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

package/src/canonicalization-hooks.ts

@@ -0,0 +1,32 @@
+import type { PreserveEmptyPredicate, StorageSort } from '@prisma-next/contract/hashing';
+import {
+  createPreserveEmptyPredicate,
+  createStorageSort,
+  type NamedArraySortTarget,
+  type PathPattern,
+} from '@prisma-next/contract/hashing-utils';
+
+const preserveEmptyPatterns = [
+  ['storage', 'namespaces', '*', 'tables'],
+  ['storage', 'namespaces', '*', 'tables', '*'],
+  ['storage', 'namespaces', '*', 'tables', '*', ['uniques', 'indexes', 'foreignKeys']],
+  ['storage', 'namespaces', '*', 'tables', '*', 'foreignKeys', ['constraint', 'index']],
+  ['storage', 'types', '*', 'typeParams'],
+] as const satisfies readonly PathPattern[];
+
+const sortTargets = [
+  { path: ['namespaces', '*', 'tables', '*'], arrayKeys: ['indexes', 'uniques'] },
+] as const satisfies readonly NamedArraySortTarget[];
+
+const shouldPreserveEmpty: PreserveEmptyPredicate =
+  createPreserveEmptyPredicate(preserveEmptyPatterns);
+
+const sortStorage: StorageSort = createStorageSort(sortTargets);
+
+export const sqlContractCanonicalizationHooks: {
+  readonly shouldPreserveEmpty: PreserveEmptyPredicate;
+  readonly sortStorage: StorageSort;
+} = {
+  shouldPreserveEmpty,
+  sortStorage,
+};

package/src/exports/canonicalization-hooks.ts

@@ -0,0 +1 @@
+export { sqlContractCanonicalizationHooks } from '../canonicalization-hooks';

package/src/exports/types.ts

