@prisma-next/sql-contract-ts 0.11.0-dev.9 → 0.12.0

package/package.json

@@ -1,31 +1,39 @@
 {
   "name": "@prisma-next/sql-contract-ts",
-  "version": "0.11.0-dev.9",
+  "version": "0.12.0",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
   "description": "SQL-specific TypeScript contract authoring surface for Prisma Next",
   "dependencies": {
-    "@prisma-next/config": "0.11.0-dev.9",
-    "@prisma-next/contract": "0.11.0-dev.9",
-    "@prisma-next/contract-authoring": "0.11.0-dev.9",
-    "@prisma-next/framework-components": "0.11.0-dev.9",
-    "@prisma-next/sql-contract": "0.11.0-dev.9",
-    "@prisma-next/utils": "0.11.0-dev.9",
+    "@prisma-next/config": "0.12.0",
+    "@prisma-next/contract": "0.12.0",
+    "@prisma-next/contract-authoring": "0.12.0",
+    "@prisma-next/framework-components": "0.12.0",
+    "@prisma-next/sql-contract": "0.12.0",
+    "@prisma-next/utils": "0.12.0",
     "arktype": "^2.2.0",
     "pathe": "^2.0.3",
     "ts-toolbelt": "^9.6.0"
   },
   "devDependencies": {
-    "@prisma-next/test-utils": "0.11.0-dev.9",
-    "@prisma-next/tsconfig": "0.11.0-dev.9",
+    "@prisma-next/test-utils": "0.12.0",
+    "@prisma-next/tsconfig": "0.12.0",
     "@types/pg": "8.20.0",
     "pg": "8.20.0",
-    "@prisma-next/tsdown": "0.11.0-dev.9",
+    "@prisma-next/tsdown": "0.12.0",
     "tsdown": "0.22.0",
     "typescript": "5.9.3",
     "vitest": "4.1.6"
   },
+  "peerDependencies": {
+    "typescript": ">=5.9"
+  },
+  "peerDependenciesMeta": {
+    "typescript": {
+      "optional": true
+    }
+  },
   "files": [
     "dist",
     "src",
@@ -36,6 +44,9 @@
     "./contract-builder": "./dist/contract-builder.mjs",
     "./package.json": "./package.json"
   },
+  "engines": {
+    "node": ">=24"
+  },
   "repository": {
     "type": "git",
     "url": "https://github.com/prisma/prisma-next.git",

package/src/build-contract.ts

@@ -4,6 +4,7 @@ import {
   computeStorageHash,
 } from '@prisma-next/contract/hashing';
 import {
+  asNamespaceId,
   type ColumnDefault,
   type ColumnDefaultLiteralInputValue,
   type Contract,
@@ -11,13 +12,17 @@ import {
   type ContractModel,
   type ContractRelation,
   type ContractValueObject,
+  type CrossReference,
   coreHash,
+  crossRef,
   type ExecutionMutationDefault,
   type JsonValue,
   type StorageHashBase,
 } from '@prisma-next/contract/types';
+import { type CapabilityMatrix, mergeCapabilityMatrices } from '@prisma-next/contract-authoring';
 import type { CodecLookup } from '@prisma-next/framework-components/codec';
-import { type Namespace, UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';
+import { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';
+import { sqlContractCanonicalizationHooks } from '@prisma-next/sql-contract/canonicalization-hooks';
 import { validateIndexTypes } from '@prisma-next/sql-contract/index-type-validation';
 import {
   createIndexTypeRegistry,
@@ -26,6 +31,7 @@ import {
 } from '@prisma-next/sql-contract/index-types';
 import {
   applyFkDefaults,
+  buildSqlNamespace,
   isPostgresEnumStorageEntry,
   type PostgresEnumStorageEntry,
   type SqlNamespaceTablesInput,
@@ -38,6 +44,7 @@ import {
   toStorageTypeInstance,
 } from '@prisma-next/sql-contract/types';
 import { validateStorageSemantics } from '@prisma-next/sql-contract/validators';
+import { blindCast } from '@prisma-next/utils/casts';
 import { ifDefined } from '@prisma-next/utils/defined';
 import type {
   ContractDefinition,
@@ -146,6 +153,17 @@ function isValueObjectField(
 const JSONB_CODEC_ID = 'pg/jsonb@1';
 const JSONB_NATIVE_TYPE = 'jsonb';
 
+function resolveModelNamespaceId(
+  model: ModelNode,
+  modelNameToNamespaceId: ReadonlyMap<string, string>,
+  targetId: string,
+): string {
+  if (model.namespaceId !== undefined && model.namespaceId.length > 0) {
+    return model.namespaceId;
+  }
+  return modelNameToNamespaceId.get(model.modelName) ?? defaultModelNamespaceId(targetId);
+}
+
 function buildStorageColumn(
   field: FieldNode | ValueObjectFieldNode,
   codecLookup?: CodecLookup,
@@ -213,7 +231,7 @@ function buildDomainField(
 
 function collectStorageNamespaceCoordinateIds(definition: ContractDefinition): Set<string> {
   const ids = new Set<string>();
-  ids.add(UNBOUND_NAMESPACE_ID);
+  ids.add(defaultModelNamespaceId(definition.target.targetId));
   for (const id of definition.namespaces ?? []) {
     if (id.length > 0) {
       ids.add(id);
@@ -228,6 +246,11 @@ function collectStorageNamespaceCoordinateIds(definition: ContractDefinition): S
 }
 
 const POSTGRES_ENUM_NAMESPACE_ID = 'public';
+const POSTGRES_DEFAULT_NAMESPACE_ID = 'public';
+
+function defaultModelNamespaceId(targetId: string): string {
+  return targetId === 'postgres' ? POSTGRES_DEFAULT_NAMESPACE_ID : UNBOUND_NAMESPACE_ID;
+}
 
 function partitionStorageTypesForTarget(
   targetId: string,
@@ -286,13 +309,19 @@ export function buildSqlContractFromDefinition(
 
   const tablesByNamespace: Record<string, Record<string, StorageTable>> = {};
   const tableNameToNamespaceId = new Map<string, string>();
+  const modelNameToNamespaceId = new Map<string, string>();
   const executionDefaults: ExecutionMutationDefault[] = [];
-  const models: Record<string, ContractModel> = {};
-  const roots: Record<string, string> = {};
+  const modelsByNamespace: Record<string, Record<string, ContractModel>> = {};
+  const roots: Record<string, CrossReference> = {};
 
   for (const semanticModel of definition.models) {
     const tableName = semanticModel.tableName;
-    roots[tableName] = semanticModel.modelName;
+    const namespaceId =
+      semanticModel.namespaceId !== undefined && semanticModel.namespaceId.length > 0
+        ? semanticModel.namespaceId
+        : defaultModelNamespaceId(target);
+    modelNameToNamespaceId.set(semanticModel.modelName, namespaceId);
+    roots[tableName] = crossRef(semanticModel.modelName, namespaceId);
 
     // --- Build storage table ---
 
@@ -344,11 +373,6 @@ export function buildSqlContractFromDefinition(
       }
     }
 
-    const namespaceId =
-      semanticModel.namespaceId !== undefined && semanticModel.namespaceId.length > 0
-        ? semanticModel.namespaceId
-        : UNBOUND_NAMESPACE_ID;
-
     const foreignKeys = (semanticModel.foreignKeys ?? []).map((fk) => {
       const targetModel = assertKnownTargetModel(
         modelsByName,
@@ -366,11 +390,11 @@ export function buildSqlContractFromDefinition(
         fk.references.namespaceId ??
         (targetModel.namespaceId !== undefined && targetModel.namespaceId.length > 0
           ? targetModel.namespaceId
-          : UNBOUND_NAMESPACE_ID);
+          : defaultModelNamespaceId(target));
       return {
-        source: { namespaceId, tableName, columns: fk.columns },
+        source: { namespaceId: asNamespaceId(namespaceId), tableName, columns: fk.columns },
         target: {
-          namespaceId: targetNamespaceId,
+          namespaceId: asNamespaceId(targetNamespaceId),
           tableName: fk.references.table,
           columns: fk.references.columns,
         },
@@ -461,7 +485,10 @@ export function buildSqlContractFromDefinition(
       );
 
       modelRelations[relation.fieldName] = {
-        to: relation.toModel,
+        to: crossRef(
+          relation.toModel,
+          resolveModelNamespaceId(targetModel, modelNameToNamespaceId, target),
+        ),
         // RelationDefinition.cardinality includes 'N:M' which isn't in
         // ContractReferenceRelation yet — cast is needed until the contract
         // type is extended to cover many-to-many.
@@ -482,7 +509,12 @@ export function buildSqlContractFromDefinition(
       };
     }
 
-    models[semanticModel.modelName] = {
+    let namespaceModels = modelsByNamespace[namespaceId];
+    if (namespaceModels === undefined) {
+      namespaceModels = {};
+      modelsByNamespace[namespaceId] = namespaceModels;
+    }
+    namespaceModels[semanticModel.modelName] = {
       storage: {
         table: tableName,
         fields: storageFields,
@@ -526,19 +558,24 @@ export function buildSqlContractFromDefinition(
     namespaceCoordinateIds.add(id);
   }
   const { createNamespace } = definition;
-  const namespaces: Record<string, SqlNamespaceTablesInput | Namespace> = Object.fromEntries(
-    [...namespaceCoordinateIds].sort().map((id) => {
-      const enumTypes = namespaceEnumTypesById[id];
-      const nsInput: SqlNamespaceTablesInput = {
-        id,
-        tables: tablesByNamespace[id] ?? {},
-        ...ifDefined('enum', enumTypes),
-      };
-      return [id, createNamespace ? createNamespace(nsInput) : nsInput];
-    }),
+  const namespaces = blindCast<
+    SqlStorageInput['namespaces'],
+    'contract authoring materialises each namespace coordinate from the model set and explicit namespace list'
+  >(
+    Object.fromEntries(
+      [...namespaceCoordinateIds].sort().map((id) => {
+        const enumTypes = namespaceEnumTypesById[id];
+        const nsInput: SqlNamespaceTablesInput = {
+          id,
+          tables: tablesByNamespace[id] ?? {},
+          ...ifDefined('enum', enumTypes),
+        };
+        return [id, createNamespace ? createNamespace(nsInput) : buildSqlNamespace(nsInput)];
+      }),
+    ),
   );
   const storageWithoutHash = {
-    types: documentTypes,
+    ...(Object.keys(documentTypes).length > 0 ? { types: documentTypes } : {}),
     namespaces,
   };
   const storageHash: StorageHashBase<string> = definition.storageHash
@@ -547,8 +584,9 @@ export function buildSqlContractFromDefinition(
         target,
         targetFamily,
         storage: storageWithoutHash as Record<string, unknown>,
+        ...sqlContractCanonicalizationHooks,
       });
-  const storage = new SqlStorage({ ...storageWithoutHash, storageHash } as SqlStorageInput); // Builder types are wider than SqlStorageInput until SqlStorage normalises document types.
+  const storage = new SqlStorage({ ...storageWithoutHash, storageHash });
 
   const executionSection =
     executionDefaults.length > 0
@@ -578,8 +616,24 @@ export function buildSqlContractFromDefinition(
     }
   }
 
-  const capabilities: Record<string, Record<string, boolean>> = definition.capabilities || {};
-  const profileHash = computeProfileHash({ target, targetFamily, capabilities });
+  const extensionPackCapabilitySources = definition.extensionPacks
+    ? Object.values(definition.extensionPacks).map(
+        (pack) => pack.capabilities as CapabilityMatrix | undefined,
+      )
+    : [];
+  const capabilities = mergeCapabilityMatrices(
+    definition.target.capabilities as CapabilityMatrix | undefined,
+    ...extensionPackCapabilitySources,
+  );
+  // Internal `profileHash` computation is unchanged from `origin/main`: it
+  // continues to fingerprint the author-declared capability subset. With
+  // `capabilities` removed from the `defineContract` input that subset is
+  // now always empty, so the hash naturally stabilises at `hash({})`.
+  const profileHash = computeProfileHash({
+    target,
+    targetFamily,
+    capabilities: {},
+  });
 
   const executionWithHash = executionSection
     ? {
@@ -618,14 +672,32 @@ export function buildSqlContractFromDefinition(
         )
       : undefined;
 
+  const defaultNamespaceId = defaultModelNamespaceId(target);
+  const domainNamespaceIds = new Set(Object.keys(modelsByNamespace));
+  if (domainNamespaceIds.size === 0) {
+    domainNamespaceIds.add(defaultNamespaceId);
+  }
+  if (valueObjects !== undefined) {
+    domainNamespaceIds.add(defaultNamespaceId);
+  }
+  const domainNamespaces = Object.fromEntries(
+    [...domainNamespaceIds].sort().map((namespaceId) => {
+      const modelsInNs = modelsByNamespace[namespaceId] ?? {};
+      const namespaceSlice =
+        namespaceId === defaultNamespaceId && valueObjects !== undefined
+          ? { models: modelsInNs, valueObjects }
+          : { models: modelsInNs };
+      return [namespaceId, namespaceSlice];
+    }),
+  );
+
   const contract: Contract<SqlStorage> = {
     target,
     targetFamily,
-    models,
+    domain: { namespaces: domainNamespaces },
     roots,
     storage,
     ...(executionWithHash ? { execution: executionWithHash } : {}),
-    ...ifDefined('valueObjects', valueObjects),
     extensionPacks,
     capabilities,
     profileHash,

package/src/config-types.ts

@@ -1,9 +1,11 @@
 import { pathToFileURL } from 'node:url';
 import type { ContractConfig } from '@prisma-next/config/config-types';
 import type { Contract } from '@prisma-next/contract/types';
+import type { TargetPackRef } from '@prisma-next/framework-components/components';
 import { ifDefined } from '@prisma-next/utils/defined';
 import { ok } from '@prisma-next/utils/result';
 import { extname } from 'pathe';
+import { buildSqlContractFromDefinition } from './build-contract';
 
 /**
  * Derives the emit output path from the TS contract input so artefacts land
@@ -17,6 +19,18 @@ function defaultOutputFromContractPath(contractPath: string): string {
   return `${contractPath.slice(0, -ext.length)}.json`;
 }
 
+export function emptyContract(options: {
+  readonly output?: string;
+  readonly target: TargetPackRef<'sql', string>;
+}): ContractConfig {
+  return {
+    source: {
+      load: async () => ok(buildSqlContractFromDefinition({ target: options.target, models: [] })),
+    },
+    ...ifDefined('output', options.output),
+  };
+}
+
 export function typescriptContract(contract: Contract, output?: string): ContractConfig {
   return {
     source: {

package/src/contract-builder.ts

@@ -11,6 +11,7 @@ import type {
   SqlNamespaceTablesInput,
   StorageTypeInstance,
 } from '@prisma-next/sql-contract/types';
+import { blindCast } from '@prisma-next/utils/casts';
 import { buildSqlContractFromDefinition } from './build-contract';
 import {
   type ComposedAuthoringHelpers,
@@ -53,7 +54,6 @@ type ContractDefinition<
   Types extends Record<string, StorageTypeInstance | PostgresEnumStorageEntry>,
   Models extends Record<string, ModelLike>,
   ExtensionPacks extends Record<string, ExtensionPackRef<'sql', string>> | undefined,
-  Capabilities extends Record<string, Record<string, boolean>> | undefined,
   Naming extends ContractInput['naming'] | undefined,
   StorageHash extends string | undefined,
   ForeignKeyDefaults extends ForeignKeyDefaultsState | undefined,
@@ -65,7 +65,6 @@ type ContractDefinition<
   readonly naming?: Naming;
   readonly storageHash?: StorageHash;
   readonly foreignKeyDefaults?: ForeignKeyDefaults;
-  readonly capabilities?: Capabilities;
   readonly namespaces?: Namespaces;
   readonly createNamespace?: (input: SqlNamespaceTablesInput) => Namespace;
   readonly types?: Types;
@@ -77,7 +76,6 @@ type ContractScaffold<
   Family extends FamilyPackRef<string>,
   Target extends TargetPackRef<'sql', string>,
   ExtensionPacks extends Record<string, ExtensionPackRef<'sql', string>> | undefined,
-  Capabilities extends Record<string, Record<string, boolean>> | undefined,
   Naming extends ContractInput['naming'] | undefined,
   StorageHash extends string | undefined,
   ForeignKeyDefaults extends ForeignKeyDefaultsState | undefined,
@@ -89,9 +87,10 @@ type ContractScaffold<
   readonly naming?: Naming;
   readonly storageHash?: StorageHash;
   readonly foreignKeyDefaults?: ForeignKeyDefaults;
-  readonly capabilities?: Capabilities;
   readonly namespaces?: Namespaces;
   readonly createNamespace?: (input: SqlNamespaceTablesInput) => Namespace;
+  readonly types?: never;
+  readonly models?: never;
   readonly codecLookup?: CodecLookup;
 };
 
@@ -274,11 +273,7 @@ function validateExtensionPackRefs(
 
 function buildContractFromDsl<Definition extends ContractInput>(
   definition: Definition,
-): SqlContractResult<Definition>;
-
-function buildContractFromDsl(
-  definition: ContractInput,
-): ReturnType<typeof buildSqlContractFromDefinition> {
+): SqlContractResult<Definition> {
   validateTargetPackRef(definition.family, definition.target);
   validateExtensionPackRefs(definition.target, definition.extensionPacks);
   validateNamespaceDeclarations(definition.target, definition.namespaces);
@@ -288,10 +283,10 @@ function buildContractFromDsl(
     (definition.models ?? {}) as Record<string, ModelLike>,
   );
 
-  return buildSqlContractFromDefinition(
-    buildContractDefinition(definition),
-    definition.codecLookup,
-  );
+  return blindCast<
+    SqlContractResult<Definition>,
+    'buildSqlContractFromDefinition return type is wide; SqlContractResult conditional resolves correctly at runtime for any concrete Definition'
+  >(buildSqlContractFromDefinition(buildContractDefinition(definition), definition.codecLookup));
 }
 
 export function defineContract<
@@ -305,7 +300,6 @@ export function defineContract<
   const ExtensionPacks extends
     | Record<string, ExtensionPackRef<'sql', string>>
     | undefined = undefined,
-  const Capabilities extends Record<string, Record<string, boolean>> | undefined = undefined,
   const Naming extends ContractInput['naming'] | undefined = undefined,
   const StorageHash extends string | undefined = undefined,
   const ForeignKeyDefaults extends ForeignKeyDefaultsState | undefined = undefined,
@@ -317,7 +311,6 @@ export function defineContract<
     Types,
     Models,
     ExtensionPacks,
-    Capabilities,
     Naming,
     StorageHash,
     ForeignKeyDefaults,
@@ -330,7 +323,6 @@ export function defineContract<
     Types,
     Models,
     ExtensionPacks,
-    Capabilities,
     Naming,
     StorageHash,
     ForeignKeyDefaults,
@@ -348,7 +340,6 @@ export function defineContract<
   const ExtensionPacks extends
     | Record<string, ExtensionPackRef<'sql', string>>
     | undefined = undefined,
-  const Capabilities extends Record<string, Record<string, boolean>> | undefined = undefined,
   const Naming extends ContractInput['naming'] | undefined = undefined,
   const StorageHash extends string | undefined = undefined,
   const ForeignKeyDefaults extends ForeignKeyDefaultsState | undefined = undefined,
@@ -358,7 +349,6 @@ export function defineContract<
     Family,
     Target,
     ExtensionPacks,
-    Capabilities,
     Naming,
     StorageHash,
     ForeignKeyDefaults,
@@ -372,7 +362,6 @@ export function defineContract<
     Types,
     Models,
     ExtensionPacks,
-    Capabilities,
     Naming,
     StorageHash,
     ForeignKeyDefaults,

package/src/contract-definition.ts

@@ -118,7 +118,6 @@ export interface ModelNode {
 export interface ContractDefinition {
   readonly target: TargetPackRef<'sql', string>;
   readonly extensionPacks?: Record<string, ExtensionPackRef<'sql', string>>;
-  readonly capabilities?: Record<string, Record<string, boolean>>;
   readonly storageHash?: string;
   readonly foreignKeyDefaults?: ForeignKeyDefaultsState;
   readonly storageTypes?: Record<string, StorageTypeInstance | PostgresEnumStorageEntry>;

package/src/contract-dsl.ts

@@ -1209,7 +1209,6 @@ export type ContractInput<
     >
   > = Record<never, never>,
   ExtensionPacks extends Record<string, ExtensionPackRef<'sql', string>> | undefined = undefined,
-  Capabilities extends Record<string, Record<string, boolean>> | undefined = undefined,
 > = {
   readonly family: Family;
   readonly target: Target;
@@ -1217,7 +1216,6 @@ export type ContractInput<
   readonly naming?: NamingConfig;
   readonly storageHash?: string;
   readonly foreignKeyDefaults?: ForeignKeyDefaultsState;
-  readonly capabilities?: Capabilities;
   /**
    * Declared namespace coordinates the contract recognises. Per-model
    * `namespace` references must reference an entry in this list (or the

package/src/contract-lowering.ts

@@ -708,7 +708,6 @@ export function buildContractDefinition(definition: ContractInput): ContractDefi
   return {
     target: definition.target,
     ...(definition.extensionPacks ? { extensionPacks: definition.extensionPacks } : {}),
-    ...(definition.capabilities ? { capabilities: definition.capabilities } : {}),
     ...(definition.storageHash ? { storageHash: definition.storageHash } : {}),
     ...(definition.foreignKeyDefaults ? { foreignKeyDefaults: definition.foreignKeyDefaults } : {}),
     ...(Object.keys(collection.storageTypes).length > 0

package/src/contract-types.ts

@@ -2,6 +2,7 @@ import type {
   ColumnDefault,
   Contract,
   ContractRelation,
+  NamespaceId,
   StorageHashBase,
 } from '@prisma-next/contract/types';
 import type { ExtensionPackRef, TargetPackRef } from '@prisma-next/framework-components/components';
@@ -69,11 +70,35 @@ type DefinitionExtensionPacks<Definition> = Definition extends {
   ? Packs
   : Record<never, never>;
 
-type DefinitionCapabilities<Definition> = Definition extends {
-  readonly capabilities?: infer Capabilities extends Record<string, Record<string, boolean>>;
+type ExtractPackCapabilities<P> = P extends {
+  readonly capabilities?: infer Caps extends Record<string, Record<string, boolean>>;
 }
-  ? Capabilities
-  : undefined;
+  ? Caps
+  : never;
+
+type MergeExtensionPackCapabilities<Packs> =
+  Packs extends Record<string, unknown>
+    ? keyof Packs extends never
+      ? Record<string, never>
+      : UnionToIntersection<
+          {
+            [K in keyof Packs]: ExtractPackCapabilities<Packs[K]>;
+          }[keyof Packs]
+        >
+    : Record<string, never>;
+
+type Defaulted<T, Fallback> = [T] extends [never] ? Fallback : T;
+
+// Build-time capability derivation no longer reads an author-declared
+// `capabilities` block — that field was removed from the `defineContract`
+// input. The build-time matrix is the merge of the target pack's caps and
+// every extension pack's caps; adapter and driver caps are layered in by
+// `enrichContract` at CLI emit time.
+type DerivedCapabilities<Definition> = Defaulted<
+  ExtractPackCapabilities<DefinitionTarget<Definition>>,
+  Record<string, never>
+> &
+  MergeExtensionPackCapabilities<DefinitionExtensionPacks<Definition>>;
 
 type DefinitionTargetId<Definition> = Definition extends {
   readonly target: TargetPackRef<'sql', infer Target>;
@@ -509,12 +534,12 @@ type BuiltStorageTables<Definition> = {
     readonly indexes: ReadonlyArray<Index>;
     readonly foreignKeys: ReadonlyArray<{
       readonly source: {
-        readonly namespaceId: string;
+        readonly namespaceId: NamespaceId;
         readonly tableName: string;
         readonly columns: readonly string[];
       };
       readonly target: {
-        readonly namespaceId: string;
+        readonly namespaceId: NamespaceId;
         readonly tableName: string;
         readonly columns: readonly string[];
       };
@@ -538,33 +563,48 @@ type BuiltStorageTables<Definition> = {
     : Record<string, never>);
 };
 
-type BuiltStorageTypes<Definition> = {
+type BuiltDocumentScopedTypes<Definition> = {
   readonly [K in keyof DefinitionTypes<Definition> as DefinitionTypes<Definition>[K] extends PostgresEnumStorageEntry
     ? never
     : K]: DefinitionTypes<Definition>[K];
 };
 
+type BuiltDomain<Definition> =
+  BuiltDocumentScopedTypes<Definition> extends Record<never, never>
+    ? Record<string, never>
+    : {
+        readonly __unbound__: {
+          readonly types: BuiltDocumentScopedTypes<Definition>;
+        };
+      };
+
+type DefaultStorageNamespaceId<Definition> =
+  DefinitionTargetId<Definition> extends 'postgres' ? 'public' : '__unbound__';
+
 type BuiltStorage<Definition> = {
   readonly storageHash: StorageHashBase<string>;
-  readonly types: BuiltStorageTypes<Definition>;
-  // SQL contracts always carry a literal `__unbound__` namespace whose tables
-  // slot is narrowed to the actual built table shape so downstream DSL
-  // surfaces (TableProxyContract, Ref, SelectBuilder) keep literal-keyed
-  // access without an optional-narrowing dance. The shape is described
-  // inline (rather than intersecting with `SqlStorage['namespaces']`) so
-  // its `Readonly<Record<string, Namespace>>` index signature doesn't
+  readonly types?: BuiltDocumentScopedTypes<Definition>;
+  // The primary namespace key is target-specific: Postgres uses `public` (the
+  // default schema), all other SQL targets use `__unbound__`. The namespace
+  // carries the narrowed tables shape so downstream DSL surfaces keep
+  // literal-keyed access without an optional-narrowing dance. The shape is
+  // described inline (rather than intersecting with `SqlStorage['namespaces']`)
+  // so its `Readonly<Record<string, Namespace>>` index signature doesn't
   // collapse `keyof tables` to `string`. The literal object is still
-  // structurally assignable to `SqlStorage['namespaces']` because every
-  // value satisfies the framework `Namespace` interface.
+  // structurally assignable to `SqlStorage['namespaces']` because every value
+  // satisfies the framework `Namespace` interface.
   readonly namespaces: {
-    readonly __unbound__: {
-      readonly id: '__unbound__';
+    readonly [K in DefaultStorageNamespaceId<Definition>]: {
+      readonly id: K;
       readonly kind: string;
       readonly tables: BuiltStorageTables<Definition>;
       readonly enum?: Readonly<Record<string, PostgresEnumStorageEntry>>;
     };
   } & {
-    readonly [Ns in Exclude<DefinitionNamespaces<Definition>, '__unbound__'>]: {
+    readonly [Ns in Exclude<
+      DefinitionNamespaces<Definition>,
+      DefaultStorageNamespaceId<Definition>
+    >]: {
       readonly id: Ns;
       readonly kind: string;
       readonly tables: Record<never, never>;
@@ -604,16 +644,11 @@ export type SqlContractResult<Definition> = ContractWithTypeMaps<
   Contract<BuiltStorage<Definition>, BuiltModels<Definition>> & {
     readonly target: DefinitionTargetId<Definition>;
     readonly targetFamily: 'sql';
-  } & {
+  } & { readonly domain: BuiltDomain<Definition> } & {
     readonly extensionPacks: keyof DefinitionExtensionPacks<Definition> extends never
       ? Record<string, never>
       : DefinitionExtensionPacks<Definition>;
-    readonly capabilities: DefinitionCapabilities<Definition> extends Record<
-      string,
-      Record<string, boolean>
-    >
-      ? DefinitionCapabilities<Definition>
-      : Record<string, Record<string, boolean>>;
+    readonly capabilities: DerivedCapabilities<Definition>;
   },
   TypeMaps<
     CodecTypesFromDefinition<Definition>,

package/src/exports/config-types.ts

@@ -1,2 +1,6 @@
 export type { ContractConfig } from '@prisma-next/config/config-types';
-export { typescriptContract, typescriptContractFromPath } from '../config-types';
+export {
+  emptyContract,
+  typescriptContract,
+  typescriptContractFromPath,
+} from '../config-types';