@abide/abide 0.109.0 → 0.110.1

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@abide/abide",
-    "version": "0.109.0",
+    "version": "0.110.1",
     "type": "module",
     "description": "Isomorphic type-safe framework for reactive async interfaces for humans and machines",
     "license": "MIT",

package/scaffold/AGENTS.md

@@ -17,7 +17,7 @@ before writing code, rather than guessing from Svelte, Vue or React. It installs
   TypeScript service do not read `.abide` files, so a clean `tsc` says nothing about them. Run
   `bun run check` after every change, and treat its warnings as bugs: several of them name a read
   that will not update when its value changes.
-- `bun run test` — runs `bun test`. `src/tests/getGreeting.test.ts` is the pattern: a test imports a
+- `bun run test` — runs `bun test`. `src/getGreeting.test.ts` is the pattern: a test imports a
   handler or a `.abide` file and calls it.
 - `bun run dev` — serves the app on a local port and rebuilds when a file changes.
 - `bun run build` then `bun run start` — the production build, and the app served from it.
@@ -32,9 +32,15 @@ before writing code, rather than guessing from Svelte, Vue or React. It installs
   scripts, the CLI and MCP alike.
 - A `.abide` cannot export. A `<script server>` in one holds that file's private handlers
   (`const save = POST(…)`), callable by that file alone, and its hooks (`onStart`, `middleware`, …).
-- A directory holds addresses and four fenced directories alone: `lib/` for components and modules,
-  `tests/` for tests, `server/` for modules the browser never loads (importing one from browser code
-  is a compile error), and `public/` for files served as they are (`src/blog/public/cover.png`
-  answers `/blog/cover.png`). Anything else beside the pages is a build error.
+- A directory holds addresses, tests, `.d.ts` declarations and two fenced directories alone: `lib/` for components and
+  modules, and `public/` for files served as they are (`src/blog/public/cover.png` answers
+  `/blog/cover.png`). Anything else beside the pages is a build error.
+- A test is a `.test.ts`, kept beside the file it tests — a page, a handler, or a module in `lib/`.
+  A browser test (playwright) is a `.test.ts` too, under `e2e/` beside `src/`: `bun test` reads
+  `src/` alone (`root` in `bunfig.toml`), so it never runs one.
+- A module the browser never loads is named `<name>.server.ts` and lives in `lib/`
+  (`src/invoices/lib/db.server.ts`); importing one from browser code is a compile error. A module it
+  imports is not fenced by it.
 - Import the app's own modules as `#src/…` (see `imports` in `package.json`).
-- A test imports `.abide` files directly: `bunfig.toml` preloads `@abide/abide/test`.
+- A test imports `.abide` files directly: `bunfig.toml` preloads `@abide/harness/abide/preload`,
+  a DOM to mount into and then `@abide/abide/test`.

package/scaffold/src/{tests/getGreeting.test.ts → getGreeting.test.ts}

@@ -1,5 +1,5 @@
 import { expect, test } from 'bun:test'