@@ -37,6 +37,8 @@ export type {
 } from '../types';
 export {
   applyFkDefaults,
+  buildSqlNamespace,
+  buildSqlNamespaceMap,
   CODEC_INSTANCE_KIND,
   DEFAULT_FK_CONSTRAINT,
   DEFAULT_FK_INDEX,

package/src/factories.ts

@@ -1,4 +1,4 @@
-import type { ScalarFieldType } from '@prisma-next/contract/types';
+import { asNamespaceId, type ScalarFieldType } from '@prisma-next/contract/types';
 import { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';
 import {
   applyFkDefaults,
@@ -38,7 +38,7 @@ export function fk(
   opts?: ForeignKeyOptions & { constraint?: boolean; index?: boolean; namespaceId?: string },
 ): ForeignKey {
   const defaults = applyFkDefaults({ constraint: opts?.constraint, index: opts?.index });
-  const namespaceId = opts?.namespaceId ?? UNBOUND_NAMESPACE_ID;
+  const namespaceId = asNamespaceId(opts?.namespaceId ?? UNBOUND_NAMESPACE_ID);
   return new ForeignKey({
     source: { namespaceId, tableName: srcTableName, columns: srcColumns },
     target: { namespaceId, tableName: targetTableName, columns: targetColumns },

package/src/ir/build-sql-namespace.ts

@@ -0,0 +1,89 @@
+import {
+  freezeNode,
+  type Namespace,
+  NamespaceBase,
+  UNBOUND_NAMESPACE_ID,
+} from '@prisma-next/framework-components/ir';
+import { blindCast, castAs } from '@prisma-next/utils/casts';
+import type { PostgresEnumStorageEntry } from './postgres-enum-storage-entry';
+import type { SqlNamespace, SqlNamespaceTablesInput } from './sql-storage';
+import { SqlUnboundNamespace } from './sql-unbound-namespace';
+import { StorageTable } from './storage-table';
+
+const SQL_NAMESPACE_KIND = 'sql-namespace' as const;
+
+function isMaterializedSqlNamespace(ns: Namespace | SqlNamespaceTablesInput): ns is SqlNamespace {
+  if (typeof ns !== 'object' || ns === null) {
+    return false;
+  }
+  const proto = Object.getPrototypeOf(ns);
+  if (proto === Object.prototype || proto === null) {
+    return false;
+  }
+  return (ns as Namespace).kind === SQL_NAMESPACE_KIND;
+}
+
+class SqlBoundNamespace extends NamespaceBase {
+  declare readonly kind: string;
+  declare readonly enum?: Readonly<Record<string, PostgresEnumStorageEntry>>;
+
+  readonly id: string;
+  readonly tables: Readonly<Record<string, StorageTable>>;
+
+  static fromTablesInput(input: SqlNamespaceTablesInput): SqlNamespace {
+    const tableCount = Object.keys(input.tables ?? {}).length;
+    const enumCount = Object.keys(input.enum ?? {}).length;
+    if (input.id === UNBOUND_NAMESPACE_ID && tableCount === 0 && enumCount === 0) {
+      return castAs<SqlNamespace>(SqlUnboundNamespace.instance);
+    }
+    return castAs<SqlNamespace>(new SqlBoundNamespace(input));
+  }
+
+  private constructor(input: SqlNamespaceTablesInput) {
+    super();
+    this.id = input.id;
+    this.tables = Object.freeze(
+      Object.fromEntries(
+        Object.entries(input.tables ?? {}).map(([name, t]) => [
+          name,
+          t instanceof StorageTable ? t : new StorageTable(t),
+        ]),
+      ),
+    );
+    if (input.enum !== undefined && Object.keys(input.enum).length > 0) {
+      Object.defineProperty(this, 'enum', {
+        value: Object.freeze({ ...input.enum }),
+        writable: false,
+        enumerable: true,
+        configurable: false,
+      });
+    }
+    Object.defineProperty(this, 'kind', {
+      value: SQL_NAMESPACE_KIND,
+      writable: false,
+      enumerable: false,
+      configurable: true,
+    });
+    freezeNode(this);
+  }
+}
+
+export function buildSqlNamespace(input: SqlNamespaceTablesInput): SqlNamespace {
+  return SqlBoundNamespace.fromTablesInput(input);
+}
+
+export function buildSqlNamespaceMap(
+  namespaces: Readonly<Record<string, Namespace | SqlNamespaceTablesInput>>,
+): Readonly<Record<string, SqlNamespace>> {
+  return Object.fromEntries(
+    Object.entries(namespaces).map(([nsKey, ns]) => [
+      nsKey,
+      isMaterializedSqlNamespace(ns)
+        ? blindCast<
+            SqlNamespace,
+            'a materialised SQL-family namespace entry in a namespace map is a SqlNamespace'
+          >(ns)
+        : SqlBoundNamespace.fromTablesInput(ns),
+    ]),
+  );
+}

package/src/ir/foreign-key-reference.ts

@@ -1,3 +1,4 @@
+import { asNamespaceId, type NamespaceId } from '@prisma-next/contract/types';
 import { freezeNode } from '@prisma-next/framework-components/ir';
 import { SqlNode } from './sql-node';
 
@@ -15,13 +16,13 @@ export interface ForeignKeyReferenceInput {
  * as the sentinel `namespaceId` for single-namespace (unbound) references.
  */
 export class ForeignKeyReference extends SqlNode {
-  readonly namespaceId: string;
+  readonly namespaceId: NamespaceId;
   readonly tableName: string;
   readonly columns: readonly string[];
 
   constructor(input: ForeignKeyReferenceInput) {
     super();
-    this.namespaceId = input.namespaceId;
+    this.namespaceId = asNamespaceId(input.namespaceId);
     this.tableName = input.tableName;
     this.columns = input.columns;
     freezeNode(this);

package/src/ir/sql-storage.ts

@@ -1,18 +1,11 @@
 import type { StorageHashBase } from '@prisma-next/contract/types';
-import {
-  freezeNode,
-  type Namespace,
-  NamespaceBase,
-  type Storage,
-  UNBOUND_NAMESPACE_ID,
-} from '@prisma-next/framework-components/ir';
+import { freezeNode, type Namespace, type Storage } from '@prisma-next/framework-components/ir';
 import {
   isPostgresEnumStorageEntry,
   type PostgresEnumStorageEntry,
 } from './postgres-enum-storage-entry';
 import { SqlNode } from './sql-node';
-import { SqlUnboundNamespace } from './sql-unbound-namespace';
-import { StorageTable, type StorageTableInput } from './storage-table';
+import type { StorageTable, StorageTableInput } from './storage-table';
 import {
   isStorageTypeInstance,
   type StorageTypeInstance,
@@ -30,10 +23,6 @@ export type SqlStorageTypeEntry =
   | StorageTypeInstanceInput
   | PostgresEnumStorageEntry;
 
-const DEFAULT_NAMESPACES: Readonly<Record<string, Namespace>> = Object.freeze({
-  [UNBOUND_NAMESPACE_ID]: SqlUnboundNamespace.instance,
-});
-
 export interface SqlNamespaceTablesInput {
   readonly id: string;
   readonly tables?: Record<string, StorageTable | StorageTableInput>;
@@ -43,59 +32,7 @@ export interface SqlNamespaceTablesInput {
 export interface SqlStorageInput<THash extends string = string> {
   readonly storageHash: StorageHashBase<THash>;
   readonly types?: Record<string, SqlStorageTypeEntry>;
-  readonly namespaces?: Readonly<Record<string, Namespace | SqlNamespaceTablesInput>>;
-}
-
-class SqlNamespacePayload extends NamespaceBase {
-  declare readonly kind: string;
-  declare readonly enum?: Readonly<Record<string, PostgresEnumStorageEntry>>;
-
-  readonly id: string;
-  readonly tables: Readonly<Record<string, StorageTable>>;
-
-  constructor(input: SqlNamespaceTablesInput) {
-    super();
-    this.id = input.id;
-    this.tables = Object.freeze(
-      Object.fromEntries(
-        Object.entries(input.tables ?? {}).map(([name, t]) => [
-          name,
-          t instanceof StorageTable ? t : new StorageTable(t),
-        ]),
-      ),
-    );
-    if (input.enum !== undefined && Object.keys(input.enum).length > 0) {
-      Object.defineProperty(this, 'enum', {
-        value: Object.freeze({ ...input.enum }),
-        writable: false,
-        enumerable: true,
-        configurable: false,
-      });
-    }
-    Object.defineProperty(this, 'kind', {
-      value: 'sql-namespace',
-      writable: false,
-      enumerable: false,
-      configurable: true,
-    });
-    freezeNode(this);
-  }
-}
-
-function normaliseNamespaceEntry(
-  nsKey: string,
-  ns: Namespace | SqlNamespaceTablesInput,
-): Namespace {
-  if (ns instanceof NamespaceBase) {
-    return ns;
-  }
-  const input = ns as SqlNamespaceTablesInput; // JSON namespace payloads match SqlNamespaceTablesInput before SqlNamespacePayload materialises StorageTable instances.
-  const tableCount = Object.keys(input.tables ?? {}).length;
-  const typeCount = Object.keys(input.enum ?? {}).length;
-  if (nsKey === UNBOUND_NAMESPACE_ID && tableCount === 0 && typeCount === 0) {
-    return SqlUnboundNamespace.instance;
-  }
-  return new SqlNamespacePayload(input);
+  readonly namespaces: Readonly<Record<string, SqlNamespace>>;
 }
 
 /**
@@ -108,16 +45,11 @@ function normaliseNamespaceEntry(
  * target-specific storage extensions).
  *
  * Honours the framework `Storage` interface: every SQL IR carries a
- * `namespaces` map keyed by namespace id. The default singleton
- * (`{ [UNBOUND_NAMESPACE_ID]: SqlUnboundNamespace.instance }`)
- * binds every contract authored before per-target namespace concretions
- * land; per-target namespace classes (`PostgresSchema.unbound`,
- * `SqliteUnboundDatabase.instance`) earn their slots when each
- * target's namespace shape lands.
+ * `namespaces` map keyed by namespace id. Callers must supply fully
+ * constructed `Namespace` instances — construction discipline lives
+ * in the authoring builders and deserializer hydration paths.
  *
- * The constructor normalises optional `types` into class instances and
- * materialises plain namespace envelope objects into `Namespace` class
- * instances so downstream walks see a uniform AST.
+ * The constructor normalises optional `types` into class instances.
  * `types` is polymorphic per Decision 18 Option B: codec-triple inputs
  * are stamped with `kind: 'codec-instance'`; class-instance kinds
  * (e.g. Postgres-enum entries satisfying `PostgresEnumStorageEntry`)
@@ -129,7 +61,7 @@ function normaliseNamespaceEntry(
 // SQL concretions always store `StorageTable`-shaped values in `tables`.
 // `tables` is a SQL-family idiom — the framework `Namespace` contract no
 // longer mandates this field; Mongo namespaces carry `collections`
-// instead. The `__unbound__` slot uses the same narrowing as every other
+// instead. The `tables` slot uses the same narrowing as every other
 // SQL namespace; the wider `Record<string, object>` on `StorageTable` is
 // only there so emitted `contract.d.ts` table literals (which lack the
 // runtime `kind` discriminator on `StorageTable`) structurally satisfy
@@ -141,27 +73,13 @@ export type SqlNamespace = Namespace & {
 
 export class SqlStorage<THash extends string = string> extends SqlNode implements Storage {
   readonly storageHash: StorageHashBase<THash>;
-  readonly namespaces: Readonly<Record<string, SqlNamespace>> & {
-    readonly __unbound__: SqlNamespace;
-  };
+  readonly namespaces: Readonly<Record<string, SqlNamespace>>;
   declare readonly types?: Readonly<Record<string, StorageTypeInstance | PostgresEnumStorageEntry>>;
 
   constructor(input: SqlStorageInput<THash>) {
     super();
     this.storageHash = input.storageHash;
-    const inputNamespaces = input.namespaces ?? DEFAULT_NAMESPACES;
-    const normalised: Record<string, SqlNamespace> = Object.fromEntries(
-      Object.entries(inputNamespaces).map(([nsKey, ns]) => [
-        nsKey,
-        normaliseNamespaceEntry(nsKey, ns) as SqlNamespace,
-      ]),
-    );
-    if (!normalised[UNBOUND_NAMESPACE_ID]) {
-      normalised[UNBOUND_NAMESPACE_ID] = SqlUnboundNamespace.instance as SqlNamespace;
-    }
-    this.namespaces = Object.freeze(normalised) as Readonly<Record<string, SqlNamespace>> & {
-      readonly __unbound__: SqlNamespace;
-    };
+    this.namespaces = Object.freeze(input.namespaces);
     if (input.types !== undefined) {
       this.types = Object.freeze(
         Object.fromEntries(

package/src/types.ts

@@ -1,6 +1,7 @@
 import type { CodecTrait } from '@prisma-next/framework-components/codec';
 import type { ReferentialAction } from './ir/foreign-key';
 
+export { buildSqlNamespace, buildSqlNamespaceMap } from './ir/build-sql-namespace';
 export {
   ForeignKey,
   type ForeignKeyInput,

package/src/validators.ts

@@ -1,8 +1,17 @@
 import { ContractValidationError } from '@prisma-next/contract/contract-validation-error';
-import type { Contract, ContractField, ContractModel } from '@prisma-next/contract/types';
+import {
+  type Contract,
+  type ContractField,
+  type ContractModel,
+  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,
@@ -129,11 +138,12 @@ export const IndexSchema = type({
   'options?': 'Record<string, unknown>',
 });
 
-export const ForeignKeyReferenceSchema = type.declare<ForeignKeyReferenceInput>().type({
+export const ForeignKeyReferenceSchema = type({
+  '+': 'reject',
   namespaceId: 'string',
   tableName: 'string',
   columns: type.string.array().readonly(),
-});
+}) satisfies Type<ForeignKeyReferenceInput>;
 
 export const ReferentialActionSchema = type
   .declare<ReferentialAction>()
@@ -256,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>;
 }
@@ -351,13 +366,32 @@ const ModelStorageSchema = type({
   fields: type({ '[string]': ModelStorageFieldSchema }),
 });
 
+const ContractReferenceRelationSchema = type({
+  '+': 'reject',
+  to: CrossReferenceSchema,
+  cardinality: "'1:1' | '1:N' | 'N:1'",
+  on: type({
+    '+': 'reject',
+    localFields: type.string.array().readonly(),
+    targetFields: type.string.array().readonly(),
+  }),
+});
+
+const ContractEmbedRelationSchema = type({
+  '+': 'reject',
+  to: CrossReferenceSchema,
+  cardinality: "'1:1' | '1:N'",
+});
+
+const ContractRelationSchema = ContractReferenceRelationSchema.or(ContractEmbedRelationSchema);
+
 const ModelSchema = type({
   storage: ModelStorageSchema,
   'fields?': type({ '[string]': ModelFieldSchema }),
-  'relations?': type({ '[string]': 'unknown' }),
+  'relations?': type({ '[string]': ContractRelationSchema }),
   'discriminator?': 'unknown',
   'variants?': 'unknown',
-  'base?': 'string',
+  'base?': CrossReferenceSchema,
   'owner?': 'string',
 });
 
@@ -383,10 +417,15 @@ export function createSqlContractSchema(
     'capabilities?': 'Record<string, Record<string, boolean>>',
     'extensionPacks?': 'Record<string, unknown>',
     'meta?': ContractMetaSchema,
-    'roots?': 'Record<string, string>',
-    models: type({ '[string]': ModelSchema }),
-    'valueObjects?': 'Record<string, unknown>',
-    'domain?': 'unknown',
+    'roots?': type({ '[string]': CrossReferenceSchema }),
+    domain: type({
+      namespaces: type({
+        '[string]': type({
+          models: type({ '[string]': ModelSchema }),
+          'valueObjects?': 'Record<string, unknown>',
+        }),
+      }),
+    }),
     storage,
     'execution?': ExecutionSchema,
   }) as Type<unknown>;
@@ -413,11 +452,26 @@ 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`.
-  return new SqlStorage(result as SqlStorageInput);
+  // 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 ?? {});
+  // Compatibility shim: inject the empty unbound singleton when absent so that
+  // production code paths which address __unbound__ for table metadata have a
+  // slot to read or write into. The `SqlStorageInput['namespaces']` type no
+  // longer requires __unbound__, so this is a runtime convenience, not a type
+  // invariant.
+  const unbound = namespaces[UNBOUND_NAMESPACE_ID] ?? SqlUnboundNamespace.instance;
+  return new SqlStorage({
+    storageHash: validated.storageHash,
+    ...ifDefined('types', validated.types),
+    namespaces: { ...namespaces, [UNBOUND_NAMESPACE_ID]: unbound },
+  });
 }
 
 export function validateModel(value: unknown): unknown {
@@ -633,43 +687,46 @@ export function validateStorageSemantics(storage: SqlStorage): string[] {
  * columns. Throws `ContractValidationError` on the first mismatch.
  */
 export function validateModelStorageReferences(contract: Contract<SqlStorage>): void {
-  const models = contract.models as Record<string, ContractModel<SqlModelStorage>>;
-  for (const [modelName, model] of Object.entries(models)) {
-    const storageTable = model.storage.table;
-
-    const rawTable = findStorageTableByTableName(contract.storage, storageTable);
-    if (rawTable === undefined) {
-      throw new ContractValidationError(
-        `Model "${modelName}" references non-existent table "${storageTable}"`,
-        'storage',
-      );
-    }
-
-    const table = rawTable as StorageTable;
-
-    const columnNames = new Set(Object.keys(table.columns));
-    for (const [fieldName, field] of Object.entries(model.storage.fields)) {
-      if (!columnNames.has(field.column)) {
+  for (const [namespaceId, namespace] of Object.entries(contract.domain.namespaces)) {
+    const models = namespace.models as Record<string, ContractModel<SqlModelStorage>>;
+    for (const [modelName, model] of Object.entries(models)) {
+      const qualifiedName = `${namespaceId}:${modelName}`;
+      const storageTable = model.storage.table;
+
+      const rawTable = findStorageTableByTableName(contract.storage, storageTable);
+      if (rawTable === undefined) {
         throw new ContractValidationError(
-          `Model "${modelName}" field "${fieldName}" references non-existent column "${field.column}" in table "${storageTable}"`,
+          `Model "${qualifiedName}" references non-existent table "${storageTable}"`,
           'storage',
         );
       }
-    }
 
-    const JSON_NATIVE_TYPES = new Set(['json', 'jsonb']);
-    for (const [fieldName, domainField] of Object.entries(model.fields ?? {})) {
-      const f = domainField as ContractField;
-      if (f.type?.kind !== 'valueObject') continue;
-      const storageField = model.storage.fields[fieldName];
-      if (!storageField) continue;
-      const column = table.columns[storageField.column];
-      if (!column) continue;
-      if (!JSON_NATIVE_TYPES.has(column.nativeType)) {
-        throw new ContractValidationError(
-          `Model "${modelName}" field "${fieldName}" is a value object but storage column "${storageField.column}" has nativeType "${column.nativeType}" (expected json or jsonb)`,
-          'storage',
-        );
+      const table = rawTable as StorageTable;
+
+      const columnNames = new Set(Object.keys(table.columns));
+      for (const [fieldName, field] of Object.entries(model.storage.fields)) {
+        if (!columnNames.has(field.column)) {
+          throw new ContractValidationError(
+            `Model "${qualifiedName}" field "${fieldName}" references non-existent column "${field.column}" in table "${storageTable}"`,
+            'storage',
+          );
+        }
+      }
+
+      const JSON_NATIVE_TYPES = new Set(['json', 'jsonb']);
+      for (const [fieldName, domainField] of Object.entries(model.fields ?? {})) {
+        const f = domainField as ContractField;
+        if (f.type?.kind !== 'valueObject') continue;
+        const storageField = model.storage.fields[fieldName];
+        if (!storageField) continue;
+        const column = table.columns[storageField.column];
+        if (!column) continue;
+        if (!JSON_NATIVE_TYPES.has(column.nativeType)) {
+          throw new ContractValidationError(
+            `Model "${qualifiedName}" field "${fieldName}" is a value object but storage column "${storageField.column}" has nativeType "${column.nativeType}" (expected json or jsonb)`,
+            'storage',
+          );
+        }
       }
     }
   }
@@ -809,8 +866,7 @@ export function validateSqlContractFully<T extends Contract<SqlStorage>>(
   const validated = validateSqlContractStructure<T>(stripped, schema);
   validateContractDomain({
     roots: validated.roots,
-    models: validated.models,
-    ...(validated.valueObjects ? { valueObjects: validated.valueObjects } : {}),
+    domain: validated.domain,
   });
   validateSqlStorageConsistency(validated);
   const semanticErrors = validateStorageSemantics(validated.storage);