TML-2727: address CodeRabbit findings on R3 namespace branding

- Mirror the SQL R3 fix on Mongo: type MongoStorageInput.namespaces as
  Readonly<Record<string, MongoNamespace>> so the constructor assignment
  needs no cast; drop the bare `as`.
- Make the SQL `__unbound__` brand sound rather than asserted: inject the
  SqlUnboundNamespace singleton when the validated/hydrated namespaces omit
  the late-bound slot (cross-namespace contracts legitimately do), then
  reconstruct the branded map. Removes the unsound blindCast in
  validateStorage and the bare `as` bridge cast; keeps an honest,
  runtime-guaranteed cast in the hydrate path.
- Make the Mongo construction test honest: it exercises the unbound-only
  happy path (namespaces is a required field, not a runtime throw).

Signed-off-by: wmadden-electric <286902546+wmadden-electric@users.noreply.github.com>

Author: wmadden-electric

packages/2-mongo-family/1-foundation/mongo-contract/src/ir/mongo-storage.ts

@@ -12,11 +12,6 @@ export interface MongoNamespaceCollectionsInput {
   readonly collections?: Record<string, MongoCollection | MongoCollectionInput>;
 }
 
-export interface MongoStorageInput<THash extends string = string> {
-  readonly storageHash: StorageHashBase<THash>;
-  readonly namespaces: Readonly<Record<string, Namespace>>;
-}
-
 // Mongo concretions always store `MongoCollection` instances in
 // `collections` (Mongo idiom — distinct from the SQL family's `tables`).
 // Narrowing the namespace map here lets target/family-level consumers
@@ -27,6 +22,11 @@ export type MongoNamespace = Namespace & {
   readonly collections: Readonly<Record<string, MongoCollection>>;
 };
 
+export interface MongoStorageInput<THash extends string = string> {
+  readonly storageHash: StorageHashBase<THash>;
+  readonly namespaces: Readonly<Record<string, MongoNamespace>>;
+}
+
 export class MongoStorage<THash extends string = string> extends IRNodeBase implements Storage {
   declare readonly kind: 'mongo-storage';
   readonly storageHash: StorageHashBase<THash>;
@@ -41,7 +41,7 @@ export class MongoStorage<THash extends string = string> extends IRNodeBase impl
       configurable: true,
     });
     this.storageHash = input.storageHash;
-    this.namespaces = Object.freeze(input.namespaces) as Readonly<Record<string, MongoNamespace>>;
+    this.namespaces = Object.freeze(input.namespaces);
     freezeNode(this);
   }
 }

packages/2-mongo-family/1-foundation/mongo-contract/test/mongo-storage.test.ts

@@ -1,7 +1,6 @@
 import { coreHash } from '@prisma-next/contract/types';
 import {
   freezeNode,
-  type IRNode,
   NamespaceBase,
   UNBOUND_NAMESPACE_ID,
 } from '@prisma-next/framework-components/ir';