-import getGreeting from '../getGreeting.ts'
+import getGreeting from './getGreeting.ts'
 
 test('the handler answers with the name it is given', async () => {
     expect(await getGreeting({ name: 'Ada' })).toBe('Hello, Ada')

package/scaffold/src/{tests/index.test.ts → index.test.ts}

@@ -1,7 +1,7 @@
 import { expect, test } from 'bun:test'
 import { flushSync } from '@abide/abide'
 import { measure, mount } from '@abide/harness/abide'
-import Index from '../index.abide'
+import Index from './index.abide'
 
 test('a click rewrites the count and builds nothing', async () => {
     using _page = await mount(Index({}))

package/src/compiler/appLayout.ts

@@ -1,5 +1,4 @@
 import { relative as relativeTo } from 'node:path' // bun exposes no path helpers of its own
-import type { Compilation } from '#server/abideModules.ts'
 import { appFiles } from '#server/appTree.ts'
 import { type Placement, placement, routeOf } from '#server/placement.ts'
 import { LAUNCHER_PAGE } from '#shared/LAUNCHER_FILES.ts'
@@ -77,7 +76,6 @@ export type AppLayout = {
     errors: AppRoute[]
     /** Every public file's source path to its address. 36.11. */
     published: Map<string, string>
-    mounted: Compilation['mounted']
     /** 30.26 — every address a link may name: a page's, and a public file's. */
     addresses: string[]
     /** What the tree refuses, each at its file; a build stops naming every one. */
@@ -160,7 +158,6 @@ export async function appLayout(root: string): Promise<AppLayout> {
         routes,
         errors,
         published,
-        mounted: found.mounted,
         addresses: [...addresses].sort(),
         refused: refusals.found,
         unparsed: unparsed.found,
@@ -201,7 +198,6 @@ export async function withDependencies(
 ): Promise<{
     sources: ParsedSource[]
     handlers: HandlerFile[]
-    mounted: Compilation['mounted']
     /** 23.19 — each mounted `.abide`'s position, by its path; one at its own path is not here. */
     positions: Map<string, string>
 }> {
@@ -215,7 +211,6 @@ export async function withDependencies(
         })
     // The mounted handler files placed so far; the app's own is never mounted (23.20).
     const handled = new Set<string>()
-    const mounted: Compilation['mounted'] = {}
     const byPath = new Map<string, ParsedSource>()
     for (const source of all) byPath.set(source.path, source)
     const positions = new Map<string, string>()
@@ -258,7 +253,6 @@ export async function withDependencies(
                 continue
             }
             mountedBy.set(mount.directory, position)
-            mounted[relativeTo(root, mount.directory)] = mount.at
             for (const placed of mount.handlers) {
                 // Two mounts can overlap, one directory inside the other; a file is placed once.
                 if (handled.has(placed.path)) continue
@@ -283,7 +277,7 @@ export async function withDependencies(
             if (!byPath.has(target)) await add(target)
         }
     }
-    return { sources: all, handlers, mounted, positions }
+    return { sources: all, handlers, positions }
 }
 
 /** Whether a page or an error page has anything to paint: a template, or a head. 23.3, 35.14. */
@@ -294,8 +288,7 @@ export function paints(file: AbideFile): boolean {
 /**
  * Refuses what a source's place forbids it.
  *
- * 34.20 — a server block under a `server` or `public` directory: neither holds a component that
- * runs. 34.21 — a file imported as text that is not there, found at build rather than when its
+ * 34.20 — a server block under a `public` directory, which holds no component that runs. 34.21 — a file imported as text that is not there, found at build rather than when its
  * module first loads. 35.16 — of the files with an address, the root layout alone writes the
  * document.
  */
@@ -306,14 +299,11 @@ function refusePlace(
     refusals: Refusals,
 ): void {
     const { relative, place, kind } = placed
-    if (
-        source.file.servers.length > 0 &&
-        (place === 'server' || place === 'public')
-    )
+    if (source.file.servers.length > 0 && place === 'public')
         refusals.at(
             relative,
             new Error(
-                `abide: ${relative} has a <script server>, and it is under a ${place} directory, where nothing has an address. Move the file out of it, or the code into a module under a server directory. RULEBOOK 34.20.`,
+                `abide: ${relative} has a <script server>, and it is under a public directory, where nothing has an address. Move the file out of it, or the code into a server file under a lib directory. RULEBOOK 34.20.`,
             ),
         )
     const from = source.path.slice(0, source.path.lastIndexOf('/'))
@@ -340,7 +330,7 @@ function refusePlace(
 }
 
 /**
- * Refuses, naming the module, every module under a `server` or a `lib` directory that calls a hook.
+ * Refuses, naming the module, every module under a `lib` directory that calls a hook.
  *
  * 37.13 — a hook called in a module that is neither a `.abide` nor a handler file runs as the module
  * is imported, before any file's route is set, and not at all where nothing imports it.

package/src/compiler/compileApp.ts

@@ -172,7 +172,6 @@ export function compilationOf(app: CompiledApp): Compilation {
         files: app.files,
         handlers: app.handlers,
         tables: app.tables,
-        mounted: app.mounted,
     }
 }
 
@@ -211,7 +210,6 @@ export async function compiled(
         files: {},
         tables: {},
         handlers: {},
-        mounted: layout.mounted,
         routes: [],
         mounts: [],
         sources: layout.own,

package/src/compiler/handlersUnder.ts

@@ -95,7 +95,7 @@ export async function handlersUnder(
                     throw new Error(
                         each.name === 'default'
                             ? `abide: ${relative}'s default export is not declared as a handler. A handler file's default is declared by abide's \`GET(…)\` (or POST, PUT, PATCH, DELETE); anything else belongs under a lib directory. RULEBOOK 16.73.`
-                            : `abide: ${relative} exports \`${each.name}\`, and a handler file exports its handler as its default and nothing else. Move \`${each.name}\` into a module under a lib or a server directory. RULEBOOK 16.73.`,
+                            : `abide: ${relative} exports \`${each.name}\`, and a handler file exports its handler as its default and nothing else. Move \`${each.name}\` into a module under a lib directory. RULEBOOK 16.73.`,
                     )
             if (handler?.method === undefined)
                 throw new Error(

package/src/compiler/scaffold.ts

@@ -34,10 +34,10 @@ const SOURCE_ALIAS = { '#src/*': ['./src/*', './src/*.ts'] }
 /**
  * 38.109, 38.119 — the starter's `bunfig.toml`: the harness's abide preload, which is a DOM a test
  * can mount into and measure, then abide's own — the app's `.abide` files imported as modules, with
- * nothing booted first.
+ * nothing booted first. Its test root is `src`, so a browser test under `e2e` is playwright's alone.
  */
 export const TEST_PRELOAD =
-    '# 38.109, 38.119 — a DOM to mount into and measure, then the app\'s `.abide` files as modules.\n[test]\npreload = ["@abide/harness/abide/preload"]\n'
+    '# 38.109, 38.119 — a DOM to mount into and measure, then the app\'s `.abide` files as modules.\n[test]\nroot = "src"\npreload = ["@abide/harness/abide/preload"]\n'
 
 // WRITTEN, NOT COPIED, beside the manifests: a packer drops a `bunfig.toml` or a `.gitignore` from
 // the tarball (`bun pm pack` both, `npm pack` the second), so neither survives as a starter file.
@@ -63,11 +63,11 @@ function filesFor(name: string): Record<string, string> {
                 },
                 // ONE ALIAS FOR THE SOURCE, and two targets for it, because an extensionless
                 // specifier is how an import is written and only bun probes for the extension:
-                // TypeScript takes an `imports` target as the exact file, so `#src/media/server/db`
+                // TypeScript takes an `imports` target as the exact file, so `#src/media/lib/db.server`
                 // alone left every name it imports `any` and the checker could not type one of
                 // them (31.3). The first target is what bun resolves, and the one a `.ts` or
-                // `.abide` specifier needs. Which side a module is on is its directory's to say
-                // (36.10), not its alias's.
+                // `.abide` specifier needs. Which side a module is on is its name's to say (36.10),
+                // not its alias's.
                 imports: SOURCE_ALIAS,
                 dependencies: { '@abide/abide': ABIDE_DEPENDENCY },
                 // `Bun`, `bun:sqlite` and the rest of the runtime a server module reaches for are

package/src/server/abideModules.ts

@@ -75,11 +75,6 @@ export type Compilation = {
     handlers: Record<string, HandlerFace>
     /** The build's own modules, by name below `__abide`. */
     tables: Record<string, string>
-    /**
-     * 23.19 — every directory a file mounts, by its path below the root, to the position its files
-     * take: what the browser's fence reads a mounted file's place by (16.29).
-     */
-    mounted: Record<string, string>
 }
 
 const RELATIVE_OR_SUBPATH = /^(?:\.\.?\/|#)/

package/src/server/appTree.ts

@@ -1,11 +1,11 @@
 // 23.14 — WHERE AN APP'S ADDRESSES ARE, read off the tree in one walk. A file directly in a directory
 // below the root is an address — a page, a layout, an error page or a handler file — and nothing
-// else is there (23.22); a fence is never one (23.15): `server` fences a graph, `public` holds files
-// answered as authored at the path of the directories above it, and `lib` and `tests` hold the rest.
-// So listing a directory lists its routes.
+// else is there but its tests (23.22); a fence is never one (23.15): `public` holds files answered as
+// authored at the path of the directories above it, and `lib` holds the rest, a server file among it
+// (23.23). So listing a directory lists its routes.
 //
-// ONE WALK for the sources, the handler files, the server and lib modules, and the public files
-// `abide build` copies and `abide dev` answers, and the refusals (23.16, 23.17, 23.18, 23.22) — each
+// ONE WALK for the sources, the handler files, the lib modules, and the public files `abide build`
+// copies and `abide dev` answers, and the refusals (23.16, 23.17, 23.18, 23.22, 23.23) — each
 // file what `placeOf` says of its path, so the walk and every reader of one path agree, and ONE SKIP
 // RULE, `skipped`, for every walk of the tree.
 //
@@ -16,12 +16,18 @@ import { type Dirent, existsSync, readdirSync } from 'node:fs' // bun has no dir
 import type { Refusals } from '#compiler/Refusals.ts'
 import { ABIDE_ADDRESS } from '#shared/ADDRESSES.ts'
 import {
-    HOLDS_SERVER,
     PUBLIC_DIRECTORY,
     RESERVED_DIRECTORIES,
-    SERVER_DIRECTORY,
 } from '#shared/RESERVED_DIRECTORIES.ts'
-import { DIRECTORY_FILES, placeOf, routeOf, skipped } from './placement.ts'
+import {
+    DIRECTORY_FILES,
+    isDeclarationFile,
+    isServerFile,
+    isTestFile,
+    placeOf,
+    routeOf,
+    skipped,
+} from './placement.ts'
 
 /** What one walk of the app finds, every path relative to the root. */
 type AppFiles = {
@@ -29,15 +35,15 @@ type AppFiles = {
     abide: string[]
     /** Every handler file, in path order. */
     handlers: string[]
-    /** Every module under a `server` or a `lib` directory, in path order — read for 37.13. */
+    /** Every module under a `lib` directory, in path order — read for 37.13. */
     modules: string[]
     /** Every file under a `public` directory, to the address it is answered at below the mount. */
     published: Map<string, string>
 }
 
 /**
- * The app's `.abide` sources, handler files, server and lib modules and public files, refusing a
- * tree 23.16, 23.17, 23.18 or 23.22 forbids into `refusals`, each at its path below the root.
+ * The app's `.abide` sources, handler files, lib modules and public files, refusing a tree 23.16,
+ * 23.17, 23.18, 23.22 or 23.23 forbids into `refusals`, each at its path below the root.
  *
  * A missing root is an app with nothing in it, not a fault.
  */
@@ -82,14 +88,7 @@ function walk(
         if (entry.isDirectory()) {
             let within = reserved
             if (RESERVED_DIRECTORIES.has(entry.name)) {
-                // 23.16 — `server` nests in the fences that hold code.
-                if (
-                    reserved !== undefined &&
-                    !(
-                        entry.name === SERVER_DIRECTORY &&
-                        HOLDS_SERVER.has(reserved.name)
-                    )
-                )
+                if (reserved !== undefined)
                     refusals.at(
                         path,
                         new Error(
@@ -107,17 +106,27 @@ function walk(
             )
             continue
         }
+        const place = placeOf(path)
+        if (isServerFile(path) && place !== 'lib') {
+            refusals.at(
+                path,
+                new Error(
+                    `abide: ${path} is a server file under no lib directory. Move it into a lib directory beside it. RULEBOOK 23.23.`,
+                ),
+            )
+            continue
+        }
         const abide = path.endsWith('.abide')
         if (abide) files.abide.push(path)
-        const place = placeOf(path)
         if (place === 'address') {
+            if (isTestFile(path) || isDeclarationFile(path)) continue
             if (!abide && !isModule(path)) {
                 if (packaged && relative === '' && !path.endsWith('.ts'))
                     continue
                 refusals.at(
                     path,
                     new Error(
-                        `abide: ${path} is directly in an address directory, which holds pages, layouts, error pages and handler files alone. Move it into a lib directory beside it. RULEBOOK 23.22.`,
+                        `abide: ${path} is directly in an address directory, which holds pages, layouts, error pages, handler files, test files and declaration files alone. Move it into a lib directory beside it. RULEBOOK 23.22.`,
                     ),
                 )
                 continue
@@ -139,21 +148,13 @@ function walk(
             )
         else if (place === 'public')
             files.published.set(path, publicAddress(path, fence.path))
-        else if ((place === 'server' || place === 'lib') && isModule(path))
-            files.modules.push(path)
+        else if (place === 'lib' && isModule(path)) files.modules.push(path)
     }
 }
 
-/**
- * Whether `path` names a module the app runs — neither a declaration nor a test: directly in an
- * address directory, a handler file rather than a stray.
- */
+/** Whether `path` names a module the app runs — neither a declaration nor a test. */
 function isModule(path: string): boolean {
-    return (
-        path.endsWith('.ts') &&
-        !path.endsWith('.d.ts') &&
-        !path.endsWith('.test.ts')
-    )
+    return path.endsWith('.ts') && !isDeclarationFile(path) && !isTestFile(path)
 }
 
 /** The refusal of `source` where `route` lies in the framework's own namespace, or `undefined`. 23.17. */
@@ -199,7 +200,8 @@ export function holdsApp(root: string): boolean {
     return !appSourcesUnder(root, '').next().done
 }
 
-// Every `.abide` under `directory`, and every handler file — a module whose place is an address.
+// Every `.abide` under `directory`, and every handler file — a module whose place is an address, and
+// no server file (23.23).
 function* appSourcesUnder(
     directory: string,
     relative: string,
@@ -217,7 +219,9 @@ function* appSourcesUnder(
             yield* appSourcesUnder(`${directory}/${entry.name}`, `${path}/`)
         else if (
             path.endsWith('.abide') ||
-            (isModule(path) && placeOf(path) === 'address')
+            (isModule(path) &&
+                !isServerFile(path) &&
+                placeOf(path) === 'address')
         )
             yield path
     }

package/src/server/clientBundle.ts

@@ -52,10 +52,10 @@ export async function clientBundle(
         // tables' is not on disk to open.
         root,
         // 16.28, 16.29 — the browser's view of the server: a `<script server>` is its stand-ins and a
-        // `server/` module refuses — FENCED FIRST, before the plugin that would serve the module. 38.43
+        // server file refuses — FENCED FIRST, before the plugin that would serve the module. 38.43
         // — then the app's own, as `bunfig.toml` declares them.
         plugins: [
-            fenceServer(root, compilation.mounted),
+            fenceServer(root),
             abideModules(root, compilation),
             ...(await appPlugins(root)),
         ],

package/src/server/fenceServer.ts

@@ -1,63 +1,57 @@
-// 16.29 — WHAT THE BROWSER'S BUNDLE SEES OF THE SERVER: nothing under a `server` directory, at any
-// depth, so a secret or a database client cannot ride into the browser by being imported from the
-// wrong file. A handler crosses as the wrapper the compiler wrote in its place — a handler file as
-// that file, a private handler in its server block's place (16.28); this is the fence around
+// 16.29 — WHAT THE BROWSER'S BUNDLE SEES OF THE SERVER: no server file, `<name>.server.<extension>`,
+// wherever it lies, so a secret or a database client cannot ride into the browser by being imported
+// from the wrong file. A handler crosses as the wrapper the compiler wrote in its place — a handler
+// file as that file, a private handler in its server block's place (16.28); this is the fence around
 // everything else.
 //
 // A PLUGIN ON THE BUNDLE, NOT A REWRITE OF THE PAGES. A rewrite reaches the specifiers the compiler
-// emitted; the bundle reaches every edge — a helper the page imports, importing a server module,
+// emitted; the bundle reaches every edge — a helper the page imports, importing a server file,
 // included.
 //
 // REGISTERED AHEAD OF `abideModules`, AND IN ITS NAMESPACES: a load is answered by the first plugin
 // that answers it, and a component or a file's text is loaded there rather than as a `file`.
 //
-// BY POSITION, NOT BY PATH (23.19): a directory a file mounts places its files where the app says,
-// so a `server` directory inside it is fenced as the app's own would be, wherever the package lies.
+// BY NAME, NOT BY PLACE: the file's own name says it, so a dependency's or a mounted package's is
+// fenced as the app's own is, and a module it imports is not (36.10).
 
-import { SERVER_DIRECTORY } from '#shared/RESERVED_DIRECTORIES.ts'
-import type { Compilation } from './abideModules.ts'
 import {
     COMPONENT_NAMESPACE,
     realFileOf,
     STYLE_NAMESPACE,
     TEXT_NAMESPACE,
 } from './faceOf.ts'
-import { placeOf, positionOf } from './placement.ts'
+import { isServerFile } from './placement.ts'
 
 // Every namespace a browser bundle loads a file of the app's in: its modules, its components, a
 // file's text and a component's stylesheet.
 const FENCED = ['file', COMPONENT_NAMESPACE, TEXT_NAMESPACE, STYLE_NAMESPACE]
 
 /**
- * The bundler plugin refusing everything under a `server` directory to the browser's bundle.
+ * The bundler plugin refusing every server file to the browser's bundle.
  *
- * `root` is its real path (`appRoot`), which is how the bundler names a file; `mounted` is the
- * compilation's. Listed before `abideModules`.
+ * `root` is its real path (`appRoot`), which is how the bundler names a file. Listed before
+ * `abideModules`.
  */
-export function fenceServer(
-    root: string,
-    mounted: Compilation['mounted'],
-): Bun.BunPlugin {
-    // Anything with a `server` directory in its path, and `placeOf` decides by its position — a
-    // load it passes on falls through to the next plugin's, or the bundler's own.
-    const filter = new RegExp(`/${SERVER_DIRECTORY}/`)
+export function fenceServer(root: string): Bun.BunPlugin {
+    // Anything whose own name could be one, a face's suffix included, and `isServerFile` decides by
+    // the file a face stands for — a load it passes on falls through to the next plugin's, or the
+    // bundler's own.
+    const filter = /\.server\.[^/]*$/
     return {
         name: 'abide-fence',
         setup(build) {
             for (const namespace of FENCED)
                 build.onLoad({ filter, namespace }, (args) => {
-                    const position = positionOf(
-                        root,
-                        mounted,
-                        realFileOf(args.path),
-                    )
-                    if (
-                        position === undefined ||
-                        placeOf(position) !== 'server'
-                    )
-                        return undefined
+                    const path = realFileOf(args.path)
+                    if (!isServerFile(path)) return undefined
+                    const dependency = path.lastIndexOf('/node_modules/')
+                    const shown = path.startsWith(`${root}/`)
+                        ? path.slice(root.length + 1)
+                        : dependency === -1
+                          ? path
+                          : path.slice(dependency + 1)
                     throw new Error(
-                        `abide: ${position} is under a server directory, and the browser's bundle imports it. RULEBOOK 16.29.`,
+                        `abide: ${shown} is a server file, and the browser's bundle imports it. RULEBOOK 16.29.`,
                     )
                 })
         },

package/src/server/generatedSurfaces.ts

@@ -253,6 +253,14 @@ export class McpSurface {
         handlers: Map<string, Mounted>,
         answer: (request: Request) => Promise<Response>,
     ) {
+        // 20.20 — a tool's arguments are an object, so args that can never be one are no tool.
+        for (const mounted of handlers.values()) {
+            const tool = surfaceOf(mounted, 'mcp')
+            if (tool !== undefined && toolInput(tool.schema) === undefined)
+                throw new Error(
+                    `abide: ${tool.name}'s args can never be an object, which is all an MCP tool is called with — give it object args, or \`clients: { mcp: false }\`. RULEBOOK 20.20.`,
+                )
+        }
         this.#handlers = handlers
         this.#answer = answer
     }
@@ -280,7 +288,7 @@ export class McpSurface {
             listing.push({
                 name: tool.name,
                 description: tool.description ?? '',
-                inputSchema: tool.schema ?? { type: 'object' },
+                inputSchema: toolInput(tool.schema),
                 // 20.14 — what the method promises: a `GET` is safe, and a `GET`, a `PUT` and a
                 // `DELETE` idempotent. Any other write may destroy, and nothing says it does not.
                 annotations: {
@@ -411,6 +419,32 @@ function logCall(
     )
 }
 
+/**
+ * `schema` as a tool's `inputSchema`, its top-level `type` `object` whatever it declared there, or
+ * `undefined` where no value it admits is an object. 20.19, 20.20.
+ */
+function toolInput(schema: unknown): object | undefined {
+    if (schema === undefined || schema === true) return { type: 'object' }
+    if (!admitsObject(schema)) return undefined
+    return { ...(schema as object), type: 'object' }
+}
+
+/** Whether a JSON Schema admits some object — its `type`, and each of `anyOf`, `oneOf` and `allOf`. */
+function admitsObject(schema: unknown): boolean {
+    if (schema === true) return true
+    if (schema === null || typeof schema !== 'object') return false
+    const { type, anyOf, oneOf, allOf } = schema as Record<string, unknown>
+    if (
+        type !== undefined &&
+        type !== 'object' &&
+        !(Array.isArray(type) && type.includes('object'))
+    )
+        return false
+    if (Array.isArray(anyOf) && !anyOf.some(admitsObject)) return false
+    if (Array.isArray(oneOf) && !oneOf.some(admitsObject)) return false
+    return !Array.isArray(allOf) || allOf.every(admitsObject)
+}
+
 /**
  * Whether a tool declares an `outputSchema`: MCP's structured content is an object, so only a
  * result schema that is one. 20.16.