@prisma-next/sql-contract-ts 0.12.0-dev.7 → 0.12.0-dev.70

package/package.json

@@ -1,30 +1,30 @@
 {
   "name": "@prisma-next/sql-contract-ts",
-  "version": "0.12.0-dev.7",
+  "version": "0.12.0-dev.70",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
   "description": "SQL-specific TypeScript contract authoring surface for Prisma Next",
   "dependencies": {
-    "@prisma-next/config": "0.12.0-dev.7",
-    "@prisma-next/contract": "0.12.0-dev.7",
-    "@prisma-next/contract-authoring": "0.12.0-dev.7",
-    "@prisma-next/framework-components": "0.12.0-dev.7",
-    "@prisma-next/sql-contract": "0.12.0-dev.7",
-    "@prisma-next/utils": "0.12.0-dev.7",
+    "@prisma-next/config": "0.12.0-dev.70",
+    "@prisma-next/contract": "0.12.0-dev.70",
+    "@prisma-next/contract-authoring": "0.12.0-dev.70",
+    "@prisma-next/framework-components": "0.12.0-dev.70",
+    "@prisma-next/sql-contract": "0.12.0-dev.70",
+    "@prisma-next/utils": "0.12.0-dev.70",
     "arktype": "^2.2.0",
     "pathe": "^2.0.3",
     "ts-toolbelt": "^9.6.0"
   },
   "devDependencies": {
-    "@prisma-next/test-utils": "0.12.0-dev.7",
-    "@prisma-next/tsconfig": "0.12.0-dev.7",
+    "@prisma-next/test-utils": "0.12.0-dev.70",
+    "@prisma-next/tsconfig": "0.12.0-dev.70",
     "@types/pg": "8.20.0",
-    "pg": "8.20.0",
-    "@prisma-next/tsdown": "0.12.0-dev.7",
-    "tsdown": "0.22.0",
+    "pg": "8.21.0",
+    "@prisma-next/tsdown": "0.12.0-dev.70",
+    "tsdown": "0.22.1",
     "typescript": "5.9.3",
-    "vitest": "4.1.6"
+    "vitest": "4.1.8"
   },
   "peerDependencies": {
     "typescript": ">=5.9"

package/src/build-contract.ts

@@ -8,6 +8,7 @@ import {
   type ColumnDefault,
   type ColumnDefaultLiteralInputValue,
   type Contract,
+  type ContractEnum,
   type ContractField,
   type ContractModel,
   type ContractRelation,
@@ -18,6 +19,7 @@ import {
   type ExecutionMutationDefault,
   type JsonValue,
   type StorageHashBase,
+  type ValueSetRef,
 } from '@prisma-next/contract/types';
 import { type CapabilityMatrix, mergeCapabilityMatrices } from '@prisma-next/contract-authoring';
 import type { CodecLookup } from '@prisma-next/framework-components/codec';
@@ -32,6 +34,7 @@ import {
 import {
   applyFkDefaults,
   buildSqlNamespace,
+  type CheckConstraintInput,
   isPostgresEnumStorageEntry,
   type PostgresEnumStorageEntry,
   type SqlNamespaceTablesInput,
@@ -41,6 +44,7 @@ import {
   StorageTable,
   type StorageTableInput,
   type StorageTypeInstance,
+  type StorageValueSetInput,
   toStorageTypeInstance,
 } from '@prisma-next/sql-contract/types';
 import { validateStorageSemantics } from '@prisma-next/sql-contract/validators';
@@ -156,16 +160,17 @@ const JSONB_NATIVE_TYPE = 'jsonb';
 function resolveModelNamespaceId(
   model: ModelNode,
   modelNameToNamespaceId: ReadonlyMap<string, string>,
-  targetId: string,
+  defaultNamespaceId: string,
 ): string {
   if (model.namespaceId !== undefined && model.namespaceId.length > 0) {
     return model.namespaceId;
   }
-  return modelNameToNamespaceId.get(model.modelName) ?? defaultModelNamespaceId(targetId);
+  return modelNameToNamespaceId.get(model.modelName) ?? defaultNamespaceId;
 }
 
 function buildStorageColumn(
   field: FieldNode | ValueObjectFieldNode,
+  storageValueSetRef: ValueSetRef | undefined,
   codecLookup?: CodecLookup,
 ): StorageColumn {
   if (isValueObjectField(field)) {
@@ -203,12 +208,14 @@ function buildStorageColumn(
     ...ifDefined('typeParams', field.descriptor.typeParams),
     ...ifDefined('default', encodedDefault),
     ...ifDefined('typeRef', field.descriptor.typeRef),
+    ...ifDefined('valueSet', storageValueSetRef),
   };
 }
 
 function buildDomainField(
   field: FieldNode | ValueObjectFieldNode,
   column: StorageColumn,
+  domainValueSetRef: ValueSetRef | undefined,
 ): ContractField {
   if (isValueObjectField(field)) {
     return {
@@ -226,12 +233,13 @@ function buildDomainField(
     },
     nullable: column.nullable,
     ...(field.many ? { many: true } : {}),
+    ...ifDefined('valueSet', domainValueSetRef),
   };
 }
 
 function collectStorageNamespaceCoordinateIds(definition: ContractDefinition): Set<string> {
   const ids = new Set<string>();
-  ids.add(defaultModelNamespaceId(definition.target.targetId));
+  ids.add(definition.target.defaultNamespaceId);
   for (const id of definition.namespaces ?? []) {
     if (id.length > 0) {
       ids.add(id);
@@ -245,22 +253,38 @@ function collectStorageNamespaceCoordinateIds(definition: ContractDefinition): S
   return ids;
 }
 
-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 ensureUnboundNamespaceSlot(
+  namespaces: SqlStorageInput['namespaces'],
+  createNamespace: ContractDefinition['createNamespace'],
+): SqlStorageInput['namespaces'] {
+  if (Object.hasOwn(namespaces, UNBOUND_NAMESPACE_ID)) {
+    return namespaces;
+  }
+  const unboundInput: SqlNamespaceTablesInput = {
+    id: UNBOUND_NAMESPACE_ID,
+    entries: { table: {} },
+  };
+  const unbound = createNamespace ? createNamespace(unboundInput) : buildSqlNamespace(unboundInput);
+  return blindCast<
+    SqlStorageInput['namespaces'],
+    'createNamespace may return a target namespace concretion; the unbound slot matches SqlNamespace at runtime'
+  >({
+    [UNBOUND_NAMESPACE_ID]: unbound,
+    ...namespaces,
+  });
 }
 
+const POSTGRES_ENUM_NAMESPACE_ID = 'public';
+
 function partitionStorageTypesForTarget(
   targetId: string,
   types: Record<string, StorageTypeInstance | PostgresEnumStorageEntry>,
   namespaceTypes?: Readonly<Record<string, Readonly<Record<string, PostgresEnumStorageEntry>>>>,
 ): {
-  readonly documentTypes: Record<string, StorageTypeInstance | PostgresEnumStorageEntry>;
+  readonly documentTypes: Record<string, StorageTypeInstance>;
   readonly namespaceEnumTypesById: Record<string, Record<string, PostgresEnumStorageEntry>>;
 } {
-  const documentTypes: Record<string, StorageTypeInstance | PostgresEnumStorageEntry> = {};
+  const documentTypes: Record<string, StorageTypeInstance> = {};
   const namespaceEnumTypesById: Record<string, Record<string, PostgresEnumStorageEntry>> = {};
   for (const [name, entry] of Object.entries(types)) {
     if (isPostgresEnumStorageEntry(entry)) {
@@ -304,6 +328,7 @@ export function buildSqlContractFromDefinition(
   codecLookup?: CodecLookup,
 ): Contract<SqlStorage> {
   const target = definition.target.targetId;
+  const defaultNamespaceId = definition.target.defaultNamespaceId;
   const targetFamily = 'sql';
   const modelsByName = new Map(definition.models.map((m) => [m.modelName, m]));
 
@@ -319,9 +344,13 @@ export function buildSqlContractFromDefinition(
     const namespaceId =
       semanticModel.namespaceId !== undefined && semanticModel.namespaceId.length > 0
         ? semanticModel.namespaceId
-        : defaultModelNamespaceId(target);
+        : defaultNamespaceId;
     modelNameToNamespaceId.set(semanticModel.modelName, namespaceId);
-    roots[tableName] = crossRef(semanticModel.modelName, namespaceId);
+    // STI variants share the base table; the base model already owns this
+    // table name and its root, so the variant contributes neither.
+    if (!semanticModel.sharesBaseTable) {
+      roots[tableName] = crossRef(semanticModel.modelName, namespaceId);
+    }
 
     // --- Build storage table ---
 
@@ -348,11 +377,34 @@ export function buildSqlContractFromDefinition(
         }
       }
 
-      const column = buildStorageColumn(field, codecLookup);
+      const enumHandle = !isValueObjectField(field) ? field.enumTypeHandle : undefined;
+      // Authored enums are always registered under the contract's defaultNamespaceId
+      // (see the enum registration loop below), so refs must point there regardless
+      // of which namespace the consuming model lives in.
+      const storageValueSetRef: ValueSetRef | undefined =
+        enumHandle !== undefined
+          ? {
+              plane: 'storage',
+              entityKind: 'value-set',
+              namespaceId: defaultNamespaceId,
+              name: enumHandle.enumName,
+            }
+          : undefined;
+      const domainValueSetRef: ValueSetRef | undefined =
+        enumHandle !== undefined
+          ? {
+              plane: 'domain',
+              entityKind: 'enum',
+              namespaceId: defaultNamespaceId,
+              name: enumHandle.enumName,
+            }
+          : undefined;
+
+      const column = buildStorageColumn(field, storageValueSetRef, codecLookup);
       columns[field.columnName] = column;
       fieldToColumn[field.fieldName] = field.columnName;
 
-      domainFields[field.fieldName] = buildDomainField(field, column);
+      domainFields[field.fieldName] = buildDomainField(field, column, domainValueSetRef);
 
       if (isValueObjectField(field)) {
         domainFieldRefs[field.fieldName] = {
@@ -374,6 +426,31 @@ export function buildSqlContractFromDefinition(
     }
 
     const foreignKeys = (semanticModel.foreignKeys ?? []).map((fk) => {
+      if (fk.references.spaceId !== undefined) {
+        // Cross-space FK: the target lives in a different contract space.
+        // Skip local model lookup and carry the spaceId coordinate through.
+        const targetNamespaceId = fk.references.namespaceId ?? defaultNamespaceId;
+        return {
+          source: { namespaceId: asNamespaceId(namespaceId), tableName, columns: fk.columns },
+          target: {
+            namespaceId: asNamespaceId(targetNamespaceId),
+            tableName: fk.references.table,
+            columns: fk.references.columns,
+            spaceId: fk.references.spaceId,
+          },
+          ...applyFkDefaults(
+            {
+              ...ifDefined('constraint', fk.constraint),
+              ...ifDefined('index', fk.index),
+            },
+            definition.foreignKeyDefaults,
+          ),
+          ...ifDefined('name', fk.name),
+          ...ifDefined('onDelete', fk.onDelete),
+          ...ifDefined('onUpdate', fk.onUpdate),
+        };
+      }
+
       const targetModel = assertKnownTargetModel(
         modelsByName,
         semanticModel.modelName,
@@ -390,7 +467,7 @@ export function buildSqlContractFromDefinition(
         fk.references.namespaceId ??
         (targetModel.namespaceId !== undefined && targetModel.namespaceId.length > 0
           ? targetModel.namespaceId
-          : defaultModelNamespaceId(target));
+          : defaultNamespaceId);
       return {
         source: { namespaceId: asNamespaceId(namespaceId), tableName, columns: fk.columns },
         target: {
@@ -411,48 +488,64 @@ export function buildSqlContractFromDefinition(
       };
     });
 
-    const existingNs = tableNameToNamespaceId.get(tableName);
-    if (existingNs !== undefined && existingNs !== namespaceId) {
-      throw new Error(
-        `buildSqlContractFromDefinition: table "${tableName}" is mapped in namespace "${namespaceId}" but already exists in namespace "${existingNs}".`,
+    // STI variants share the base table: their columns are already
+    // materialised onto the base `ModelNode`, so the variant builds a domain
+    // model (below) but no storage table of its own.
+    if (!semanticModel.sharesBaseTable) {
+      const existingNs = tableNameToNamespaceId.get(tableName);
+      if (existingNs !== undefined && existingNs !== namespaceId) {
+        throw new Error(
+          `buildSqlContractFromDefinition: table "${tableName}" is mapped in namespace "${namespaceId}" but already exists in namespace "${existingNs}".`,
+        );
+      }
+      tableNameToNamespaceId.set(tableName, namespaceId);
+
+      const checksForTable: CheckConstraintInput[] = Object.entries(columns).flatMap(
+        ([columnName, col]) => {
+          const valueSet = col.valueSet;
+          return valueSet === undefined
+            ? []
+            : [{ name: `${tableName}_${columnName}_check`, column: columnName, valueSet }];
+        },
       );
-    }
-    tableNameToNamespaceId.set(tableName, namespaceId);
-
-    const tableInput: StorageTableInput = {
-      columns,
-      uniques: (semanticModel.uniques ?? []).map((u) => ({
-        columns: u.columns,
-        ...ifDefined('name', u.name),
-      })),
-      indexes: (semanticModel.indexes ?? []).map((i) => ({
-        columns: i.columns,
-        ...ifDefined('name', i.name),
-        ...ifDefined('type', i.type),
-        ...ifDefined('options', i.options),
-      })),
-      foreignKeys,
-      ...(semanticModel.id
-        ? {
-            primaryKey: {
-              columns: semanticModel.id.columns,
-              ...ifDefined('name', semanticModel.id.name),
-            },
-          }
-        : {}),
-    };
 
-    let nsTables = tablesByNamespace[namespaceId];
-    if (nsTables === undefined) {
-      nsTables = {};
-      tablesByNamespace[namespaceId] = nsTables;
-    }
-    if (nsTables[tableName] !== undefined) {
-      throw new Error(
-        `buildSqlContractFromDefinition: duplicate table "${tableName}" in namespace "${namespaceId}".`,
-      );
+      const tableInput: StorageTableInput = {
+        columns,
+        ...ifDefined('control', semanticModel.control),
+        uniques: (semanticModel.uniques ?? []).map((u) => ({
+          columns: u.columns,
+          ...ifDefined('name', u.name),
+        })),
+        indexes: (semanticModel.indexes ?? []).map((i) => ({
+          columns: i.columns,
+          ...ifDefined('name', i.name),
+          ...ifDefined('type', i.type),
+          ...ifDefined('options', i.options),
+        })),
+        foreignKeys,
+        ...(semanticModel.id
+          ? {
+              primaryKey: {
+                columns: semanticModel.id.columns,
+                ...ifDefined('name', semanticModel.id.name),
+              },
+            }
+          : {}),
+        ...(checksForTable.length > 0 ? { checks: checksForTable } : {}),
+      };
+
+      let nsTables = tablesByNamespace[namespaceId];
+      if (nsTables === undefined) {
+        nsTables = {};
+        tablesByNamespace[namespaceId] = nsTables;
+      }
+      if (nsTables[tableName] !== undefined) {
+        throw new Error(
+          `buildSqlContractFromDefinition: duplicate table "${tableName}" in namespace "${namespaceId}".`,
+        );
+      }
+      nsTables[tableName] = new StorageTable(tableInput);
     }
-    nsTables[tableName] = new StorageTable(tableInput);
 
     // --- Build contract model ---
 
@@ -466,6 +559,24 @@ export function buildSqlContractFromDefinition(
     );
     const modelRelations: Record<string, ContractRelation> = {};
     for (const relation of semanticModel.relations ?? []) {
+      // Cross-space relations have `spaceId` set — the target model lives in
+      // a different contract space, so skip local model lookup and validation.
+      if (relation.spaceId !== undefined) {
+        const targetNamespaceId = relation.namespaceId ?? defaultNamespaceId;
+        modelRelations[relation.fieldName] = {
+          to: crossRef(relation.toModel, targetNamespaceId, relation.spaceId),
+          // Cross-space belongsTo relations are always N:1 (the FK-owning side).
+          cardinality: 'N:1',
+          on: {
+            localFields: relation.on.parentColumns.map((col) => columnToField.get(col) ?? col),
+            // For cross-space targets the lowering carries field names directly
+            // (no fieldToColumn map available for the remote model).
+            targetFields: relation.on.childColumns,
+          },
+        };
+        continue;
+      }
+
       const targetModel = assertKnownTargetModel(
         modelsByName,
         semanticModel.modelName,
@@ -487,7 +598,7 @@ export function buildSqlContractFromDefinition(
       modelRelations[relation.fieldName] = {
         to: crossRef(
           relation.toModel,
-          resolveModelNamespaceId(targetModel, modelNameToNamespaceId, target),
+          resolveModelNamespaceId(targetModel, modelNameToNamespaceId, defaultNamespaceId),
         ),
         // RelationDefinition.cardinality includes 'N:M' which isn't in
         // ContractReferenceRelation yet — cast is needed until the contract
@@ -517,6 +628,7 @@ export function buildSqlContractFromDefinition(
     namespaceModels[semanticModel.modelName] = {
       storage: {
         table: tableName,
+        namespaceId,
         fields: storageFields,
       },
       fields: domainFields,
@@ -557,6 +669,39 @@ export function buildSqlContractFromDefinition(
   for (const id of Object.keys(namespaceEnumTypesById)) {
     namespaceCoordinateIds.add(id);
   }
+
+  // Build per-namespace registries for `enumType()` handles.
+  // All authored enums target the contract's default namespace.
+  const domainEnumsByNs: Record<string, Record<string, ContractEnum>> = {};
+  const storageValueSetsByNs: Record<string, Record<string, StorageValueSetInput>> = {};
+  for (const [enumName, handle] of Object.entries(definition.enums ?? {})) {
+    if (enumName !== handle.enumName) {
+      throw new Error(
+        `enum declaration key "${enumName}" must match enumType name "${handle.enumName}". Aliases are not supported.`,
+      );
+    }
+    const nsId = defaultNamespaceId;
+    let domainSlot = domainEnumsByNs[nsId];
+    if (domainSlot === undefined) {
+      domainSlot = {};
+      domainEnumsByNs[nsId] = domainSlot;
+    }
+    domainSlot[enumName] = {
+      codecId: handle.codecId,
+      members: handle.enumMembers,
+    };
+
+    let storageSlot = storageValueSetsByNs[nsId];
+    if (storageSlot === undefined) {
+      storageSlot = {};
+      storageValueSetsByNs[nsId] = storageSlot;
+    }
+    storageSlot[enumName] = {
+      kind: 'value-set',
+      values: handle.values,
+    };
+  }
+
   const { createNamespace } = definition;
   const namespaces = blindCast<
     SqlStorageInput['namespaces'],
@@ -565,18 +710,26 @@ export function buildSqlContractFromDefinition(
     Object.fromEntries(
       [...namespaceCoordinateIds].sort().map((id) => {
         const enumTypes = namespaceEnumTypesById[id];
+        const valueSetEntries = storageValueSetsByNs[id];
         const nsInput: SqlNamespaceTablesInput = {
           id,
-          tables: tablesByNamespace[id] ?? {},
-          ...ifDefined('enum', enumTypes),
+          entries: {
+            table: tablesByNamespace[id] ?? {},
+            ...(valueSetEntries !== undefined && Object.keys(valueSetEntries).length > 0
+              ? { valueSet: valueSetEntries }
+              : {}),
+          },
         };
-        return [id, createNamespace ? createNamespace(nsInput) : buildSqlNamespace(nsInput)];
+        return [
+          id,
+          createNamespace ? createNamespace(nsInput, enumTypes) : buildSqlNamespace(nsInput),
+        ];
       }),
     ),
   );
   const storageWithoutHash = {
     ...(Object.keys(documentTypes).length > 0 ? { types: documentTypes } : {}),
-    namespaces,
+    namespaces: ensureUnboundNamespaceSlot(namespaces, createNamespace),
   };
   const storageHash: StorageHashBase<string> = definition.storageHash
     ? coreHash(definition.storageHash)
@@ -672,7 +825,6 @@ export function buildSqlContractFromDefinition(
         )
       : undefined;
 
-  const defaultNamespaceId = defaultModelNamespaceId(target);
   const domainNamespaceIds = new Set(Object.keys(modelsByNamespace));
   if (domainNamespaceIds.size === 0) {
     domainNamespaceIds.add(defaultNamespaceId);
@@ -680,13 +832,22 @@ export function buildSqlContractFromDefinition(
   if (valueObjects !== undefined) {
     domainNamespaceIds.add(defaultNamespaceId);
   }
+  for (const nsId of Object.keys(domainEnumsByNs)) {
+    domainNamespaceIds.add(nsId);
+  }
   const domainNamespaces = Object.fromEntries(
     [...domainNamespaceIds].sort().map((namespaceId) => {
       const modelsInNs = modelsByNamespace[namespaceId] ?? {};
-      const namespaceSlice =
-        namespaceId === defaultNamespaceId && valueObjects !== undefined
-          ? { models: modelsInNs, valueObjects }
-          : { models: modelsInNs };
+      const enumsInNs = domainEnumsByNs[namespaceId];
+      const namespaceSlice = {
+        models: modelsInNs,
+        ...(namespaceId === defaultNamespaceId && valueObjects !== undefined
+          ? { valueObjects }
+          : {}),
+        ...(enumsInNs !== undefined && Object.keys(enumsInNs).length > 0
+          ? { enum: enumsInNs }
+          : {}),
+      };
       return [namespaceId, namespaceSlice];
     }),
   );
@@ -694,6 +855,7 @@ export function buildSqlContractFromDefinition(
   const contract: Contract<SqlStorage> = {
     target,
     targetFamily,
+    ...ifDefined('defaultControlPolicy', definition.defaultControlPolicy),
     domain: { namespaces: domainNamespaces },
     roots,
     storage,

package/src/config-types.ts

@@ -1,6 +1,7 @@
 import { pathToFileURL } from 'node:url';
 import type { ContractConfig } from '@prisma-next/config/config-types';
-import type { Contract } from '@prisma-next/contract/types';
+import { applySpecifierDefaultControlPolicy } from '@prisma-next/contract/apply-specifier-default-control-policy';
+import type { Contract, ControlPolicy } 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';
@@ -19,22 +20,35 @@ function defaultOutputFromContractPath(contractPath: string): string {
   return `${contractPath.slice(0, -ext.length)}.json`;
 }
 
+export interface TypeScriptContractSpecifierOptions {
+  readonly defaultControlPolicy?: ControlPolicy;
+}
+
 export function emptyContract(options: {
   readonly output?: string;
   readonly target: TargetPackRef<'sql', string>;
+  readonly defaultControlPolicy?: ControlPolicy;
 }): ContractConfig {
   return {
     source: {
-      load: async () => ok(buildSqlContractFromDefinition({ target: options.target, models: [] })),
+      load: async () => {
+        const built = buildSqlContractFromDefinition({ target: options.target, models: [] });
+        return ok(applySpecifierDefaultControlPolicy(built, options.defaultControlPolicy));
+      },
     },
     ...ifDefined('output', options.output),
   };
 }
 
-export function typescriptContract(contract: Contract, output?: string): ContractConfig {
+export function typescriptContract(
+  contract: Contract,
+  output?: string,
+  options?: TypeScriptContractSpecifierOptions,
+): ContractConfig {
   return {
     source: {
-      load: async () => ok(contract),
+      load: async () =>
+        ok(applySpecifierDefaultControlPolicy(contract, options?.defaultControlPolicy)),
     },
     // The in-memory variant has no input path to anchor on; fall through to
     // the global default in `normalizeContractConfig` when caller doesn't pin it.
@@ -42,7 +56,11 @@ export function typescriptContract(contract: Contract, output?: string): Contrac
   };
 }
 
-export function typescriptContractFromPath(contractPath: string, output?: string): ContractConfig {
+export function typescriptContractFromPath(
+  contractPath: string,
+  output?: string,
+  options?: TypeScriptContractSpecifierOptions,
+): ContractConfig {
   return {
     source: {
       inputs: [contractPath],
@@ -60,7 +78,7 @@ export function typescriptContractFromPath(contractPath: string, output?: string
             `typescriptContractFromPath: module at "${absolutePath}" has no "default" or "contract" export.`,
           );
         }
-        return ok(contract);
+        return ok(applySpecifierDefaultControlPolicy(contract, options?.defaultControlPolicy));
       },
     },
     output: output ?? defaultOutputFromContractPath(contractPath),