@@ -17,7 +16,7 @@ const hash = coreHash('h_0');
 class TestNamespace extends NamespaceBase {
   readonly kind = 'test-namespace' as const;
   readonly id: string;
-  readonly collections: Readonly<Record<string, IRNode>> = Object.freeze({});
+  readonly collections: Readonly<Record<string, MongoCollection>> = Object.freeze({});
 
   constructor(id: string) {
     super();
@@ -73,13 +72,14 @@ describe('MongoStorage', () => {
     expect(Object.isFrozen(storage)).toBe(true);
   });
 
-  it('requires a namespaces map at construction', () => {
-    expect(
-      () =>
-        new MongoStorage({
-          storageHash: hash,
-          namespaces: { [UNBOUND_NAMESPACE_ID]: MongoUnboundNamespace.instance },
-        }),
-    ).not.toThrow();
+  it('constructs from the unbound namespace singleton alone', () => {
+    // `namespaces` is a required field on `MongoStorageInput`, so the
+    // empty/omitted case is a type error rather than a runtime throw —
+    // this exercises the happy path of an unbound-only storage.
+    const storage = new MongoStorage({
+      storageHash: hash,
+      namespaces: { [UNBOUND_NAMESPACE_ID]: MongoUnboundNamespace.instance },
+    });
+    expect(storage.namespaces[UNBOUND_NAMESPACE_ID]).toBe(MongoUnboundNamespace.instance);
   });
 });

packages/2-sql/1-core/contract/src/validators.ts

@@ -6,11 +6,12 @@ import {
   CrossReferenceSchema,
 } from '@prisma-next/contract/types';
 import { validateContractDomain } from '@prisma-next/contract/validate-domain';
-import type { Namespace } from '@prisma-next/framework-components/ir';
+import { type Namespace, UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';
 import { blindCast } from '@prisma-next/utils/casts';
 import { ifDefined } from '@prisma-next/utils/defined';
 import { type Type, type } from 'arktype';
 import { buildSqlNamespaceMap } from './ir/build-sql-namespace';
+import { SqlUnboundNamespace } from './ir/sql-unbound-namespace';
 import {
   type ForeignKeyInput,
   type ForeignKeyReferenceInput,
@@ -265,6 +266,11 @@ export function createSqlStorageSchema(
     '+': 'reject',
     storageHash: 'string',
     'types?': type({ '[string]': DocumentScopedStorageTypeSchema }),
+    // `__unbound__` is NOT required here: cross-namespace contracts can
+    // declare only named namespaces (see cross-namespace FK fixtures). The
+    // `__unbound__` brand on `SqlStorageInput['namespaces']` is kept sound at
+    // construction time by injecting the unbound singleton when absent
+    // (see `validateStorage` / `hydrateSqlStorage`), not by structural require.
     'namespaces?': type({ '[string]': namespaceEntry }),
   }) as Type<unknown>;
 }
@@ -441,20 +447,25 @@ export function validateStorage(value: unknown): SqlStorage {
     const messages = result.map((p: { message: string }) => p.message).join('; ');
     throw new Error(`Storage validation failed: ${messages}`);
   }
-  // The arktype-validated shape matches `SqlStorageInput`
-  // structurally. Funnel through the constructor so nested IR fields
-  // (`types`) are normalised into class instances and the
-  // branded `storageHash` is preserved on the returned `SqlStorage`.
-  const validated = result as SqlStorageInput & {
-    readonly namespaces?: SqlStorageInput['namespaces'];
-  };
+  // Arktype validates the JSON-safe envelope, but the `ColumnDefault`
+  // union carries runtime-only `bigint | Date` that the validation DSL
+  // can't express (see NOTE above), so bridge the validated shape to the
+  // input type. Construction below re-materialises nested IR fields.
+  const validated = blindCast<
+    SqlStorageInput & { readonly namespaces?: SqlStorageInput['namespaces'] },
+    'arktype validated the JSON envelope but its output type is unknown (ColumnDefault carries runtime-only bigint|Date); bridge to the input shape'
+  >(result);
+  const namespaces = buildSqlNamespaceMap(validated.namespaces ?? {});
+  // The `__unbound__` brand is made true at construction: if the validated
+  // namespaces omit the late-bound slot (e.g. a contract declaring only named
+  // namespaces), inject the family unbound singleton rather than asserting a
+  // shape that isn't there. Reconstructing the literal lets the branded
+  // `SqlStorageInput['namespaces']` hold with no cast.
+  const unbound = namespaces[UNBOUND_NAMESPACE_ID] ?? SqlUnboundNamespace.instance;
   return new SqlStorage({
     storageHash: validated.storageHash,
     ...ifDefined('types', validated.types),
-    namespaces: blindCast<
-      SqlStorageInput['namespaces'],
-      'structural storage validation requires the __unbound__ namespace slot'
-    >(buildSqlNamespaceMap(validated.namespaces ?? {})),
+    namespaces: { ...namespaces, [UNBOUND_NAMESPACE_ID]: unbound },
   });
 }
 

packages/2-sql/9-family/src/core/ir/sql-contract-serializer-base.ts

@@ -1,13 +1,18 @@
 import { ContractValidationError } from '@prisma-next/contract/contract-validation-error';
 import type { Contract } from '@prisma-next/contract/types';
 import type { ContractSerializer } from '@prisma-next/framework-components/control';
-import { type Namespace, NamespaceBase } from '@prisma-next/framework-components/ir';
+import {
+  type Namespace,
+  NamespaceBase,
+  UNBOUND_NAMESPACE_ID,
+} from '@prisma-next/framework-components/ir';
 import {
   buildSqlNamespace,
   type SqlNamespaceTablesInput,
   SqlStorage,
   type SqlStorageInput,
   type SqlStorageTypeEntry,
+  SqlUnboundNamespace,
   StorageTable,
   type StorageTableInput,
 } from '@prisma-next/sql-contract/types';
@@ -113,16 +118,24 @@ export abstract class SqlContractSerializerBase<TContract extends Contract<SqlSt
       );
     }
     const hydratedNamespaces = this.hydrateSqlNamespaceMap(rawNamespaces);
+    // Keep the `__unbound__` brand sound: a deserialized contract may declare
+    // only named namespaces (cross-namespace contracts omit the late-bound
+    // slot), so inject the family unbound singleton when absent rather than
+    // asserting a shape that isn't present.
+    const unbound = hydratedNamespaces[UNBOUND_NAMESPACE_ID] ?? SqlUnboundNamespace.instance;
 
     return {
       ...validated,
       storage: new SqlStorage({
         storageHash: validated.storage.storageHash,
         ...ifDefined('types', hydratedTypes),
+        // `__unbound__` is guaranteed present above; the residual narrowing is
+        // the family invariant that hydrated SQL namespaces are `SqlNamespace`
+        // instances (target/family classes, not the wider framework `Namespace`).
         namespaces: blindCast<
           SqlStorageInput['namespaces'],
-          'deserialized SQL contracts require the __unbound__ namespace slot'
-        >(hydratedNamespaces),
+          'hydrated SQL namespaces are SqlNamespace instances; __unbound__ guaranteed present (injected above)'
+        >({ ...hydratedNamespaces, [UNBOUND_NAMESPACE_ID]: unbound }),
       }),
     };
   }