@@ -17,6 +17,17 @@ here.**
   `--server` replaces the stack recorded in `.metaobjects/`, so on a project that is also
   TypeScript (or Kotlin, or has a React client) following the hint dropped those references.
   The hint is now `npx meta agent-docs`, which keeps the recorded stack.
+- **`meta eject` no longer copies the HTTP adapter beside an owned generator that predates it.**
+  Since 1.0.9, ejecting `entity` / `routes` / `routes-hono` also copies the adapter source into
+  `codegen/runtime/`, and re-running it fills in a missing copy. Over an owned copy from before
+  1.0.9, which has no `runtimeImport` option and whose output imports the published package,
+  that copy was dead code, and could be a Drizzle adapter in a project with no database. It is
+  now skipped for such a copy.
+- **`meta gen` warns when generated code reaches the owned adapter from outside its workspace
+  package.** In a monorepo whose output sits in `apps/api/…`, the relative import of
+  `codegen/runtime/` leaves that package and its build fails (`TS6059 … is not under
+  'rootDir'`). The warning names the package and the two fixes: pass
+  `runtimeImport: "@metaobjectsdev/runtime-ts"`, or move the copy inside the package.
 - **`meta migrate --slug` reports the `down.sql` it writes.** It printed only the `up.sql` path.
 - **TanStack hooks and grid hooks import `<Entity>.meta` from beside themselves.** The UI
   generators write the DB-free `<Entity>.meta.ts` into their own target, but the generated
 
