@@ -8,4 +8,8 @@ Clause-②: yes (widening)
 
 - **What is added.** One function export, `navItemVisibleDataNeedsDataSource(item, ctx)`: the refinement `NavigationItemSchema` already runs, which refuses a navigation entry with no `dataSource` whose `visible` reads `data`. It is exported the way `objectNavTargetExclusivity`, `checkPageRegionPlacement` and `checkPageMainRegionWidth` are, so a hand-written mirror of the navigation item can chain the same function in its own `superRefine` instead of restating the rule.
 - **What does not change.** No schema accepts or refuses anything new. The issue is the same: one `custom` issue at `visible`, with the same message. `NavigationItemSchema` still attaches the same function, once, by name.
-- **What the function reads.** It judges the entry after the spec's parse, where `visible` is the `{ dialect, source }` envelope. A bare-string `visible` (`'data.total == 1'`, the shorthand an author writes before the spec normalises it) is not read and raises nothing. So a mirror whose own `visible` stays the authored string must hand the function the parsed `{ dialect: 'cel', source }` form, or it refuses nothing.
+- **What the function reads.** Both spellings of `visible`, so it answers the same on an entry as authored and as parsed:
+  - the authored bare string (`'data.total == 1'`), normalised by `EvaluatedExpressionInputSchema`, the slot's own schema, exactly as the spec's parse normalises it;
+  - the parsed `{ dialect: 'cel', source }` envelope.
+
+  A boolean or absent `visible` judges nothing. So a mirror whose own `visible` stays the authored string chains the function as it is and refuses what the spec refuses.
@@ -23,13 +23,15 @@
  *     cannot be running an inline copy that merely agrees on this matrix.
  *  4. BARREL identity: `./index` (what `@objectstack/spec/ui` ships) exports
  *     the very same function object, with the `(value, ctx)` arity.
- *  5. INPUT CONTRACT: the card's own entry, written with the bare-string
- *     `visible`, is refused by the door, and the export raises the identical
- *     issue on that entry's PARSED `visible`, but nothing on the bare string
- *     itself. The check judges the spec's parsed entry; a mirror whose
- *     `visible` stays the authored string gets no refusal by attaching it as
- *     it is. That is the export's docblock, measured, so a later change to
- *     what the function reads flips this leg on purpose.
+ *  5. BOTH SPELLINGS: the export accepts `visible` as authored (the bare
+ *     string a mirror whose own `visible` stays the authored string hands it)
+ *     and as parsed (the envelope the spec's door hands it), and answers the
+ *     same on both. The card's own entry as written draws the door's identical
+ *     issue from a direct call, and so does its parsed `visible`. Over the leg-1
+ *     matrix rewritten with bare strings, the direct call and the door agree
+ *     issue for issue. The same bare string with a `dataSource` draws nothing,
+ *     and neither does a boolean or absent `visible`. So a mirror attaches the
+ *     export as it is, by identifier.
  *
  * What it does NOT prove: reference identity between the export and the
  * check object the schema holds. zod 4 wraps the function handed to
@@ -245,10 +247,19 @@ describe('`./index` (the `@objectstack/spec/ui` surface) exports the same functi
 });
 
 // ---------------------------------------------------------------------------
-// Leg 5 — the input contract: the export judges the PARSED entry
+// Leg 5 — both spellings: the export reads `visible` as authored and as parsed
 // ---------------------------------------------------------------------------
 
