fix(codegen-ts): detect source.rdb structurally, not by instanceof MetaSource

`hasAnyRdbSource` / `hasWritableRdbSource` identified a source by
`child instanceof MetaSource`. That is the same class-identity assumption
that split ts-poet's Code objects in 0.21.6: two physical copies of
@metaobjectsdev/metadata in one process give the loader's nodes a different
MetaSource class object than these helpers close over, so `instanceof` is
false for a node that is a source.rdb in every observable respect.

Here the consequence is silent rather than loud. The entity reads as "not
backed by any store", so the table, queries and routes tiers all emit
nothing for it and nothing errors — the adopter gets a successful `meta gen`
with an entity missing from the output.

`meta gen` aliases @metaobjectsdev/metadata to the CLI's own copy
(load-metaobjects-config.ts CLI_PKG_PATHS), which is why this has never
fired in practice. But that alias map runs only for the CLI path: a consumer
embedding runGen() programmatically never executes it, so the helpers should
not depend on it. Both now gate on type/subType, and writability is read
through the node's own surface rather than through the class.

Behaviour is unchanged on a single-copy tree — the registry maps TYPE_SOURCE
to MetaSource, so every source.rdb child already satisfied the old guard.
A node that cannot answer isWritable() is still not counted as writable.

Gated by test/source-detect.test.ts, which models a foreign-realm source as a
MetaData subclass with the same type/subType and writability surface
(instanceof false, everything else identical). Verified red without the fix:
hasAnyRdbSource and hasWritableRdbSource both returned false. The suite also
pins the two directions the relaxation could overshoot — a read-only kind
stays non-writable, and a non-source child is not mistaken for a source.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01KTGT5ksntpcJDZVJ5VyXHS

Author: dmealing

server/typescript/packages/codegen-ts/src/source-detect.ts

@@ -6,9 +6,41 @@
 // metadata-driven, not a typeId discriminator: any object subtype can opt out
 // of Drizzle table emission simply by omitting source.rdb.
 
-import { MetaSource } from "@metaobjectsdev/metadata";
 import { TYPE_SOURCE, SOURCE_SUBTYPE_RDB } from "@metaobjectsdev/metadata";