@@ -256,7 +256,12 @@ export async function ejectGenerator(opts: EjectOptions): Promise<EjectResult> {
   // The adapter source the OUTPUT imports is part of what is handed over — copied whether
   // or not the generator file itself was already here, and under the same never-clobber
   // rule, so re-running eject fills in a missing copy without touching a kept one.
-  const runtime = ejectsRuntime(opts.name)
+  // Except when the KEPT copy predates that hand-over (1.0.9): with no `runtimeImport`
+  // option its output imports the published package, so the copy would be dead code —
+  // a Drizzle adapter, and its dependencies, in a project that may have no database.
+  const keptCopyImportsPackage =
+    existing !== undefined && !opts.force && !existing.includes("runtimeImport");
+  const runtime = ejectsRuntime(opts.name) && !keptCopyImportsPackage
     ? await ejectRuntime(opts.cwd, [opts.name], opts.force === true)
     : undefined;
 
 
@@ -30,6 +30,7 @@ import {
 import { emitStructured } from "../lib/format.js";
 import { composeCatalog } from "../lib/catalog.js";
 import { describeError } from "../lib/error-text.js";
+import { findRuntimeBoundaryCrossings, runtimeBoundaryWarnings } from "../lib/runtime-boundary-advisory.js";
 
 /**
  * Print a load failure with everything the loader's ADR-0009 envelope carried — the stable
@@ -235,6 +236,14 @@ export async function genCommand(args: string[], cwd: string, fmt: OutputFormat
     info: "",
   }));
 
+  // Advisory: generated code importing the owned adapter copy from outside its own
+  // workspace package (a monorepo) will not build. Warning only.
+  if (!cliConfig.dryRun) {
+    for (const w of runtimeBoundaryWarnings(
+      findRuntimeBoundaryCrossings(projectRoot, result.files.map((f) => f.path)),
+    )) log.warn(`warning: ${w}`);
+  }
+
   const targetDirs = Array.from(new Set(
     (forgeConfig.targets ? Object.values(forgeConfig.targets).map((t) => t.outDir) : [])
       .concat([forgeConfig.outDir]),
 
@@ -0,0 +1,74 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join, relative, resolve, sep } from "node:path";
+import { OWNED_RUNTIME_DIR, HTTP_RUNTIME_PACKAGE } from "@metaobjectsdev/codegen-ts";
+
+/**
+ * Generated code that imports the owned HTTP-adapter copy from OUTSIDE its own
+ * workspace package.
+ *
+ * Since 1.0.9 an ejected `entity` / `routes` / `routes-hono` generator points its output
+ * at `codegen/runtime/` (the adapter source `meta eject` copied) by a path relative to
+ * the output directory. In a single-package project that is exactly right. In a monorepo
+ * whose output sits inside a workspace package (`apps/api/src/generated`), the path climbs
+ * out of that package: `tsc` rejects the file (`TS6059 … is not under 'rootDir'`), and the
+ * copy's own bare imports (`qs`, `fastify`) do not resolve from the repository root. The
+ * `meta gen` run itself is green; the adopter's build is the first thing that disagrees.
+ *
+ * Found upgrading a pnpm monorepo. This names the package and the two ways out. It is a
+ * warning and never changes an exit code.
+ */
+export interface RuntimeBoundaryFinding {
+  /** Project-relative directory of the workspace package the generated file sits in. */
+  packageDir: string;
+  /** One generated file (project-relative) that crosses the boundary. */
+  example: string;
+}
+
+const IMPORT_SPEC = /\bfrom\s+["'](\.{1,2}\/[^"']+)["']/g;
+
+function nearestPackageDir(fileDir: string, projectRoot: string): string | undefined {
+  for (let d = fileDir; ; d = dirname(d)) {
+    if (d === projectRoot || !d.startsWith(projectRoot + sep)) return undefined;
+    if (existsSync(join(d, "package.json"))) return d;
+  }
+}
+
+function isInside(child: string, parent: string): boolean {
+  return child === parent || child.startsWith(parent + sep);
+}
+
+export function findRuntimeBoundaryCrossings(
+  projectRoot: string,
+  generatedFiles: readonly string[],
+): RuntimeBoundaryFinding[] {
+  const root = resolve(projectRoot);
+  const runtimeRoot = join(root, OWNED_RUNTIME_DIR);
+  const byPackage = new Map<string, RuntimeBoundaryFinding>();
+  for (const file of generatedFiles) {
+    if (!/\.(ts|tsx|mts)$/.test(file) || !existsSync(file)) continue;
+    const abs = resolve(file);
+    const pkgDir = nearestPackageDir(dirname(abs), root);
+    if (pkgDir === undefined || isInside(runtimeRoot, pkgDir) || byPackage.has(pkgDir)) continue;
+    const text = readFileSync(abs, "utf8");
+    for (const m of text.matchAll(IMPORT_SPEC)) {
+      if (isInside(resolve(dirname(abs), m[1]!), runtimeRoot)) {
+        byPackage.set(pkgDir, {
+          packageDir: relative(root, pkgDir).split(sep).join("/"),
+          example: relative(root, abs).split(sep).join("/"),
+        });
+        break;
+      }
+    }
+  }
+  return [...byPackage.values()];
+}
+
+export function runtimeBoundaryWarnings(findings: readonly RuntimeBoundaryFinding[]): string[] {
+  return findings.map((f) =>
+    `generated code in ${f.packageDir}/ imports the owned HTTP adapter from ${OWNED_RUNTIME_DIR}/, ` +
+    `outside that workspace package (e.g. ${f.example}); its build will not resolve it. ` +
+    `Either keep importing the published adapter — pass \`runtimeImport: "${HTTP_RUNTIME_PACKAGE}"\` ` +
+    `to the ejected entity/routes generators — or move ${OWNED_RUNTIME_DIR}/ inside ${f.packageDir}/ ` +
+    `and point \`runtimeImport\` at it.`,
+  );
+}
@@ -268,3 +268,28 @@ describe("meta eject reports how the owned copy compares to the reference", () =
     expect(r.comparison).toBeUndefined();
   });
 });