-describe('the input contract — the export judges the entry after the spec\'s parse', () => {
+/** The leg-1 matrix with each envelope `visible` written back as the bare string an author writes. */
+const authoredFixtures: Fixture[] = fixtures
+  .filter((f) => f.value.visible !== undefined)
+  .map((f) => ({
+    ...f,
+    label: `${f.label}, \`visible\` written as the bare string`,
+    value: { ...f.value, visible: (f.value.visible as { source: string }).source },
+  }));
+
+describe('both spellings — the export reads `visible` as authored and as parsed, and answers the same', () => {
   const parsedVisible = EvaluatedExpressionInputSchema.parse(CARD_ENTRY.visible);
 
   it('the spec normalises the bare string to the envelope the check reads', () => {
@@ -265,13 +276,33 @@ describe('the input contract — the export judges the entry after the spec\'s p
     expect(runExport({ ...CARD_ENTRY, visible: parsedVisible })).toEqual(runParse(CARD_ENTRY));
   });
 
-  it('the export raises NOTHING on the bare-string spelling — a mirror must hand it the parsed entry', () => {
-    expect(runExport(CARD_ENTRY)).toEqual([]);
+  it('the export raises the door\'s identical issue (code, path and message) on the card\'s entry AS WRITTEN', () => {
+    const direct = runExport(CARD_ENTRY);
+    expect(direct).toHaveLength(1);
+    expect(direct).toEqual(runParse(CARD_ENTRY));
+  });
+
+  it.each(authoredFixtures)('$label — the direct call refuses at exactly the declared paths, issue for issue with the door', ({ value, refusesAt }) => {
+    const direct = runExport(value);
+    expect(direct.map((i) => i.path).sort()).toEqual([...refusesAt].sort());
+    expect(runParse(value)).toEqual(direct);
   });
 
-  it('the control — the same entry with a `dataSource` — is accepted by the door and by the export', () => {
+  it('the authored matrix has both kinds of path, so agreement is not vacuous', () => {
+    expect(authoredFixtures.filter((f) => f.refusesAt.length > 0).length).toBeGreaterThanOrEqual(4);
+    expect(authoredFixtures.filter((f) => f.refusesAt.length === 0).length).toBeGreaterThanOrEqual(3);
+  });
+
+  it('the control — the same bare string with a `dataSource` — draws nothing, from the door or the export', () => {
     const withSource = { ...CARD_ENTRY, dataSource: API_BINDING };
     expect(NavigationItemSchema.safeParse(withSource).success).toBe(true);
+    expect(runExport(withSource)).toEqual([]);
     expect(runExport({ ...withSource, visible: parsedVisible })).toEqual([]);
   });
+
+  it('a boolean or absent `visible` judges nothing', () => {
+    expect(runExport({ ...CARD_ENTRY, visible: true })).toEqual([]);
+    expect(runExport({ ...CARD_ENTRY, visible: false })).toEqual([]);
+    expect(runExport({ id: CARD_ENTRY.id, type: CARD_ENTRY.type, objectName: CARD_ENTRY.objectName })).toEqual([]);
+  });
 });
@@ -1017,6 +1017,17 @@ function celReadsRootData(source: string): boolean {
   return reads;
 }
 
+/**
+ * An authored bare-string `visible` as the envelope the spec's parse makes of
+ * it. It goes through {@link EvaluatedExpressionInputSchema}, the slot's own
+ * schema, so the shorthand normalisation is reused and never restated here.
+ * `undefined` when that schema refuses the string (a blank one).
+ */
+function authoredVisibleEnvelope(source: string): unknown {
+  const parsed = EvaluatedExpressionInputSchema.safeParse(source);
+  return parsed.success ? parsed.data : undefined;
+}
+
 /**
  * A navigation entry whose `visible` reads `data` must declare `dataSource` —
  * the narrowing arm of #24332's ruling, question 2 (letter A).
@@ -1029,8 +1040,8 @@ function celReadsRootData(source: string): boolean {
  * parsed, validated and shipped as an entry the console never shows, with the
  * author told nothing. Refused at the entry's own `visible`, with the fix.
  *
- * Judged on the PARSED entry, where `visible` is always the `{ dialect, source }`
- * envelope; only the `cel` dialect is read. Mounted once, on
+ * Judged on the `{ dialect, source }` envelope; only the `cel` dialect is read
+ * (see the input paragraph below for the two spellings). Mounted once, on
  * {@link NavigationItemSchema} itself, so it reaches every navigation door —
  * `app.navigation`, `app.areas[].navigation`, every `children` array at any
  * depth, and a navigation contribution's `items`. The exported per-branch
@@ -1046,20 +1057,30 @@ function celReadsRootData(source: string): boolean {
  * Exporting it moves no accept set, and its issue (`custom` at `visible`, the
  * message above) is the same at every door that runs it.
  *
- * ⚠️ What it reads is the entry AFTER the spec's parse: `visible` as the
- * `{ dialect, source }` envelope {@link EvaluatedExpressionInputSchema} turns
- * either authored spelling into. A bare-string `visible` (the authored
- * shorthand, before that normalisation) is not read and raises nothing, so a
- * mirror whose own `visible` stays the authored string refuses nothing by
- * attaching this as it is. The mount, the export, the barrel identity and that
- * input contract are pinned by
+ * It accepts both spellings of `visible`, so it answers the same on an entry
+ * as authored and on the entry the spec's parse produced:
+ *
+ * - the PARSED `{ dialect, source }` envelope, which is all the spec's own door
+ *   ever hands it;
+ * - the AUTHORED bare string (`'data.total == 1'`), which a mirror whose own
+ *   `visible` stays the authored string hands it. It is normalised by
+ *   {@link EvaluatedExpressionInputSchema}, the slot's own schema, whose string
+ *   arm turns it into `{ dialect: 'cel', source }`. It is the very normaliser
+ *   the parse runs, reused rather than restated, so a blank string it refuses
+ *   is judged by nothing here either.
+ *
+ * A boolean or absent `visible` judges nothing. So a mirror attaches this as it
+ * is, by identifier. The mount, the export, the barrel identity and both
+ * spellings are pinned by
  * `app-nav-visible-data-needs-data-source-export.test.ts`.
  */
 export function navItemVisibleDataNeedsDataSource(item: unknown, ctx: z.RefinementCtx): void {
   if (!item || typeof item !== 'object') return;
   const entry = item as { visible?: unknown; dataSource?: unknown };
   if (entry.dataSource !== undefined) return;
-  const visible = entry.visible as { dialect?: unknown; source?: unknown } | undefined;
+  const visible = (typeof entry.visible === 'string'
+    ? authoredVisibleEnvelope(entry.visible)
+    : entry.visible) as { dialect?: unknown; source?: unknown } | undefined;
   if (!visible || visible.dialect !== 'cel' || typeof visible.source !== 'string') return;
   if (!celReadsRootData(visible.source)) return;
   ctx.addIssue({