-import type { MetaObject } from "@metaobjectsdev/metadata";
+import type { MetaData, MetaObject } from "@metaobjectsdev/metadata";
+
+// Cross-realm safety: identify a source structurally (type/subType + the
+// writability surface), never by `instanceof MetaSource`.
+//
+// Two physical copies of @metaobjectsdev/metadata in one process give the
+// loader's nodes a different MetaSource class object than this module closes
+// over, so `instanceof` is false for a node that is a source.rdb in every
+// observable respect — the same class-identity defect that split ts-poet's Code
+// objects in 0.21.6. Here the consequence is silent: the entity reads as "not
+// backed by any store", so no Drizzle table, no queries and no routes are
+// emitted for it, and nothing errors.
+//
+// `meta gen` aliases @metaobjectsdev/metadata to the CLI's own copy
+// (load-metaobjects-config.ts CLI_PKG_PATHS), which closes the split for the CLI
+// path — but that alias map does not run when a consumer embeds runGen()
+// programmatically, so these helpers do not depend on it. Gated by
+// test/source-detect.test.ts ("survives a split @metaobjectsdev/metadata tree").
+
+/** True when the child is a source.rdb node, by structure rather than class identity. */
+function isRdbSource(child: MetaData): boolean {
+  return child.type === TYPE_SOURCE && child.subType === SOURCE_SUBTYPE_RDB;
+}
+
+/**
+ * True when the node reports itself writable. Reads the writability surface
+ * structurally so a source built by a second copy of the package still answers.
+ * A node that cannot answer is not counted as writable (fail-closed — the same
+ * outcome the `instanceof` guard produced for a non-source node).
+ */
+function reportsWritable(child: MetaData): boolean {
+  const probe = child as unknown as { isWritable?: () => boolean };
+  return typeof probe.isWritable === "function" && probe.isWritable();
+}
 
 /**
  * True when the entity declares at least one writable source.rdb child.
@@ -22,10 +54,8 @@ export function hasWritableRdbSource(entity: MetaObject): boolean {
   // (the JVM port's "entity inheriting its source emitted NOTHING" bug); own-only
   // would suppress the Drizzle table for such an entity.
   for (const child of entity.children()) {
-    if (child.type !== TYPE_SOURCE) continue;
-    if (child.subType !== SOURCE_SUBTYPE_RDB) continue;
-    if (!(child instanceof MetaSource)) continue;
-    if (child.isWritable()) return true;
+    if (!isRdbSource(child)) continue;
+    if (reportsWritable(child)) return true;
   }
   return false;
 }
@@ -42,10 +72,7 @@ export function hasWritableRdbSource(entity: MetaObject): boolean {
 export function hasAnyRdbSource(entity: MetaObject): boolean {
   // ADR-0039: resolving — same rationale as hasWritableRdbSource.
   for (const child of entity.children()) {
-    if (child.type !== TYPE_SOURCE) continue;
-    if (child.subType !== SOURCE_SUBTYPE_RDB) continue;
-    if (!(child instanceof MetaSource)) continue;
-    return true;
+    if (isRdbSource(child)) return true;
   }
   return false;
 }

server/typescript/packages/codegen-ts/test/source-detect.test.ts

@@ -2,6 +2,7 @@ import { describe, test, expect } from "bun:test";
 import {
   TypeId,
   TYPE_SOURCE,
+  TYPE_FIELD,
   SOURCE_SUBTYPE_RDB,
   SOURCE_ATTR_KIND,
   SOURCE_ATTR_TABLE,
@@ -10,8 +11,9 @@ import {
   OBJECT_SUBTYPE_ENTITY,
   OBJECT_SUBTYPE_VALUE,
 } from "@metaobjectsdev/metadata";
+import { MetaData } from "@metaobjectsdev/metadata";
 import { meta, metaObject } from "./_meta-build.js";
-import { hasWritableRdbSource } from "../src/source-detect.js";
+import { hasWritableRdbSource, hasAnyRdbSource } from "../src/source-detect.js";
 
 describe("hasWritableRdbSource", () => {
   test("returns false for an object.value with no source children", () => {
@@ -58,3 +60,68 @@ describe("hasWritableRdbSource", () => {
     expect(hasWritableRdbSource(entity)).toBe(true);
   });
 });
+
+// ---------------------------------------------------------------------------
+// Cross-realm (split node_modules tree) — the ts-poet defect class of 0.21.6,
+// applied to @metaobjectsdev/metadata. Two physical copies of the package give
+// the loader's source nodes a DIFFERENT MetaSource class object than the one
+// these helpers close over, so `instanceof MetaSource` is false for a node that
+// is a source.rdb in every observable respect.
+//
+// The CLI closes this by aliasing @metaobjectsdev/metadata to its own copy
+// (load-metaobjects-config.ts CLI_PKG_PATHS) — but that alias map runs only for
+// `meta gen`; a consumer embedding runGen()/codegen-ts programmatically never
+// executes it. The failure is SILENT and severe: the entity reads as "not backed
+// by any store", so no Drizzle table, no queries and no routes are emitted for
+// it, and nothing errors.
+//
+// A foreign-realm node is modelled as a MetaData subclass carrying the same
+// type/subType and writability surface — which reproduces exactly the observable
+// condition (instanceof false, everything else identical) without planting a
+// second physical copy of the package on disk.
+class ForeignRealmSource extends MetaData {
+  isReadOnly(): boolean {
+    return this.attr(SOURCE_ATTR_KIND) === SOURCE_KIND_VIEW;
+  }
+  isWritable(): boolean {
+    return !this.isReadOnly();
+  }
+}
+
+function foreignRdbSource(name: string, kind: string): ForeignRealmSource {
+  const src = new ForeignRealmSource(new TypeId(TYPE_SOURCE, SOURCE_SUBTYPE_RDB), name);
+  src.setAttr(SOURCE_ATTR_KIND, kind);
+  return src;
+}
+
+describe("source detection survives a split @metaobjectsdev/metadata tree", () => {
+  test("hasAnyRdbSource sees a source.rdb built by a second physical copy", () => {
+    const entity = metaObject(OBJECT_SUBTYPE_ENTITY, "Council");
+    entity.addChild(foreignRdbSource("source", SOURCE_KIND_TABLE));
+    expect(hasAnyRdbSource(entity)).toBe(true);
+  });
+
+  test("hasWritableRdbSource sees a writable source.rdb from a second copy", () => {
+    const entity = metaObject(OBJECT_SUBTYPE_ENTITY, "Council");
+    entity.addChild(foreignRdbSource("source", SOURCE_KIND_TABLE));
+    expect(hasWritableRdbSource(entity)).toBe(true);
+  });
+
+  test("a read-only kind from a second copy is still not writable", () => {
+    // The relaxed guard must not turn every foreign source into a writable one —
+    // read-only kinds stay read-only, so the view/table split is still honoured.
+    const entity = metaObject(OBJECT_SUBTYPE_ENTITY, "CouncilView");
+    entity.addChild(foreignRdbSource("source", SOURCE_KIND_VIEW));
+    expect(hasAnyRdbSource(entity)).toBe(true);
+    expect(hasWritableRdbSource(entity)).toBe(false);
+  });
+
+  test("a non-source child is not mistaken for one", () => {
+    // Guards the structural check: type/subType still gate, so an unrelated
+    // node that happens to expose isWritable() is not counted as a source.
+    const entity = metaObject(OBJECT_SUBTYPE_ENTITY, "Council");
+    entity.addChild(meta(new TypeId(TYPE_FIELD, "string"), "name"));
+    expect(hasAnyRdbSource(entity)).toBe(false);
+    expect(hasWritableRdbSource(entity)).toBe(false);
+  });
+});