+
+describe("meta eject over an owned copy that predates the runtime hand-over", () => {
+  // Since 1.0.9 an ejected entity/routes generator points its output at an owned copy of
+  // the HTTP adapter in codegen/runtime/, and eject copies that source. An owned copy
+  // from before then has no `runtimeImport` option — its output imports the published
+  // @metaobjectsdev/runtime-ts — so copying the adapter beside it (and asking for its
+  // dependencies) handed a project with no database a Drizzle adapter it never imports.
+  test("a kept pre-1.0.9 copy gets no codegen/runtime/ files", async () => {
+    await mkdir(join(cwd, "codegen/generators"), { recursive: true });
+    await writeFile(join(cwd, "codegen/generators/entity.ts"), "// my 1.0.0 entity generator\n", "utf8");
+    const r = await ejectGenerator({ cwd, name: "entity" });
+    expect(r.status).toBe("preserved");
+    expect(r.runtime?.files ?? []).toEqual([]);
+    const { existsSync } = await import("node:fs");
+    expect(existsSync(join(cwd, "codegen/runtime"))).toBe(false);
+  });
+
+  test("a kept copy that already supports runtimeImport still gets a missing runtime copy", async () => {
+    await mkdir(join(cwd, "codegen/generators"), { recursive: true });
+    await writeFile(join(cwd, "codegen/generators/entity.ts"), "// mine\nconst runtimeImport = undefined;\n", "utf8");
+    const r = await ejectGenerator({ cwd, name: "entity" });
+    expect(r.status).toBe("preserved");
+    expect((r.runtime?.files ?? []).length).toBeGreaterThan(0);
+  });
+});
@@ -0,0 +1,68 @@
+// An ejected entity/routes generator imports the owned adapter copy in codegen/runtime/
+// by a relative path. In a monorepo whose output sits in a workspace package that path
+// leaves the package and the package's build rejects it (found upgrading a pnpm monorepo:
+// `TS6059 … is not under 'rootDir'`). meta gen warns, naming the package.
+import { describe, test, expect, afterEach } from "bun:test";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { findRuntimeBoundaryCrossings, runtimeBoundaryWarnings } from "../../src/lib/runtime-boundary-advisory.js";
+
+const dirs: string[] = [];
+afterEach(() => { for (const d of dirs.splice(0)) rmSync(d, { recursive: true, force: true }); });
+
+function project(): string {
+  const d = mkdtempSync(join(tmpdir(), "mo-rt-boundary-"));
+  dirs.push(d);
+  writeFileSync(join(d, "package.json"), "{}");
+  mkdirSync(join(d, "codegen/runtime/drizzle-fastify"), { recursive: true });
+  writeFileSync(join(d, "codegen/runtime/drizzle-fastify/index.ts"), "export {};\n");
+  return d;
+}
+
+function gen(root: string, rel: string, content: string): string {
+  const abs = join(root, rel);
+  mkdirSync(join(abs, ".."), { recursive: true });
+  writeFileSync(abs, content);
+  return abs;
+}
+
+describe("runtime boundary advisory", () => {
+  test("a file in a workspace package importing ../codegen/runtime is named", () => {
+    const root = project();
+    mkdirSync(join(root, "apps/api"), { recursive: true });
+    writeFileSync(join(root, "apps/api/package.json"), "{}");
+    const f = gen(root, "apps/api/src/generated/User.routes.ts",
+      `import { mountCrudRoutes } from "../../../../codegen/runtime/drizzle-fastify/index";\n`);
+    const found = findRuntimeBoundaryCrossings(root, [f]);
+    expect(found).toEqual([{ packageDir: "apps/api", example: "apps/api/src/generated/User.routes.ts" }]);
+    const [w] = runtimeBoundaryWarnings(found);
+    expect(w).toContain(`runtimeImport: "@metaobjectsdev/runtime-ts"`);
+    expect(w).toContain("apps/api/");
+  });
+
+  test("a single-package project is not flagged", () => {
+    const root = project();
+    const f = gen(root, "src/generated/User.routes.ts",
+      `import { mountCrudRoutes } from "../../codegen/runtime/drizzle-fastify/index";\n`);
+    expect(findRuntimeBoundaryCrossings(root, [f])).toEqual([]);
+  });
+
+  test("output that imports the published package is not flagged", () => {
+    const root = project();
+    mkdirSync(join(root, "apps/api"), { recursive: true });
+    writeFileSync(join(root, "apps/api/package.json"), "{}");
+    const f = gen(root, "apps/api/src/generated/User.routes.ts",
+      `import { mountCrudRoutes } from "@metaobjectsdev/runtime-ts/drizzle-fastify";\n`);
+    expect(findRuntimeBoundaryCrossings(root, [f])).toEqual([]);
+  });
+
+  test("a runtime copy moved inside the package is not flagged", () => {
+    const root = project();
+    mkdirSync(join(root, "apps/api/codegen/runtime/drizzle-fastify"), { recursive: true });
+    writeFileSync(join(root, "apps/api/package.json"), "{}");
+    const f = gen(root, "apps/api/src/generated/User.routes.ts",
+      `import { mountCrudRoutes } from "../../codegen/runtime/drizzle-fastify/index";\n`);
+    expect(findRuntimeBoundaryCrossings(root, [f])).toEqual([]);
+  });
+});