@pilotiq/pilotiq 0.24.1 → 0.24.2

package/src/relationManagerData.test.ts

@@ -1,1595 +0,0 @@
-import { describe, it, beforeEach } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { Pilotiq } from './Pilotiq.js'
-import { Resource } from './Resource.js'
-import { Page } from './Page.js'
-import { RelationManager } from './RelationManager.js'
-import { Form } from './elements/Form.js'
-import { Table } from './elements/Table.js'
-import { Column } from './Column.js'
-import { TextField } from './fields/TextField.js'
-import { Heading } from './schema/Heading.js'
-import { findRelatedResource, relationManagerData, dispatchPageData, resourceEditData, resourceViewData, resourceRecordPageData, safeManagerPolicy } from './pageData.js'
-import { PilotiqRegistry } from './PilotiqRegistry.js'
-import type { ModelLike, ModelQuery } from './orm/modelDefaults.js'
-
-// ── Test doubles ───────────────────────────────────────────────────
-
-interface QueryRow extends Record<string, unknown> { id: string | number }
-
-class StubQuery implements ModelQuery {
-  private filters: Array<{ col: string; op?: string; val: unknown }> = []
-  constructor(private rows: QueryRow[]) {}
-
-  where(...args: unknown[]): ModelQuery {
-    if (args.length === 2) this.filters.push({ col: args[0] as string, val: args[1] })
-    else this.filters.push({ col: args[0] as string, op: args[1] as string, val: args[2] })
-    return this
-  }
-  orWhere(...args: unknown[]): ModelQuery {
-    return this.where(...args)
-  }
-  orderBy(_c: string, _d?: 'ASC' | 'DESC'): ModelQuery { return this }
-
-  async paginate(_page: number, _perPage?: number) {
-    let data = this.rows
-    for (const f of this.filters) {
-      if (f.op === '=' || f.op === undefined) {
-        data = data.filter(r => r[f.col] === f.val)
-      }
-    }
-    return { data, total: data.length }
-  }
-}
-
-function stubModel(opts: { rows?: QueryRow[]; primaryKey?: string } = {}): ModelLike {
-  const rows = opts.rows ?? []
-  const M: ModelLike = {
-    async find(id) { return rows.find(r => r['id'] === id || String(r['id']) === String(id)) ?? null },
-    async create(data) { const next = { id: rows.length + 1, ...data } as QueryRow; rows.push(next); return next },
-    async update(id, data) { const r = rows.find(r => r['id'] === id); if (r) Object.assign(r, data); return r ?? null },
-    async delete(id) { const i = rows.findIndex(r => r['id'] === id); if (i >= 0) rows.splice(i, 1) },
-    query() { return new StubQuery(rows) },
-  }
-  if (opts.primaryKey !== undefined) M.primaryKey = opts.primaryKey
-  return M
-}
-
-/** Build a parent record that exposes `.related(name)` (rudder convention)
- *  yielding a StubQuery filtered by the foreign key. */
-function makeParentWithChildren(parentId: string | number, childRows: QueryRow[], fk = 'parentId') {
-  return {
-    id: parentId,
-    related(_name: string): ModelQuery {
-      // Return a StubQuery pre-filtered to just this parent's children.
-      return new StubQuery(childRows.filter(r => r[fk] === parentId))
-    },
-  }
-}
-
-/**
- * Adapt a stub `find(id)` to the `query().where(pk, id).paginate(1, 1)`
- * shape that pilotiq's `findRecord(R, id, ctx)` now drives. Returns a
- * `ModelQuery` that captures the last where-clause value and resolves
- * via the supplied finder on `paginate()`. Lets these tests keep their
- * `find(id)` stub data without rewriting fixtures into row arrays.
- */
-function findAdapter(find: (id: string) => Promise<unknown>): ModelQuery {
-  let captured: unknown
-  const q: ModelQuery = {
-    where(...args: unknown[]): ModelQuery {
-      captured = args.length === 2 ? args[1] : args[2]
-      return q
-    },
-    orWhere(...args: unknown[]): ModelQuery {
-      captured = args.length === 2 ? args[1] : args[2]
-      return q
-    },
-    orderBy(): ModelQuery { return q },
-    async paginate() {
-      const r = await find(String(captured))
-      return { data: r ? [r] : [], total: r ? 1 : 0 }
-    },
-  }
-  return q
-}
-
-// ── findRelatedResource — discovery via override + rudder convention ──
-
-describe('findRelatedResource (Plan #11)', () => {
-  it('returns the explicit relatedResource override without touching ORM metadata', () => {
-    class TargetResource extends Resource {
-      static override slug = 'targets'
-    }
-    class M extends RelationManager {
-      static override relationship    = 'targets'
-      static override relatedResource = TargetResource
-    }
-    class Parent extends Resource {
-      static override slug = 'parents'
-      static override relations() { return [M] }
-    }
-    const panel = Pilotiq.make('T').path('/admin').resources([Parent, TargetResource])
-    const got = findRelatedResource(M, Parent, panel.getConfig())
-    assert.equal(got, TargetResource)
-  })
-
-  it('discovers via rudder relations[name].model() match against cfg.resources', () => {
-    const ChildModel = stubModel()
-    const ParentModel = {
-      ...stubModel(),
-      relations: { posts: { model: () => ChildModel } },
-    } as ModelLike
-
-    class PostResource extends Resource {
-      static override slug  = 'posts'
-      static override get model() { return ChildModel }
-    }
-    class PostsManager extends RelationManager {
-      static override relationship = 'posts'
-    }
-    class UserResource extends Resource {
-      static override slug = 'users'
-      static override get model() { return ParentModel }
-      static override relations() { return [PostsManager] }
-    }
-    const panel = Pilotiq.make('T').path('/admin').resources([UserResource, PostResource])
-    const got = findRelatedResource(PostsManager, UserResource, panel.getConfig())
-    assert.equal(got, PostResource)
-  })
-
-  it('returns undefined when neither override nor rudder metadata locates a Resource', () => {
-    class M extends RelationManager {
-      static override relationship = 'orphans'
-    }
-    class Parent extends Resource {
-      static override slug = 'parents'
-      static override relations() { return [M] }
-    }
-    const panel = Pilotiq.make('T').path('/admin').resources([Parent])
-    const got = findRelatedResource(M, Parent, panel.getConfig())
-    assert.equal(got, undefined)
-  })
-})
-
-// ── relationManagerData — the three scopes ────────────────────────
-
-describe('relationManagerData (Plan #11)', () => {
-  /** Build a User → Posts test world. Returns the panel + key models so
-   *  individual tests can poke records or override hooks. */
-  function buildWorld(opts: { managerOverrides?: Partial<typeof RelationManager> } = {}) {
-    const postRows: QueryRow[] = [
-      { id: 'p1', parentId: 'u1', title: 'Post One' },
-      { id: 'p2', parentId: 'u1', title: 'Post Two' },
-      { id: 'p3', parentId: 'u2', title: 'Other User Post' },
-    ]
-    const PostModel = stubModel({ rows: postRows })
-
-    // Parent records carry their own .related() so relation-list works
-    // without touching ParentModel.relations metadata; for relation-edit
-    // we ALSO need ParentModel.relations[].model() to discover Related
-    // Resource.
-    const parents = new Map<string, ReturnType<typeof makeParentWithChildren>>([
-      ['u1', makeParentWithChildren('u1', postRows)],
-      ['u2', makeParentWithChildren('u2', postRows)],
-    ])
-    // `query()` drives the new `findRecord(R, id, ctx)` path used to load
-    // parent records (and policy-record lookups). Build a StubQuery over
-    // the parents-as-rows so `where('id', '=', X).paginate(1, 1)` resolves
-    // the same shape `find()` historically returned.
-    const parentRows: QueryRow[] = [...parents.values()].map(p => p as unknown as QueryRow)
-    const ParentModel: ModelLike = {
-      async find(id) { return parents.get(String(id)) ?? null },
-      async create() { throw new Error('not used') },
-      async update() { throw new Error('not used') },
-      async delete() { /* ok */ },
-      query() { return new StubQuery(parentRows) },
-    }
-    Object.assign(ParentModel as object, {
-      relations: { posts: { model: () => PostModel } },
-    })
-
-    class PostResource extends Resource {
-      static override label = 'Posts'
-      static override labelSingular = 'Post'
-      static override slug  = 'posts'
-      static override get model() { return PostModel }
-      static override form(form: Form): Form {
-        return form.schema([TextField.make('title').required()])
-      }
-    }
-
-    class PostsManager extends RelationManager {
-      static override relationship = 'posts'
-      static override label        = 'Posts'
-
-      static override table(table: Table): Table {
-        return table.columns([Column.make('title').sortable()])
-      }
-      static override form(form: Form): Form {
-        return form.schema([TextField.make('title').required()])
-      }
-    }
-    if (opts.managerOverrides) {
-      Object.assign(PostsManager, opts.managerOverrides)
-    }
-
-    class UserResource extends Resource {
-      static override label = 'Users'
-      static override slug  = 'users'
-      static override recordTitleAttribute = 'name'
-      static override get model() { return ParentModel }
-      static override relations() { return [PostsManager] }
-    }
-
-    const panel = Pilotiq.make('T').path('/admin').resources([UserResource, PostResource])
-    return { panel, UserResource, PostResource, PostsManager, ParentModel, PostModel, postRows, parents }
-  }
-
-  it('returns null when the parent slug is unknown', async () => {
-    const { panel } = buildWorld()
-    const out = await relationManagerData(panel, {
-      kind: 'relation-list', slug: 'missing', recordId: 'u1', relationship: 'posts',
-    })
-    assert.equal(out, null)
-  })
-
-  it('returns null when the manager relationship is unknown on the resource', async () => {
-    const { panel } = buildWorld()
-    const out = await relationManagerData(panel, {
-      kind: 'relation-list', slug: 'users', recordId: 'u1', relationship: 'comments',
-    })
-    assert.equal(out, null)
-  })
-
-  it('returns null when the parent record cannot be loaded', async () => {
-    const { panel } = buildWorld()
-    const out = await relationManagerData(panel, {
-      kind: 'relation-list', slug: 'users', recordId: 'unknown', relationship: 'posts',
-    })
-    assert.equal(out, null)
-  })
-
-  it('throws when the parent has relations() but no static model', () => {
-    class M extends RelationManager {
-      static override relationship = 'posts'
-    }
-    class Bare extends Resource {
-      static override slug = 'bare'
-      static override relations() { return [M] }
-    }
-    const panel = Pilotiq.make('T').path('/admin').resources([Bare])
-    return assert.rejects(
-      () => relationManagerData(panel, {
-        kind: 'relation-list', slug: 'bare', recordId: '1', relationship: 'posts',
-      }),
-      /has relations\(.*\) but no static model/,
-    )
-  })
-
-  describe('authorization gating', () => {
-    it('403 when parent canAccess fails', async () => {
-      class Locked extends Resource {
-        static override slug = 'users'
-        static override async canAccess() { return false }
-        static override relations() { return [class extends RelationManager {
-          static override relationship = 'posts'
-        }] }
-      }
-      const panel = Pilotiq.make('T').path('/admin').resources([Locked])
-      const out = await relationManagerData(panel, {
-        kind: 'relation-list', slug: 'users', recordId: 'u1', relationship: 'posts',
-      })
-      assert.deepEqual(out, { ok: false, status: 403 })
-    })
-
-    it('403 when parent canEdit fails', async () => {
-      const { ParentModel, PostModel } = buildWorld()
-      class M extends RelationManager {
-        static override relationship = 'posts'
-      }
-      class R2 extends Resource {
-        static override slug = 'users'
-        static override get model() { return ParentModel }
-        static override async canEdit() { return false }
-        static override relations() { return [M] }
-      }
-      class Posts extends Resource {
-        static override slug = 'posts'
-        static override get model() { return PostModel }
-      }
-      const panel = Pilotiq.make('T').path('/admin').resources([R2, Posts])
-      const out = await relationManagerData(panel, {
-        kind: 'relation-list', slug: 'users', recordId: 'u1', relationship: 'posts',
-      })
-      assert.deepEqual(out, { ok: false, status: 403 })
-    })
-
-    it('403 on relation-list when manager.canViewAny fails', async () => {
-      const { panel } = buildWorld({
-        managerOverrides: {
-          canViewAny: async () => false,
-        } as Partial<typeof RelationManager>,
-      })
-      const out = await relationManagerData(panel, {
-        kind: 'relation-list', slug: 'users', recordId: 'u1', relationship: 'posts',
-      })
-      assert.deepEqual(out, { ok: false, status: 403 })
-    })
-
-    it('403 on relation-create when manager.canCreate fails', async () => {
-      const { panel } = buildWorld({
-        managerOverrides: {
-          canCreate: async () => false,
-        } as Partial<typeof RelationManager>,
-      })
-      const out = await relationManagerData(panel, {
-        kind: 'relation-create', slug: 'users', recordId: 'u1', relationship: 'posts',
-      })
-      assert.deepEqual(out, { ok: false, status: 403 })
-    })
-
-    it('403 on relation-edit when manager.canEdit fails', async () => {
-      const { panel } = buildWorld({
-        managerOverrides: {
-          canEdit: async () => false,
-        } as Partial<typeof RelationManager>,
-      })
-      const out = await relationManagerData(panel, {
-        kind: 'relation-edit', slug: 'users', recordId: 'u1', relationship: 'posts', childId: 'p1',
-      })
-      assert.deepEqual(out, { ok: false, status: 403 })
-    })
-
-    it('403 on relation-view when manager.canView fails', async () => {
-      const { panel } = buildWorld({
-        managerOverrides: {
-          canView: async () => false,
-        } as Partial<typeof RelationManager>,
-      })
-      const out = await relationManagerData(panel, {
-        kind: 'relation-view', slug: 'users', recordId: 'u1', relationship: 'posts', childId: 'p1',
-      })
-      assert.deepEqual(out, { ok: false, status: 403 })
-    })
-  })
-
-  describe('relation-list scope', () => {
-    it('returns schemaData with the manager table, parent-scoped via .related()', async () => {
-      const { panel } = buildWorld()
-      const out = await relationManagerData(panel, {
-        kind: 'relation-list', slug: 'users', recordId: 'u1', relationship: 'posts',
-      })
-      assert.notEqual(out, null)
-      assert.notEqual((out as { ok?: boolean }).ok, false)
-      const data = out as Record<string, unknown>
-      assert.equal(data['pageType'], 'relation-list')
-      const relation = data['relation'] as Record<string, unknown>
-      assert.equal(relation['relationship'], 'posts')
-      assert.equal(relation['relatedSlug'], 'posts')
-      const parent = data['parent'] as Record<string, unknown>
-      assert.equal(parent['id'], 'u1')
-
-      // Auto-wired records loader produced rows scoped to u1's children.
-      const schema = data['schemaData'] as Array<Record<string, unknown>>
-      const tableMeta = schema.find(s => s['type'] === 'table')
-      assert.ok(tableMeta, 'expected a table element in schemaData')
-      const rows = (tableMeta['rows'] as Array<Record<string, unknown>>) ?? []
-      assert.equal(rows.length, 2)  // u1 has p1 + p2 only, never p3
-      assert.deepEqual(rows.map(r => r['id']).sort(), ['p1', 'p2'])
-    })
-  })
-
-  describe('relation-create scope', () => {
-    it('returns schemaData with form + create url stamped', async () => {
-      const { panel } = buildWorld()
-      const out = await relationManagerData(panel, {
-        kind: 'relation-create', slug: 'users', recordId: 'u1', relationship: 'posts',
-      })
-      assert.notEqual(out, null)
-      const data = out as Record<string, unknown>
-      assert.equal(data['pageType'], 'relation-create')
-      assert.equal(data['mode'], 'create')
-
-      const schema = data['schemaData'] as Array<Record<string, unknown>>
-      const formMeta = schema.find(s => s['type'] === 'form')
-      assert.ok(formMeta, 'expected a form element in schemaData')
-      assert.equal(formMeta['action'], '/admin/users/u1/posts/create')
-    })
-
-    it('honors prefill values and errors', async () => {
-      const { panel } = buildWorld()
-      const out = await relationManagerData(panel, {
-        kind: 'relation-create', slug: 'users', recordId: 'u1', relationship: 'posts',
-        prefill: { values: { title: 'Draft' }, errors: { title: ['Required'] } },
-      })
-      const data = out as Record<string, unknown>
-      assert.equal(data['hasErrors'], true)
-      const schema = data['schemaData'] as Array<Record<string, unknown>>
-      const formMeta = schema.find(s => s['type'] === 'form') as Record<string, unknown>
-      assert.equal((formMeta['values'] as Record<string, unknown>)['title'], 'Draft')
-      assert.deepEqual((formMeta['errors'] as Record<string, string[]>)['title'], ['Required'])
-    })
-  })
-
-  describe('relation-view scope', () => {
-    it('loads child + verifies it belongs to the parent (anti-IDOR)', async () => {
-      const { panel } = buildWorld({
-        managerOverrides: {
-          // Override detail() so we can assert the child + parent reach the
-          // schema. Heading text echoes the child's title.
-          detail(record: unknown, parentRecord: unknown) {
-            const child = record as Record<string, unknown>
-            const parent = parentRecord as Record<string, unknown>
-            return [Heading.make(`${parent['id']}: ${child['title']}`)]
-          },
-        } as Partial<typeof RelationManager>,
-      })
-      const out = await relationManagerData(panel, {
-        kind: 'relation-view', slug: 'users', recordId: 'u1', relationship: 'posts', childId: 'p1',
-      })
-      assert.notEqual(out, null)
-      const data = out as Record<string, unknown>
-      assert.equal(data['pageType'], 'relation-view')
-      assert.equal(data['mode'], 'view')
-      assert.equal(data['childId'], 'p1')
-
-      const schema = data['schemaData'] as Array<Record<string, unknown>>
-      const heading = schema.find(s => s['type'] === 'heading') as Record<string, unknown>
-      // detail(child, parent) was invoked with both records.
-      assert.equal(heading['content'], 'u1: Post One')
-    })
-
-    it('returns null when the child belongs to a different parent (IDOR)', async () => {
-      const { panel } = buildWorld()
-      // p3 is u2's post — trying to view it under u1 must fail.
-      const out = await relationManagerData(panel, {
-        kind: 'relation-view', slug: 'users', recordId: 'u1', relationship: 'posts', childId: 'p3',
-      })
-      assert.equal(out, null)
-    })
-
-    it('returns null when the child does not exist at all', async () => {
-      const { panel } = buildWorld()
-      const out = await relationManagerData(panel, {
-        kind: 'relation-view', slug: 'users', recordId: 'u1', relationship: 'posts', childId: 'nonexistent',
-      })
-      assert.equal(out, null)
-    })
-
-    it('renders an empty schema (RelationTabs only) when the manager does not override detail()', async () => {
-      const { panel } = buildWorld()
-      const out = await relationManagerData(panel, {
-        kind: 'relation-view', slug: 'users', recordId: 'u1', relationship: 'posts', childId: 'p1',
-      })
-      const data = out as Record<string, unknown>
-      const schema = data['schemaData'] as Array<Record<string, unknown>>
-      // Default Manager.detail() returns []; the page surfaces only the
-      // breadcrumbs (Phase C) + the RelationTabs strip — no detail body.
-      assert.deepEqual(
-        schema.map(s => s['type']),
-        ['breadcrumbs', 'relation-tabs'],
-      )
-    })
-
-    it('marks the manager tab active in the RelationTabs strip', async () => {
-      const { panel } = buildWorld()
-      const out = await relationManagerData(panel, {
-        kind: 'relation-view', slug: 'users', recordId: 'u1', relationship: 'posts', childId: 'p1',
-      })
-      const data = out as Record<string, unknown>
-      const schema = data['schemaData'] as Array<Record<string, unknown>>
-      const tabs = schema.find(s => s['type'] === 'relation-tabs') as Record<string, unknown>
-      const tabList = tabs['tabs'] as Array<Record<string, unknown>>
-      const postsTab = tabList.find(t => t['key'] === 'posts')
-      assert.ok(postsTab, 'posts manager tab should be present')
-      assert.equal(postsTab!['active'], true)
-      // Sibling parent tabs render but are inactive.
-      const viewTab = tabList.find(t => t['key'] === '__view')
-      assert.equal(viewTab?.['active'], false)
-    })
-
-    it('breadcrumb leaf reads RelationManager.recordTitleAttribute over Resource fallback', async () => {
-      // Manager picks `parentId` for the leaf title; the related Resource
-      // doesn't set recordTitleAttribute, so without the manager override
-      // the fallback chain would land on `title` ("Post One").
-      const { panel } = buildWorld({
-        managerOverrides: { recordTitleAttribute: 'parentId' } as Partial<typeof RelationManager>,
-      })
-      const out = await relationManagerData(panel, {
-        kind: 'relation-view', slug: 'users', recordId: 'u1', relationship: 'posts', childId: 'p1',
-      })
-      const data = out as Record<string, unknown>
-      const schema = data['schemaData'] as Array<Record<string, unknown>>
-      const crumbs = schema.find(s => s['type'] === 'breadcrumbs') as Record<string, unknown>
-      const items = crumbs['items'] as Array<Record<string, unknown>>
-      assert.equal(items.at(-1)!['label'], 'u1')
-    })
-  })
-
-  describe('relation-edit scope', () => {
-    it('loads child + verifies it belongs to the parent (anti-IDOR)', async () => {
-      const { panel } = buildWorld()
-      const out = await relationManagerData(panel, {
-        kind: 'relation-edit', slug: 'users', recordId: 'u1', relationship: 'posts', childId: 'p1',
-      })
-      assert.notEqual(out, null)
-      const data = out as Record<string, unknown>
-      assert.equal(data['pageType'], 'relation-edit')
-      assert.equal(data['mode'], 'edit')
-      assert.equal(data['childId'], 'p1')
-
-      const schema = data['schemaData'] as Array<Record<string, unknown>>
-      const formMeta = schema.find(s => s['type'] === 'form') as Record<string, unknown>
-      // Child p1 belongs to u1 → its title should be filled in.
-      assert.equal((formMeta['values'] as Record<string, unknown>)['title'], 'Post One')
-      assert.equal(formMeta['action'], '/admin/users/u1/posts/p1/edit')
-    })
-
-    it('returns null when the child belongs to a different parent (IDOR)', async () => {
-      const { panel } = buildWorld()
-      // p3 is u2's post — trying to edit it under u1 must fail.
-      const out = await relationManagerData(panel, {
-        kind: 'relation-edit', slug: 'users', recordId: 'u1', relationship: 'posts', childId: 'p3',
-      })
-      assert.equal(out, null)
-    })
-
-    it('returns null when the child does not exist at all', async () => {
-      const { panel } = buildWorld()
-      const out = await relationManagerData(panel, {
-        kind: 'relation-edit', slug: 'users', recordId: 'u1', relationship: 'posts', childId: 'nonexistent',
-      })
-      assert.equal(out, null)
-    })
-
-    it('honors prefill on a 422 re-render', async () => {
-      const { panel } = buildWorld()
-      const out = await relationManagerData(panel, {
-        kind: 'relation-edit', slug: 'users', recordId: 'u1', relationship: 'posts', childId: 'p1',
-        prefill: { values: { title: 'User-typed value' }, errors: { title: ['Too short'] } },
-      })
-      const data = out as Record<string, unknown>
-      const schema = data['schemaData'] as Array<Record<string, unknown>>
-      const formMeta = schema.find(s => s['type'] === 'form') as Record<string, unknown>
-      assert.equal((formMeta['values'] as Record<string, unknown>)['title'], 'User-typed value')
-      assert.deepEqual((formMeta['errors'] as Record<string, string[]>)['title'], ['Too short'])
-      assert.equal(data['hasErrors'], true)
-    })
-  })
-})
-
-// ── Plan #11 — safeManagerPolicy related-resource fall-through (Step 8) ─
-
-describe('safeManagerPolicy (Plan #11 step 8)', () => {
-  it('runs the manager predicate when overridden', async () => {
-    let called = false
-    class M extends RelationManager {
-      static override relationship = 'posts'
-      static override async canCreate(_u: unknown, _p: unknown) { called = true; return true }
-    }
-    const result = await safeManagerPolicy(M, 'canCreate', undefined, 'user', { id: 1 })
-    assert.equal(result, true)
-    assert.equal(called, true, 'overridden manager predicate should be invoked')
-  })
-
-  it('falls through to Related.canX when the manager predicate is the default', async () => {
-    let managerCalled = false
-    let relatedCalled = false
-    class M extends RelationManager {
-      static override relationship = 'posts'
-      // NOT overridden — inherits from RelationManager
-    }
-    class Related extends Resource {
-      static override slug = 'posts'
-      static override async canCreate(_u: unknown) { relatedCalled = true; return false }
-    }
-    // Spy on the inherited default to ensure we DIDN'T call it.
-    const origDefault = RelationManager.canCreate
-    const spy: typeof RelationManager.canCreate = async () => { managerCalled = true; return true }
-    RelationManager.canCreate = spy
-    try {
-      const result = await safeManagerPolicy(M, 'canCreate', Related, 'user', { id: 1 })
-      assert.equal(result, false)
-      assert.equal(managerCalled, false, 'default manager predicate should be skipped when Related is configured')
-      assert.equal(relatedCalled, true, 'Related predicate should run when manager is default')
-    } finally {
-      RelationManager.canCreate = origDefault
-    }
-  })
-
-  it('strips the parent argument when calling the related Resource predicate', async () => {
-    const captured: unknown[][] = []
-    class M extends RelationManager {
-      static override relationship = 'posts'
-    }
-    class Related extends Resource {
-      static override slug = 'posts'
-      static override async canEdit(...args: unknown[]) { captured.push(args); return true }
-    }
-    await safeManagerPolicy(M, 'canEdit', Related, 'user', { id: 'parent-1' }, { id: 'child-1' })
-    // Resource.canEdit signature is (user, record) — the parent arg is dropped.
-    assert.deepEqual(captured, [['user', { id: 'child-1' }]])
-  })
-
-  it('allows when both manager and Related are default', async () => {
-    class M extends RelationManager { static override relationship = 'posts' }
-    const result = await safeManagerPolicy(M, 'canCreate', undefined, 'user', { id: 1 })
-    assert.equal(result, true)
-  })
-
-  it('fails closed when an overridden predicate throws', async () => {
-    class M extends RelationManager {
-      static override relationship = 'posts'
-      static override async canCreate(): Promise<boolean> { throw new Error('boom') }
-    }
-    const result = await safeManagerPolicy(M, 'canCreate', undefined, 'user', { id: 1 })
-    assert.equal(result, false)
-  })
-
-  it('integrates: relation-list 403 when Related.canViewAny denies and manager is default', async () => {
-    const postRows: QueryRow[] = [{ id: 'p1', parentId: 'u1' }]
-    const PostModel = stubModel({ rows: postRows })
-    const ParentModel: ModelLike = {
-      async find(_id) { return makeParentWithChildren('u1', postRows) },
-      async create() { throw new Error('not used') },
-      async update() { throw new Error('not used') },
-      async delete() { /* ok */ },
-      query(): ModelQuery { return findAdapter((this as ModelLike).find as (id: string) => Promise<unknown>) },
-    }
-    Object.assign(ParentModel as object, { relations: { posts: { model: () => PostModel } } })
-
-    class PostResource extends Resource {
-      static override slug = 'posts'
-      static override get model() { return PostModel }
-      // Related denies — manager is default → fall-through must propagate.
-      static override async canViewAny() { return false }
-    }
-    class PostsManager extends RelationManager {
-      static override relationship = 'posts'
-      static override table(t: Table): Table { return t.columns([Column.make('title')]) }
-    }
-    class UserResource extends Resource {
-      static override slug = 'users'
-      static override get model() { return ParentModel }
-      static override relations() { return [PostsManager] }
-    }
-    const panel = Pilotiq.make('FT-' + Math.random()).path('/admin').resources([UserResource, PostResource])
-    const out = await relationManagerData(panel, {
-      kind: 'relation-list', slug: 'users', recordId: 'u1', relationship: 'posts',
-    })
-    assert.deepEqual(out, { ok: false, status: 403 })
-  })
-
-  it('integrates: manager override beats Related — even when Related allows', async () => {
-    const postRows: QueryRow[] = [{ id: 'p1', parentId: 'u1' }]
-    const PostModel = stubModel({ rows: postRows })
-    const ParentModel: ModelLike = {
-      async find(_id) { return makeParentWithChildren('u1', postRows) },
-      async create() { throw new Error('not used') },
-      async update() { throw new Error('not used') },
-      async delete() { /* ok */ },
-      query(): ModelQuery { return findAdapter((this as ModelLike).find as (id: string) => Promise<unknown>) },
-    }
-    Object.assign(ParentModel as object, { relations: { posts: { model: () => PostModel } } })
-
-    class PostResource extends Resource {
-      static override slug = 'posts'
-      static override get model() { return PostModel }
-      static override async canViewAny() { return true }   // Related allows
-    }
-    class PostsManager extends RelationManager {
-      static override relationship = 'posts'
-      static override async canViewAny() { return false }  // manager denies — wins
-      static override table(t: Table): Table { return t.columns([Column.make('title')]) }
-    }
-    class UserResource extends Resource {
-      static override slug = 'users'
-      static override get model() { return ParentModel }
-      static override relations() { return [PostsManager] }
-    }
-    const panel = Pilotiq.make('FT2-' + Math.random()).path('/admin').resources([UserResource, PostResource])
-    const out = await relationManagerData(panel, {
-      kind: 'relation-list', slug: 'users', recordId: 'u1', relationship: 'posts',
-    })
-    assert.deepEqual(out, { ok: false, status: 403 })
-  })
-})
-
-// ── Plan #11 — auto-mounted RelationTabs strip (Step 7) ─────────────
-
-describe('relation tabs auto-mount (Plan #11)', () => {
-  it('relation-list page prepends RelationTabs with the manager tab active', async () => {
-    const postRows: QueryRow[] = [{ id: 'p1', parentId: 'u1', title: 'Post One' }]
-    const PostModel = stubModel({ rows: postRows })
-    const ParentModel: ModelLike = {
-      async find(_id) { return makeParentWithChildren('u1', postRows) },
-      async create() { throw new Error('not used') },
-      async update() { throw new Error('not used') },
-      async delete() { /* ok */ },
-      query(): ModelQuery { return findAdapter((this as ModelLike).find as (id: string) => Promise<unknown>) },
-    }
-    Object.assign(ParentModel as object, { relations: { posts: { model: () => PostModel } } })
-
-    class PostResource extends Resource {
-      static override slug = 'posts'
-      static override get model() { return PostModel }
-    }
-    class PostsManager extends RelationManager {
-      static override relationship = 'posts'
-      static override label        = 'Posts'
-      static override table(t: Table): Table { return t.columns([Column.make('title')]) }
-    }
-    class CommentsManager extends RelationManager {
-      static override relationship = 'comments'
-      static override label        = 'Comments'
-      static override table(t: Table): Table { return t.columns([Column.make('body')]) }
-    }
-    class UserResource extends Resource {
-      static override slug  = 'users'
-      static override get model() { return ParentModel }
-      static override relations() { return [PostsManager, CommentsManager] }
-    }
-    const panel = Pilotiq.make('TabsT-' + Math.random()).path('/admin').resources([UserResource, PostResource])
-
-    const out = await relationManagerData(panel, {
-      kind: 'relation-list', slug: 'users', recordId: 'u1', relationship: 'posts',
-    })
-    const data = out as Record<string, unknown>
-    const schema = data['schemaData'] as Array<Record<string, unknown>>
-    const tabsMeta = schema.find(s => s['type'] === 'relation-tabs') as Record<string, unknown>
-    assert.ok(tabsMeta, 'expected relation-tabs strip prepended')
-
-    const tabs = tabsMeta['tabs'] as Array<{ key: string; label: string; url: string; active: boolean }>
-    // Sub-nav follow-up: View + Edit are now sibling tabs, so the
-    // strip is `[View, Edit, Posts, Comments]` rather than the prior
-    // `[Edit, Posts, Comments]`.
-    assert.equal(tabs.length, 4)
-    assert.equal(tabs[0]?.key, '__view')
-    assert.equal(tabs[0]?.label, 'View')
-    assert.equal(tabs[0]?.url, '/admin/users/u1')
-    assert.equal(tabs[0]?.active, false)
-    assert.equal(tabs[1]?.key, '__edit')
-    assert.equal(tabs[1]?.label, 'Edit')
-    assert.equal(tabs[1]?.url, '/admin/users/u1/edit')
-    assert.equal(tabs[1]?.active, false)
-    assert.equal(tabs[2]?.key, 'posts')
-    assert.equal(tabs[2]?.url, '/admin/users/u1/posts')
-    assert.equal(tabs[2]?.active, true)     // posts is the active tab
-    assert.equal(tabs[3]?.key, 'comments')
-    assert.equal(tabs[3]?.active, false)
-  })
-
-  it('skips the strip entirely when the resource has no relation managers', async () => {
-    class OnlyR extends Resource {
-      static override slug = 'only'
-    }
-    const panel = Pilotiq.make('NoRel-' + Math.random()).path('/admin').resources([OnlyR])
-    // Touch resourceIndex/resourceCreate; we only care about Edit which depends
-    // on R.model and pages. Easier: assert directly that buildRelationTabs would
-    // not run by checking a manager-less relation-list call returns null (no
-    // manager named 'whatever' exists), which is the expected guard.
-    const out = await relationManagerData(panel, {
-      kind: 'relation-list', slug: 'only', recordId: '1', relationship: 'whatever',
-    })
-    assert.equal(out, null)
-  })
-
-  it('resource-edit page prepends RelationTabs with the Edit tab active', async () => {
-    const postRows: QueryRow[] = [{ id: 'p1', parentId: 'u1', title: 'Post One' }]
-    const PostModel = stubModel({ rows: postRows })
-    const ParentModel: ModelLike = stubModel({
-      rows: [{ id: 'u1', name: 'Alice' }, { id: 'u2', name: 'Bob' }],
-    })
-    Object.assign(ParentModel as object, { relations: { posts: { model: () => PostModel } } })
-
-    class PostResource extends Resource {
-      static override slug = 'posts'
-      static override get model() { return PostModel }
-    }
-    class PostsManager extends RelationManager {
-      static override relationship = 'posts'
-      static override label        = 'Posts'
-      static override table(t: Table): Table { return t.columns([Column.make('title')]) }
-    }
-    class UserResource extends Resource {
-      static override slug = 'users'
-      static override recordTitleAttribute = 'name'
-      static override get model() { return ParentModel }
-      static override form(form: Form): Form { return form.schema([TextField.make('name')]) }
-      static override relations() { return [PostsManager] }
-    }
-    const panel = Pilotiq.make('EditTab-' + Math.random()).path('/admin').resources([UserResource, PostResource])
-    const out = await resourceEditData(panel, 'users', 'u1')
-    const schema = (out as Record<string, unknown>)['schemaData'] as Array<Record<string, unknown>>
-    const tabsMeta = schema.find(s => s['type'] === 'relation-tabs') as Record<string, unknown>
-    assert.ok(tabsMeta, 'resource-edit should auto-mount RelationTabs')
-    const tabs = tabsMeta['tabs'] as Array<{ key: string; active: boolean; url: string }>
-    // Sub-nav: View tab now sits ahead of Edit. Edit stays the active
-    // tab on the resource-edit page.
-    assert.equal(tabs[0]?.key, '__view')
-    assert.equal(tabs[0]?.active, false)
-    assert.equal(tabs[1]?.key, '__edit')
-    assert.equal(tabs[1]?.active, true)
-    assert.equal(tabs[2]?.key, 'posts')
-    assert.equal(tabs[2]?.active, false)
-  })
-
-  it('resource-view page prepends RelationTabs with the View tab active', async () => {
-    const postRows: QueryRow[] = []
-    const PostModel = stubModel({ rows: postRows })
-    const ParentModel: ModelLike = stubModel({ rows: [{ id: 'u1', name: 'Alice' }] })
-    Object.assign(ParentModel as object, { relations: { posts: { model: () => PostModel } } })
-
-    class PostResource extends Resource {
-      static override slug = 'posts'
-      static override get model() { return PostModel }
-    }
-    class PostsManager extends RelationManager {
-      static override relationship = 'posts'
-    }
-    class UserResource extends Resource {
-      static override slug = 'users'
-      static override get model() { return ParentModel }
-      static override detail() { return [] }
-      static override relations() { return [PostsManager] }
-    }
-    const panel = Pilotiq.make('ViewTab-' + Math.random()).path('/admin').resources([UserResource, PostResource])
-    const out = await resourceViewData(panel, 'users', 'u1')
-    const schema = (out as Record<string, unknown>)['schemaData'] as Array<Record<string, unknown>>
-    const tabsMeta = schema.find(s => s['type'] === 'relation-tabs') as Record<string, unknown> | undefined
-    assert.ok(tabsMeta, 'resource-view should auto-mount RelationTabs')
-    const tabs = tabsMeta['tabs'] as Array<{ key: string; label: string; url: string; active: boolean }>
-    assert.equal(tabs[0]?.key, '__view')
-    assert.equal(tabs[0]?.label, 'View')
-    assert.equal(tabs[0]?.url, '/admin/users/u1')
-    assert.equal(tabs[0]?.active, true)
-    // Edit tab is now a sibling on the View page too.
-    assert.equal(tabs[1]?.key, '__edit')
-    assert.equal(tabs[1]?.label, 'Edit')
-    assert.equal(tabs[1]?.url, '/admin/users/u1/edit')
-    assert.equal(tabs[1]?.active, false)
-  })
-
-  it('drops the View tab when ViewPage is pruned via static pages()', async () => {
-    const postRows: QueryRow[] = [{ id: 'p1', parentId: 'u1', title: 'Post One' }]
-    const PostModel = stubModel({ rows: postRows })
-    const ParentModel: ModelLike = {
-      async find(_id) { return makeParentWithChildren('u1', postRows) },
-      async create() { throw new Error('not used') },
-      async update() { throw new Error('not used') },
-      async delete() { /* ok */ },
-      query(): ModelQuery { return findAdapter((this as ModelLike).find as (id: string) => Promise<unknown>) },
-    }
-    Object.assign(ParentModel as object, { relations: { posts: { model: () => PostModel } } })
-
-    class PostResource extends Resource {
-      static override slug = 'posts'
-      static override get model() { return PostModel }
-    }
-    class PostsManager extends RelationManager {
-      static override relationship = 'posts'
-      static override table(t: Table): Table { return t.columns([Column.make('title')]) }
-    }
-    class UserResource extends Resource {
-      static override slug = 'users'
-      static override get model() { return ParentModel }
-      static override relations() { return [PostsManager] }
-      // Prune ViewPage — defaults shipped one but the user opted out.
-      static override pages() { return { view: undefined as never } }
-    }
-    const panel = Pilotiq.make('NoView-' + Math.random()).path('/admin').resources([UserResource, PostResource])
-
-    const out = await relationManagerData(panel, {
-      kind: 'relation-list', slug: 'users', recordId: 'u1', relationship: 'posts',
-    })
-    const schema = (out as Record<string, unknown>)['schemaData'] as Array<Record<string, unknown>>
-    const tabsMeta = schema.find(s => s['type'] === 'relation-tabs') as Record<string, unknown>
-    const tabs = tabsMeta['tabs'] as Array<{ key: string }>
-    // No __view, just __edit + the manager.
-    assert.deepEqual(tabs.map(t => t.key), ['__edit', 'posts'])
-  })
-
-  it('drops the Edit tab when EditPage is pruned via static pages()', async () => {
-    const postRows: QueryRow[] = [{ id: 'p1', parentId: 'u1', title: 'Post One' }]
-    const PostModel = stubModel({ rows: postRows })
-    const ParentModel: ModelLike = {
-      async find(_id) { return makeParentWithChildren('u1', postRows) },
-      async create() { throw new Error('not used') },
-      async update() { throw new Error('not used') },
-      async delete() { /* ok */ },
-      query(): ModelQuery { return findAdapter((this as ModelLike).find as (id: string) => Promise<unknown>) },
-    }
-    Object.assign(ParentModel as object, { relations: { posts: { model: () => PostModel } } })
-
-    class PostResource extends Resource {
-      static override slug = 'posts'
-      static override get model() { return PostModel }
-    }
-    class PostsManager extends RelationManager {
-      static override relationship = 'posts'
-      static override table(t: Table): Table { return t.columns([Column.make('title')]) }
-    }
-    class UserResource extends Resource {
-      static override slug = 'users'
-      static override get model() { return ParentModel }
-      static override relations() { return [PostsManager] }
-      static override pages() { return { edit: undefined as never } }
-    }
-    const panel = Pilotiq.make('NoEdit-' + Math.random()).path('/admin').resources([UserResource, PostResource])
-
-    const out = await relationManagerData(panel, {
-      kind: 'relation-list', slug: 'users', recordId: 'u1', relationship: 'posts',
-    })
-    const schema = (out as Record<string, unknown>)['schemaData'] as Array<Record<string, unknown>>
-    const tabsMeta = schema.find(s => s['type'] === 'relation-tabs') as Record<string, unknown>
-    const tabs = tabsMeta['tabs'] as Array<{ key: string }>
-    assert.deepEqual(tabs.map(t => t.key), ['__view', 'posts'])
-  })
-
-  // ── Per-tab canX gating ──────────────────────────────────
-
-  it('hides the View tab when R.canView returns false for this record', async () => {
-    const postRows: QueryRow[] = [{ id: 'p1', parentId: 'u1', title: 'Post One' }]
-    const PostModel = stubModel({ rows: postRows })
-    const ParentModel: ModelLike = stubModel({ rows: [{ id: 'u1', name: 'Alice' }] })
-    Object.assign(ParentModel as object, { relations: { posts: { model: () => PostModel } } })
-
-    class PostResource extends Resource {
-      static override slug = 'posts'
-      static override get model() { return PostModel }
-    }
-    class PostsManager extends RelationManager {
-      static override relationship = 'posts'
-    }
-    class UserResource extends Resource {
-      static override slug = 'users'
-      static override get model() { return ParentModel }
-      static override detail() { return [] }
-      static override relations() { return [PostsManager] }
-      static override async canView(): Promise<boolean> { return false }
-    }
-    const panel = Pilotiq.make('NoCanView-' + Math.random()).path('/admin').resources([UserResource, PostResource])
-
-    // Use resource-edit so the route doesn't 403 before we render — we
-    // want to see the strip itself drop the View tab.
-    const out = await resourceEditData(panel, 'users', 'u1')
-    const schema = (out as Record<string, unknown>)['schemaData'] as Array<Record<string, unknown>>
-    const tabsMeta = schema.find(s => s['type'] === 'relation-tabs') as Record<string, unknown>
-    const tabs = tabsMeta['tabs'] as Array<{ key: string }>
-    assert.deepEqual(tabs.map(t => t.key), ['__edit', 'posts'])
-  })
-
-  it('hides the Edit tab when R.canEdit returns false for this record', async () => {
-    const postRows: QueryRow[] = []
-    const PostModel = stubModel({ rows: postRows })
-    const ParentModel: ModelLike = stubModel({ rows: [{ id: 'u1', name: 'Alice' }] })
-    Object.assign(ParentModel as object, { relations: { posts: { model: () => PostModel } } })
-
-    class PostResource extends Resource {
-      static override slug = 'posts'
-      static override get model() { return PostModel }
-    }
-    class PostsManager extends RelationManager {
-      static override relationship = 'posts'
-    }
-    class UserResource extends Resource {
-      static override slug = 'users'
-      static override get model() { return ParentModel }
-      static override detail() { return [] }
-      static override relations() { return [PostsManager] }
-      static override async canEdit(): Promise<boolean> { return false }
-    }
-    const panel = Pilotiq.make('NoCanEdit-' + Math.random()).path('/admin').resources([UserResource, PostResource])
-
-    const out = await resourceViewData(panel, 'users', 'u1')
-    const schema = (out as Record<string, unknown>)['schemaData'] as Array<Record<string, unknown>>
-    const tabsMeta = schema.find(s => s['type'] === 'relation-tabs') as Record<string, unknown>
-    const tabs = tabsMeta['tabs'] as Array<{ key: string }>
-    assert.deepEqual(tabs.map(t => t.key), ['__view', 'posts'])
-  })
-
-  it('hides a manager tab when M.canViewAny returns false', async () => {
-    const postRows: QueryRow[] = []
-    const commentRows: QueryRow[] = []
-    const PostModel = stubModel({ rows: postRows })
-    const CommentModel = stubModel({ rows: commentRows })
-    const ParentModel: ModelLike = stubModel({ rows: [{ id: 'u1', name: 'Alice' }] })
-    Object.assign(ParentModel as object, { relations: {
-      posts:    { model: () => PostModel },
-      comments: { model: () => CommentModel },
-    } })
-
-    class PostResource extends Resource {
-      static override slug = 'posts'
-      static override get model() { return PostModel }
-    }
-    class CommentResource extends Resource {
-      static override slug = 'comments'
-      static override get model() { return CommentModel }
-    }
-    class PostsManager extends RelationManager {
-      static override relationship = 'posts'
-    }
-    class CommentsManager extends RelationManager {
-      static override relationship = 'comments'
-      static override async canViewAny(): Promise<boolean> { return false }
-    }
-    class UserResource extends Resource {
-      static override slug = 'users'
-      static override get model() { return ParentModel }
-      static override detail() { return [] }
-      static override relations() { return [PostsManager, CommentsManager] }
-    }
-    const panel = Pilotiq.make('GatedMgr-' + Math.random()).path('/admin').resources([UserResource, PostResource, CommentResource])
-
-    const out = await resourceViewData(panel, 'users', 'u1')
-    const schema = (out as Record<string, unknown>)['schemaData'] as Array<Record<string, unknown>>
-    const tabsMeta = schema.find(s => s['type'] === 'relation-tabs') as Record<string, unknown>
-    const tabs = tabsMeta['tabs'] as Array<{ key: string }>
-    // CommentsManager is gone — Posts survives because it inherits the
-    // default `canViewAny → true`.
-    assert.deepEqual(tabs.map(t => t.key), ['__view', '__edit', 'posts'])
-  })
-
-  it('falls through to Related.canViewAny when manager has not overridden', async () => {
-    const postRows: QueryRow[] = []
-    const PostModel = stubModel({ rows: postRows })
-    const ParentModel: ModelLike = stubModel({ rows: [{ id: 'u1', name: 'Alice' }] })
-    Object.assign(ParentModel as object, { relations: { posts: { model: () => PostModel } } })
-
-    class PostResource extends Resource {
-      static override slug = 'posts'
-      static override get model() { return PostModel }
-      // Related-side gate fires through safeManagerPolicy fall-through
-      // since PostsManager doesn't override canViewAny.
-      static override async canViewAny(): Promise<boolean> { return false }
-    }
-    class PostsManager extends RelationManager {
-      static override relationship  = 'posts'
-      static override relatedResource = PostResource
-    }
-    class UserResource extends Resource {
-      static override slug = 'users'
-      static override get model() { return ParentModel }
-      static override detail() { return [] }
-      static override relations() { return [PostsManager] }
-    }
-    const panel = Pilotiq.make('RelatedGate-' + Math.random()).path('/admin').resources([UserResource, PostResource])
-
-    const out = await resourceViewData(panel, 'users', 'u1')
-    const schema = (out as Record<string, unknown>)['schemaData'] as Array<Record<string, unknown>>
-    const tabsMeta = schema.find(s => s['type'] === 'relation-tabs') as Record<string, unknown> | undefined
-    // With Posts gone, only the parent View+Edit tabs survive. The
-    // strip drops to under 2 manager-able entries so it stays mounted
-    // (View+Edit isn't worth-it; the depth-1 code path keeps the strip
-    // because the dropped tab was a manager, not a parent tab).
-    const tabs = (tabsMeta?.['tabs'] as Array<{ key: string }>) ?? []
-    assert.equal(tabs.find(t => t.key === 'posts'), undefined)
-  })
-
-  it('throwing canX predicate fails closed (tab hidden)', async () => {
-    const postRows: QueryRow[] = []
-    const PostModel = stubModel({ rows: postRows })
-    const ParentModel: ModelLike = stubModel({ rows: [{ id: 'u1', name: 'Alice' }] })
-    Object.assign(ParentModel as object, { relations: { posts: { model: () => PostModel } } })
-
-    class PostResource extends Resource {
-      static override slug = 'posts'
-      static override get model() { return PostModel }
-    }
-    class PostsManager extends RelationManager {
-      static override relationship = 'posts'
-    }
-    class UserResource extends Resource {
-      static override slug = 'users'
-      static override get model() { return ParentModel }
-      static override detail() { return [] }
-      static override relations() { return [PostsManager] }
-      static override async canView(): Promise<boolean> { throw new Error('boom') }
-    }
-    const panel = Pilotiq.make('ThrowCanView-' + Math.random()).path('/admin').resources([UserResource, PostResource])
-
-    const out = await resourceEditData(panel, 'users', 'u1')
-    const schema = (out as Record<string, unknown>)['schemaData'] as Array<Record<string, unknown>>
-    const tabsMeta = schema.find(s => s['type'] === 'relation-tabs') as Record<string, unknown>
-    const tabs = tabsMeta['tabs'] as Array<{ key: string }>
-    // canView threw → fail closed (hidden). canEdit + Posts survive.
-    assert.deepEqual(tabs.map(t => t.key), ['__edit', 'posts'])
-  })
-
-  it('drops the strip entirely when every manager tab is gated away on the View page', async () => {
-    const postRows: QueryRow[] = []
-    const PostModel = stubModel({ rows: postRows })
-    const ParentModel: ModelLike = stubModel({ rows: [{ id: 'u1', name: 'Alice' }] })
-    Object.assign(ParentModel as object, { relations: { posts: { model: () => PostModel } } })
-
-    class PostResource extends Resource {
-      static override slug = 'posts'
-      static override get model() { return PostModel }
-    }
-    class PostsManager extends RelationManager {
-      static override relationship = 'posts'
-      static override async canViewAny(): Promise<boolean> { return false }
-    }
-    class UserResource extends Resource {
-      static override slug = 'users'
-      static override get model() { return ParentModel }
-      static override detail() { return [] }
-      static override relations() { return [PostsManager] }
-      static override async canView(): Promise<boolean> { return false }
-      static override async canEdit(): Promise<boolean> { return false }
-    }
-    const panel = Pilotiq.make('AllGated-' + Math.random()).path('/admin').resources([UserResource, PostResource])
-
-    const out = await resourceEditData(panel, 'users', 'u1')
-    const schema = (out as Record<string, unknown>)['schemaData'] as Array<Record<string, unknown>>
-    const tabsMeta = schema.find(s => s['type'] === 'relation-tabs')
-    // No tabs survive — strip omitted entirely.
-    assert.equal(tabsMeta, undefined)
-  })
-})
-
-// ── Plan #11 — dispatchPageData wiring (Vike +data SPA path) ────────
-
-describe('dispatchPageData → relation pages (Plan #11)', () => {
-  function buildPanel() {
-    const postRows: QueryRow[] = [{ id: 'p1', parentId: 'u1', title: 'Post One' }]
-    const PostModel = stubModel({ rows: postRows })
-    const parents = new Map([
-      ['u1', makeParentWithChildren('u1', postRows)],
-    ])
-    const ParentModel: ModelLike = {
-      async find(id) { return parents.get(String(id)) ?? null },
-      async create() { throw new Error('not used') },
-      async update() { throw new Error('not used') },
-      async delete() { /* no-op */ },
-      query(): ModelQuery { return findAdapter((this as ModelLike).find as (id: string) => Promise<unknown>) },
-    }
-    Object.assign(ParentModel as object, { relations: { posts: { model: () => PostModel } } })
-
-    class PostResource extends Resource {
-      static override slug = 'posts'
-      static override get model() { return PostModel }
-      static override form(form: Form): Form { return form.schema([TextField.make('title').required()]) }
-    }
-    class PostsManager extends RelationManager {
-      static override relationship = 'posts'
-      static override table(t: Table): Table { return t.columns([Column.make('title')]) }
-      static override form(f: Form): Form  { return f.schema([TextField.make('title').required()]) }
-    }
-    class UserResource extends Resource {
-      static override slug = 'users'
-      static override get model() { return ParentModel }
-      static override relations() { return [PostsManager] }
-    }
-
-    PilotiqRegistry.reset()
-    const panel = Pilotiq.make('TestPanel-' + Math.random()).path('/admin').resources([UserResource, PostResource])
-    PilotiqRegistry.register(panel)
-    return panel
-  }
-
-  it('routes relation-list page id through to relationManagerData', async () => {
-    buildPanel()
-    const out = await dispatchPageData({
-      pageId: '/pages/(pilotiq)/relation-list',
-      routeParams: { basePath: 'admin', slug: 'users', id: 'u1', relationship: 'posts' },
-      urlParsed: { search: {} },
-    })
-    assert.notEqual(out, null)
-    assert.equal((out as Record<string, unknown>)['pageType'], 'relation-list')
-  })
-
-  it('routes relation-create page id through', async () => {
-    buildPanel()
-    const out = await dispatchPageData({
-      pageId: '/pages/(pilotiq)/relation-create',
-      routeParams: { basePath: 'admin', slug: 'users', id: 'u1', relationship: 'posts' },
-      urlParsed: { search: {} },
-    })
-    assert.equal((out as Record<string, unknown>)['pageType'], 'relation-create')
-  })
-
-  it('routes relation-edit page id through', async () => {
-    buildPanel()
-    const out = await dispatchPageData({
-      pageId: '/pages/(pilotiq)/relation-edit',
-      routeParams: { basePath: 'admin', slug: 'users', id: 'u1', relationship: 'posts', childId: 'p1' },
-      urlParsed: { search: {} },
-    })
-    assert.equal((out as Record<string, unknown>)['pageType'], 'relation-edit')
-  })
-
-  it('returns null when the panel base path is unknown', async () => {
-    PilotiqRegistry.reset()
-    const out = await dispatchPageData({
-      pageId: '/pages/(pilotiq)/relation-list',
-      routeParams: { basePath: 'nonexistent', slug: 'users', id: 'u1', relationship: 'posts' },
-      urlParsed: { search: {} },
-    })
-    assert.equal(out, null)
-  })
-
-  it('returns null when route params are incomplete', async () => {
-    buildPanel()
-    const out = await dispatchPageData({
-      pageId: '/pages/(pilotiq)/relation-edit',
-      routeParams: { basePath: 'admin', slug: 'users', id: 'u1' },   // missing relationship + childId
-      urlParsed: { search: {} },
-    })
-    assert.equal(out, null)
-  })
-})
-
-// ── Plan #13 polish — manager TrashedFilter auto-injection ──────────
-
-describe('relation-list TrashedFilter auto-inject (Plan #13 polish)', () => {
-  /** Build a User → Posts world where the related Resource opts into
-   *  soft deletes. */
-  function buildSoftDeleteWorld(opts: {
-    relatedSoftDeletes?: boolean
-  } = {}) {
-    const postRows: QueryRow[] = [{ id: 'p1', parentId: 'u1', title: 'Live' }]
-    const PostModel = stubModel({ rows: postRows })
-    const ParentModel: ModelLike = {
-      async find(_id) { return makeParentWithChildren('u1', postRows) },
-      async create() { throw new Error('not used') },
-      async update() { throw new Error('not used') },
-      async delete() { /* ok */ },
-      query(): ModelQuery { return findAdapter((this as ModelLike).find as (id: string) => Promise<unknown>) },
-    }
-    Object.assign(ParentModel as object, { relations: { posts: { model: () => PostModel } } })
-
-    class PostResource extends Resource {
-      static override slug = 'posts'
-      static override softDeletes = opts.relatedSoftDeletes ?? false
-      static override get model() { return PostModel }
-    }
-
-    class PostsManager extends RelationManager {
-      static override relationship = 'posts'
-      static override table(t: Table): Table {
-        return t.columns([Column.make('title')])
-      }
-    }
-    class UserResource extends Resource {
-      static override slug = 'users'
-      static override get model() { return ParentModel }
-      static override relations() { return [PostsManager] }
-    }
-
-    const panel = Pilotiq.make('TF-' + Math.random()).path('/admin').resources([UserResource, PostResource])
-    return { panel, PostsManager, PostResource }
-  }
-
-  /** Helper — pull filter children from a resolved Table meta. Filters
-   *  serialize as children with a `kind` field (Filter.toMeta) so we
-   *  filter on `kind in c` to distinguish them from columns. */
-  function tableFilterChildren(tableMeta: Record<string, unknown>): Array<Record<string, unknown>> {
-    const children = (tableMeta['children'] as Array<Record<string, unknown>>) ?? []
-    return children.filter(c => c['type'] === 'filter')
-  }
-
-  it('auto-injects TrashedFilter when the related Resource has softDeletes=true', async () => {
-    const { panel } = buildSoftDeleteWorld({ relatedSoftDeletes: true })
-    const out = await relationManagerData(panel, {
-      kind: 'relation-list', slug: 'users', recordId: 'u1', relationship: 'posts',
-    })
-    const data = out as Record<string, unknown>
-    const schema = data['schemaData'] as Array<Record<string, unknown>>
-    const tableMeta = schema.find(s => s['type'] === 'table') as Record<string, unknown>
-    const filters = tableFilterChildren(tableMeta)
-    const trashed = filters.find(f => f['name'] === 'trashed')
-    assert.ok(trashed, 'expected an auto-injected TrashedFilter on the manager table')
-    assert.equal(trashed!['kind'], 'select')
-  })
-
-  it('does NOT inject TrashedFilter when the related Resource has softDeletes=false (default)', async () => {
-    const { panel } = buildSoftDeleteWorld({ relatedSoftDeletes: false })
-    const out = await relationManagerData(panel, {
-      kind: 'relation-list', slug: 'users', recordId: 'u1', relationship: 'posts',
-    })
-    const data = out as Record<string, unknown>
-    const schema = data['schemaData'] as Array<Record<string, unknown>>
-    const tableMeta = schema.find(s => s['type'] === 'table') as Record<string, unknown>
-    const filters = tableFilterChildren(tableMeta)
-    const trashed = filters.find(f => f['name'] === 'trashed')
-    assert.equal(trashed, undefined)
-  })
-
-  it('does not double-inject when the manager already attached a TrashedFilter', async () => {
-    const { TrashedFilter } = await import('./filters/TrashedFilter.js')
-
-    const postRows: QueryRow[] = [{ id: 'p1', parentId: 'u1' }]
-    const PostModel = stubModel({ rows: postRows })
-    const ParentModel: ModelLike = {
-      async find(_id) { return makeParentWithChildren('u1', postRows) },
-      async create() { throw new Error('not used') },
-      async update() { throw new Error('not used') },
-      async delete() { /* ok */ },
-      query(): ModelQuery { return findAdapter((this as ModelLike).find as (id: string) => Promise<unknown>) },
-    }
-    Object.assign(ParentModel as object, { relations: { posts: { model: () => PostModel } } })
-
-    class PostResource extends Resource {
-      static override slug = 'posts'
-      static override softDeletes = true
-      static override get model() { return PostModel }
-    }
-
-    class PostsManager extends RelationManager {
-      static override relationship = 'posts'
-      static override table(t: Table): Table {
-        return t
-          .columns([Column.make('title')])
-          .filters([TrashedFilter.make().label('Custom trashed label')])
-      }
-    }
-    class UserResource extends Resource {
-      static override slug = 'users'
-      static override get model() { return ParentModel }
-      static override relations() { return [PostsManager] }
-    }
-    const panel = Pilotiq.make('TF2-' + Math.random()).path('/admin').resources([UserResource, PostResource])
-
-    const out = await relationManagerData(panel, {
-      kind: 'relation-list', slug: 'users', recordId: 'u1', relationship: 'posts',
-    })
-    const data = out as Record<string, unknown>
-    const schema = data['schemaData'] as Array<Record<string, unknown>>
-    const tableMeta = schema.find(s => s['type'] === 'table') as Record<string, unknown>
-    const children = (tableMeta['children'] as Array<Record<string, unknown>>) ?? []
-    const trashedFilters = children.filter(c => c['type'] === 'filter' && c['name'] === 'trashed')
-    assert.equal(trashedFilters.length, 1, 'should not double-inject')
-    assert.equal(trashedFilters[0]?.['label'], 'Custom trashed label',
-      'user-supplied filter should win over the auto-injected default')
-  })
-})
-
-// ── Record sub-pages ─────────────────────────────────────
-
-describe('record sub-pages (pages().record)', () => {
-  class ActivityPage extends Page {
-    static override slug = 'activity'
-    static override label = 'Activity'
-    static override schema() {
-      return [Heading.make('Activity heading')]
-    }
-  }
-  class ProfilePage extends Page {
-    static override slug = 'profile'
-    static override label = 'Profile'
-    static override schema() {
-      return [Heading.make('Profile heading')]
-    }
-  }
-
-  // ActivityPage / ProfilePage are module-scope so tests can reference
-  // them inline. `canAccess` is monkey-patched by individual tests via
-  // `buildPanel({ activityCanAccess })`; reset to the default-true
-  // predicate before every test so order of execution stays
-  // independent.
-  beforeEach(() => {
-    ;(ActivityPage as unknown as { canAccess: () => Promise<boolean> }).canAccess =
-      async () => true
-    ;(ProfilePage as unknown as { canAccess: () => Promise<boolean> }).canAccess =
-      async () => true
-  })
-
-  function buildPanel(opts: {
-    activityCanAccess?: () => boolean | Promise<boolean>
-    userCanView?:      () => boolean | Promise<boolean>
-  } = {}) {
-    const ParentModel: ModelLike = stubModel({ rows: [{ id: 'u1', name: 'Alice' }] })
-    class UserResource extends Resource {
-      static override slug = 'users'
-      static override recordTitleAttribute = 'name'
-      static override get model() { return ParentModel }
-      static override detail() { return [] }
-      static override pages() {
-        return { record: { activity: ActivityPage, profile: ProfilePage } }
-      }
-    }
-    if (opts.userCanView) {
-      (UserResource as unknown as { canView: () => unknown }).canView = opts.userCanView
-    }
-    if (opts.activityCanAccess) {
-      (ActivityPage as unknown as { canAccess: () => unknown }).canAccess = opts.activityCanAccess
-    } else {
-      ;(ActivityPage as unknown as { canAccess: () => Promise<boolean> }).canAccess =
-        async () => true
-    }
-    const panel = Pilotiq.make('RecPg-' + Math.random()).path('/admin').resources([UserResource])
-    return { panel, UserResource }
-  }
-
-  // ── ResourcePages.record widening ──────────────────
-
-  it('Resource.getRecordPages() returns the record map', () => {
-    const { UserResource } = buildPanel()
-    const recordPages = UserResource.getRecordPages()
-    assert.equal(recordPages['activity'], ActivityPage)
-    assert.equal(recordPages['profile'],  ProfilePage)
-  })
-
-  it('Resource.getRecordPages() returns {} when no record map is declared', () => {
-    class R extends Resource { static override slug = 'r' }
-    assert.deepEqual(R.getRecordPages(), {})
-  })
-
-  // ── Data builder ──────────────────────────────────
-
-  it('resourceRecordPageData returns null when slug not found', async () => {
-    const { panel } = buildPanel()
-    const out = await resourceRecordPageData(panel, 'nope', 'u1', 'activity')
-    assert.equal(out, null)
-  })
-
-  it('resourceRecordPageData returns null when sub-page slug not registered', async () => {
-    const { panel } = buildPanel()
-    const out = await resourceRecordPageData(panel, 'users', 'u1', 'nope')
-    assert.equal(out, null)
-  })
-
-  it('resourceRecordPageData renders the sub-page schema on success', async () => {
-    const { panel } = buildPanel()
-    const out = await resourceRecordPageData(panel, 'users', 'u1', 'activity')
-    const data = out as Record<string, unknown>
-    assert.equal(data['pageType'], 'record-page')
-    assert.equal(data['mode'],     'record')
-    assert.equal((data['subPage'] as Record<string, unknown>)['slug'],  'activity')
-    assert.equal((data['subPage'] as Record<string, unknown>)['label'], 'Activity')
-    const schema = data['schemaData'] as Array<Record<string, unknown>>
-    // Activity heading lives inside the page body, prepended by tabs strip.
-    const heading = schema.find(s => s['type'] === 'heading')
-    assert.ok(heading, 'expected the sub-page heading to render')
-    assert.equal(heading!['content'], 'Activity heading')
-  })
-
-  it('resourceRecordPageData 403s when R.canView returns false', async () => {
-    const { panel } = buildPanel({ userCanView: async () => false })
-    const out = await resourceRecordPageData(panel, 'users', 'u1', 'activity')
-    assert.deepEqual(out, { ok: false, status: 403 })
-  })
-
-  it('resourceRecordPageData 403s when SubPage.canAccess returns false', async () => {
-    const { panel } = buildPanel({ activityCanAccess: async () => false })
-    const out = await resourceRecordPageData(panel, 'users', 'u1', 'activity')
-    assert.deepEqual(out, { ok: false, status: 403 })
-  })
-
-  it('resourceRecordPageData fails closed when SubPage.canAccess throws', async () => {
-    const { panel } = buildPanel({ activityCanAccess: async () => { throw new Error('boom') } })
-    const out = await resourceRecordPageData(panel, 'users', 'u1', 'activity')
-    assert.deepEqual(out, { ok: false, status: 403 })
-  })
-
-  // ── RelationTabs insertion ────────────────────────
-
-  it('RelationTabs inserts a tab per sub-page between Edit and managers', async () => {
-    const ParentModel: ModelLike = stubModel({ rows: [{ id: 'u1', name: 'Alice' }] })
-    Object.assign(ParentModel as object, { relations: { posts: { model: () => stubModel({ rows: [] }) } } })
-
-    class PostsManager extends RelationManager {
-      static override relationship = 'posts'
-    }
-    class UserResource extends Resource {
-      static override slug = 'users'
-      static override get model() { return ParentModel }
-      static override detail() { return [] }
-      static override relations() { return [PostsManager] }
-      static override pages() {
-        return { record: { activity: ActivityPage } }
-      }
-    }
-    const panel = Pilotiq.make('RecPgTabs-' + Math.random()).path('/admin').resources([UserResource])
-
-    const out = await resourceViewData(panel, 'users', 'u1')
-    const schema = (out as Record<string, unknown>)['schemaData'] as Array<Record<string, unknown>>
-    const tabsMeta = schema.find(s => s['type'] === 'relation-tabs') as Record<string, unknown>
-    const tabs = tabsMeta['tabs'] as Array<{ key: string; url: string; active: boolean }>
-    assert.deepEqual(tabs.map(t => t.key), ['__view', '__edit', 'activity', 'posts'])
-    assert.equal(tabs.find(t => t.key === 'activity')?.url, '/admin/users/u1/activity')
-  })
-
-  it('RelationTabs marks the sub-page tab active when rendering through the sub-page', async () => {
-    const { panel } = buildPanel()
-    const out = await resourceRecordPageData(panel, 'users', 'u1', 'activity')
-    const schema = (out as Record<string, unknown>)['schemaData'] as Array<Record<string, unknown>>
-    const tabsMeta = schema.find(s => s['type'] === 'relation-tabs') as Record<string, unknown>
-    const tabs = tabsMeta['tabs'] as Array<{ key: string; active: boolean }>
-    const activity = tabs.find(t => t.key === 'activity')
-    assert.equal(activity?.active, true)
-  })
-
-  it('RelationTabs hides a sub-page tab when its canAccess returns false', async () => {
-    const { panel } = buildPanel({ activityCanAccess: async () => false })
-    // resourceViewData renders __view-active strip; activity sub-page
-    // should drop. profile (default canAccess=true) survives.
-    const out = await resourceViewData(panel, 'users', 'u1')
-    const schema = (out as Record<string, unknown>)['schemaData'] as Array<Record<string, unknown>>
-    const tabsMeta = schema.find(s => s['type'] === 'relation-tabs') as Record<string, unknown>
-    const tabs = tabsMeta['tabs'] as Array<{ key: string }>
-    assert.equal(tabs.find(t => t.key === 'activity'), undefined)
-    assert.ok(tabs.find(t => t.key === 'profile'), 'profile sub-page should remain visible')
-  })
-
-  it('RelationTabs mounts the strip even when only sub-pages exist (no relations)', async () => {
-    // No relation managers — pre-feature, the strip would not mount.
-    // With record sub-pages, the strip mounts to surface them.
-    const { panel } = buildPanel()
-    const out = await resourceViewData(panel, 'users', 'u1')
-    const schema = (out as Record<string, unknown>)['schemaData'] as Array<Record<string, unknown>>
-    const tabsMeta = schema.find(s => s['type'] === 'relation-tabs')
-    assert.ok(tabsMeta, 'strip should mount when sub-pages are registered')
-  })
-
-  // ── dispatchPageData fallthrough ──────────────────
-
-  it('dispatchPageData routes a known sub-page slug through resourceRecordPageData', async () => {
-    PilotiqRegistry.reset()
-    const { panel } = buildPanel()
-    PilotiqRegistry.register(panel)
-    const out = await dispatchPageData({
-      pageId:    '/pages/(pilotiq)/relation-list',
-      urlPathname: '/admin/users/u1/activity',
-      routeParams: { basePath: 'admin', slug: 'users', id: 'u1', relationship: 'activity' },
-      urlParsed: { search: {} as Record<string, string> } as never,
-    } as never)
-    const data = out as Record<string, unknown>
-    assert.equal(data['pageType'], 'record-page')
-  })
-
-  it('dispatchPageData still returns null when neither manager nor sub-page matches', async () => {
-    PilotiqRegistry.reset()
-    const { panel } = buildPanel()
-    PilotiqRegistry.register(panel)
-    const out = await dispatchPageData({
-      pageId:    '/pages/(pilotiq)/relation-list',
-      urlPathname: '/admin/users/u1/nope',
-      routeParams: { basePath: 'admin', slug: 'users', id: 'u1', relationship: 'nope' },
-      urlParsed: { search: {} as Record<string, string> } as never,
-    } as never)
-    assert.equal(out, null)
-  })
-
-  // ── Boot validation ──────────────────────────────
-
-  it('boot rejects a record sub-page slug colliding with a relation manager', () => {
-    class CollideManager extends RelationManager {
-      static override relationship = 'activity'
-    }
-    class UserResource extends Resource {
-      static override slug = 'users'
-      static override relations() { return [CollideManager] }
-      static override pages() {
-        return { record: { activity: ActivityPage } }
-      }
-    }
-    // Boot validation runs inside `registerPilotiqRoutes`; emulate by
-    // calling it through the test plumbing if available. For now we
-    // assert the validation by reading the slugs and confirming the
-    // collision is detectable — full route-registration runs in the
-    // integration test below.
-    const managerSlugs = new Set(UserResource.relations().map(M => M.getRelationship()))
-    const recordSlugs  = Object.keys(UserResource.getRecordPages())
-    const collisions = recordSlugs.filter(s => managerSlugs.has(s))
-    assert.deepEqual(collisions, ['activity'])
-  })
-
-  it('boot rejects a record sub-page slug with invalid characters', () => {
-    class UserResource extends Resource {
-      static override slug = 'users'
-      static override pages() {
-        return { record: { 'bad slug!': ActivityPage } }
-      }
-    }
-    const slugs = Object.keys(UserResource.getRecordPages())
-    // Pattern validation lives in `registerPilotiqRoutes`; here we just
-    // assert the recorded slug round-trips so the validator's input is
-    // what the user typed.
-    assert.deepEqual(slugs, ['bad slug!'])
-  })
-})