diff --git a/examples/prisma-next-demo-sqlite/migrations/app/refs/db.contract.d.ts b/examples/prisma-next-demo-sqlite/migrations/app/refs/db.contract.d.ts
new file mode 100644
index 0000000000..6e028057fb
--- /dev/null
+++ b/examples/prisma-next-demo-sqlite/migrations/app/refs/db.contract.d.ts
@@ -0,0 +1,673 @@
+// ⚠️  GENERATED FILE - DO NOT EDIT
+// This file is automatically generated by 'prisma-next contract emit'.
+// To regenerate, run: prisma-next contract emit
+import type { CodecTypes as SqliteTypes } from '@prisma-next/adapter-sqlite/codec-types';
+
+import type {
+  ContractWithTypeMaps,
+  TypeMaps as TypeMapsType,
+} from '@prisma-next/sql-contract/types';
+import type {
+  Contract as ContractType,
+  ContractModelsMap,
+  ExecutionHashBase,
+  NamespaceId,
+  ProfileHashBase,
+  StorageHashBase,
+} from '@prisma-next/contract/types';
+
+export type StorageHash =
+  StorageHashBase<'sha256:194cf0bce4a19c7191f9e4ae8670de21707c48678d7b8998d38708a506488c88'>;
+export type ExecutionHash =
+  ExecutionHashBase<'sha256:70c6ceb0ed79d5888519ec84bf32e31a056283fa8d5c7b5c1ba65b709f8595c8'>;
+export type ProfileHash =
+  ProfileHashBase<'sha256:3cc333ecad9f3f4c7229370a9d2c37e908cdce0f8d2e9fb132d50605b024eff2'>;
+
+export type CodecTypes = SqliteTypes;
+export type LaneCodecTypes = CodecTypes;
+export type QueryOperationTypes = Record<string, never>;
+type DefaultLiteralValue<CodecId extends string, _Encoded> = CodecId extends keyof CodecTypes
+  ? CodecTypes[CodecId]['output']
+  : _Encoded;
+
+export type FieldOutputTypes = {
+  readonly Post: {
+    readonly id: CodecTypes['sql/char@1']['output'];
+    readonly title: CodecTypes['sqlite/text@1']['output'];
+    readonly userId: CodecTypes['sql/char@1']['output'];
+    readonly createdAt: CodecTypes['sqlite/datetime@1']['output'];
+  };
+  readonly PostTag: {
+    readonly postId: CodecTypes['sql/char@1']['output'];
+    readonly tagId: CodecTypes['sql/char@1']['output'];
+  };
+  readonly Tag: {
+    readonly id: CodecTypes['sql/char@1']['output'];
+    readonly label: CodecTypes['sqlite/text@1']['output'];
+  };
+  readonly User: {
+    readonly id: CodecTypes['sql/char@1']['output'];
+    readonly email: CodecTypes['sqlite/text@1']['output'];
+    readonly displayName: CodecTypes['sqlite/text@1']['output'];
+    readonly createdAt: CodecTypes['sqlite/datetime@1']['output'];
+  };
+};
+export type FieldInputTypes = {
+  readonly Post: {
+    readonly id: CodecTypes['sql/char@1']['input'];
+    readonly title: CodecTypes['sqlite/text@1']['input'];
+    readonly userId: CodecTypes['sql/char@1']['input'];
+    readonly createdAt: CodecTypes['sqlite/datetime@1']['input'];
+  };
+  readonly PostTag: {
+    readonly postId: CodecTypes['sql/char@1']['input'];
+    readonly tagId: CodecTypes['sql/char@1']['input'];
+  };
+  readonly Tag: {
+    readonly id: CodecTypes['sql/char@1']['input'];
+    readonly label: CodecTypes['sqlite/text@1']['input'];
+  };
+  readonly User: {
+    readonly id: CodecTypes['sql/char@1']['input'];
+    readonly email: CodecTypes['sqlite/text@1']['input'];
+    readonly displayName: CodecTypes['sqlite/text@1']['input'];
+    readonly createdAt: CodecTypes['sqlite/datetime@1']['input'];
+  };
+};
+export type TypeMaps = TypeMapsType<
+  CodecTypes,
+  QueryOperationTypes,
+  FieldOutputTypes,
+  FieldInputTypes
+>;
+
+type ContractBase = Omit<
+  ContractType<
+    {
+      readonly namespaces: {
+        readonly __unbound__: {
+          readonly id: '__unbound__';
+          readonly kind: 'sql-namespace';
+          readonly tables: {
+            readonly post: {
+              columns: {
+                readonly id: {
+                  readonly nativeType: 'character';
+                  readonly codecId: 'sql/char@1';
+                  readonly nullable: false;
+                  readonly typeParams: { readonly length: 36 };
+                };
+                readonly title: {
+                  readonly nativeType: 'text';
+                  readonly codecId: 'sqlite/text@1';
+                  readonly nullable: false;
+                };
+                readonly userId: {
+                  readonly nativeType: 'character';
+                  readonly codecId: 'sql/char@1';
+                  readonly nullable: false;
+                  readonly typeParams: { readonly length: 36 };
+                };
+                readonly createdAt: {
+                  readonly nativeType: 'text';
+                  readonly codecId: 'sqlite/datetime@1';
+                  readonly nullable: false;
+                  readonly default: { readonly kind: 'function'; readonly expression: 'now()' };
+                };
+              };
+              primaryKey: { readonly columns: readonly ['id'] };
+              uniques: readonly [];
+              indexes: readonly [];
+              foreignKeys: readonly [
+                {
+                  readonly source: {
+                    readonly namespaceId: '__unbound__' & NamespaceId;
+                    readonly tableName: 'post';
+                    readonly columns: readonly ['userId'];
+                  };
+                  readonly target: {
+                    readonly namespaceId: '__unbound__' & NamespaceId;
+                    readonly tableName: 'user';
+                    readonly columns: readonly ['id'];
+                  };
+                  readonly name: 'post_userId_fkey';
+                  readonly constraint: true;
+                  readonly index: true;
+                },
+              ];
+            };
+            readonly post_tag: {
+              columns: {
+                readonly postId: {
+                  readonly nativeType: 'character';
+                  readonly codecId: 'sql/char@1';
+                  readonly nullable: false;
+                  readonly typeParams: { readonly length: 36 };
+                };
+                readonly tagId: {
+                  readonly nativeType: 'character';
+                  readonly codecId: 'sql/char@1';
+                  readonly nullable: false;
+                  readonly typeParams: { readonly length: 36 };
+                };
+              };
+              primaryKey: {
+                readonly columns: readonly ['postId', 'tagId'];
+                readonly name: 'post_tag_pkey';
+              };
+              uniques: readonly [];
+              indexes: readonly [];
+              foreignKeys: readonly [
+                {
+                  readonly source: {
+                    readonly namespaceId: '__unbound__' & NamespaceId;
+                    readonly tableName: 'post_tag';
+                    readonly columns: readonly ['postId'];
+                  };
+                  readonly target: {
+                    readonly namespaceId: '__unbound__' & NamespaceId;
+                    readonly tableName: 'post';
+                    readonly columns: readonly ['id'];
+                  };
+                  readonly name: 'post_tag_postId_fkey';
+                  readonly constraint: true;
+                  readonly index: true;
+                },
+                {
+                  readonly source: {
+                    readonly namespaceId: '__unbound__' & NamespaceId;
+                    readonly tableName: 'post_tag';
+                    readonly columns: readonly ['tagId'];
+                  };
+                  readonly target: {
+                    readonly namespaceId: '__unbound__' & NamespaceId;
+                    readonly tableName: 'tag';
+                    readonly columns: readonly ['id'];
+                  };
+                  readonly name: 'post_tag_tagId_fkey';
+                  readonly constraint: true;
+                  readonly index: true;
+                },
+              ];
+            };
+            readonly tag: {
+              columns: {
+                readonly id: {
+                  readonly nativeType: 'character';
+                  readonly codecId: 'sql/char@1';
+                  readonly nullable: false;
+                  readonly typeParams: { readonly length: 36 };
+                };
+                readonly label: {
+                  readonly nativeType: 'text';
+                  readonly codecId: 'sqlite/text@1';
+                  readonly nullable: false;
+                };
+              };
+              primaryKey: { readonly columns: readonly ['id'] };
+              uniques: readonly [];
+              indexes: readonly [];
+              foreignKeys: readonly [];
+            };
+            readonly user: {
+              columns: {
+                readonly id: {
+                  readonly nativeType: 'character';
+                  readonly codecId: 'sql/char@1';
+                  readonly nullable: false;
+                  readonly typeParams: { readonly length: 36 };
+                };
+                readonly email: {
+                  readonly nativeType: 'text';
+                  readonly codecId: 'sqlite/text@1';
+                  readonly nullable: false;
+                };
+                readonly displayName: {
+                  readonly nativeType: 'text';
+                  readonly codecId: 'sqlite/text@1';
+                  readonly nullable: false;
+                };
+                readonly createdAt: {
+                  readonly nativeType: 'text';
+                  readonly codecId: 'sqlite/datetime@1';
+                  readonly nullable: false;
+                  readonly default: { readonly kind: 'function'; readonly expression: 'now()' };
+                };
+              };
+              primaryKey: { readonly columns: readonly ['id'] };
+              uniques: readonly [];
+              indexes: readonly [];
+              foreignKeys: readonly [];
+            };
+          };
+        };
+      };
+      readonly storageHash: StorageHash;
+    },
+    {
+      readonly Post: {
+        readonly fields: {
+          readonly id: {
+            readonly nullable: false;
+            readonly type: {
+              readonly kind: 'scalar';
+              readonly codecId: 'sql/char@1';
+              readonly typeParams: { readonly length: 36 };
+            };
+          };
+          readonly title: {
+            readonly nullable: false;
+            readonly type: { readonly kind: 'scalar'; readonly codecId: 'sqlite/text@1' };
+          };
+          readonly userId: {
+            readonly nullable: false;
+            readonly type: {
+              readonly kind: 'scalar';
+              readonly codecId: 'sql/char@1';
+              readonly typeParams: { readonly length: 36 };
+            };
+          };
+          readonly createdAt: {
+            readonly nullable: false;
+            readonly type: { readonly kind: 'scalar'; readonly codecId: 'sqlite/datetime@1' };
+          };
+        };
+        readonly relations: {
+          readonly user: {
+            readonly to: {
+              readonly namespace: '__unbound__' & NamespaceId;
+              readonly model: 'User';
+            };
+            readonly cardinality: 'N:1';
+            readonly on: {
+              readonly localFields: readonly ['userId'];
+              readonly targetFields: readonly ['id'];
+            };
+          };
+          readonly tags: {
+            readonly to: { readonly namespace: '__unbound__' & NamespaceId; readonly model: 'Tag' };
+            readonly cardinality: 'N:M';
+            readonly on: {
+              readonly localFields: readonly ['id'];
+              readonly targetFields: readonly ['postId'];
+            };
+            readonly through: {
+              readonly table: 'post_tag';
+              readonly parentColumns: readonly ['postId'];
+              readonly childColumns: readonly ['tagId'];
+              readonly targetColumns: readonly ['id'];
+            };
+          };
+        };
+        readonly storage: {
+          readonly table: 'post';
+          readonly fields: {
+            readonly id: { readonly column: 'id' };
+            readonly title: { readonly column: 'title' };
+            readonly userId: { readonly column: 'userId' };
+            readonly createdAt: { readonly column: 'createdAt' };
+          };
+        };
+      };
+      readonly PostTag: {
+        readonly fields: {
+          readonly postId: {
+            readonly nullable: false;
+            readonly type: {
+              readonly kind: 'scalar';
+              readonly codecId: 'sql/char@1';
+              readonly typeParams: { readonly length: 36 };
+            };
+          };
+          readonly tagId: {
+            readonly nullable: false;
+            readonly type: {
+              readonly kind: 'scalar';
+              readonly codecId: 'sql/char@1';
+              readonly typeParams: { readonly length: 36 };
+            };
+          };
+        };
+        readonly relations: Record<string, never>;
+        readonly storage: {
+          readonly table: 'post_tag';
+          readonly fields: {
+            readonly postId: { readonly column: 'postId' };
+            readonly tagId: { readonly column: 'tagId' };
+          };
+        };
+      };
+      readonly Tag: {
+        readonly fields: {
+          readonly id: {
+            readonly nullable: false;
+            readonly type: {
+              readonly kind: 'scalar';
+              readonly codecId: 'sql/char@1';
+              readonly typeParams: { readonly length: 36 };
+            };
+          };
+          readonly label: {
+            readonly nullable: false;
+            readonly type: { readonly kind: 'scalar'; readonly codecId: 'sqlite/text@1' };
+          };
+        };
+        readonly relations: {
+          readonly posts: {
+            readonly to: {
+              readonly namespace: '__unbound__' & NamespaceId;
+              readonly model: 'Post';
+            };
+            readonly cardinality: 'N:M';
+            readonly on: {
+              readonly localFields: readonly ['id'];
+              readonly targetFields: readonly ['tagId'];
+            };
+            readonly through: {
+              readonly table: 'post_tag';
+              readonly parentColumns: readonly ['tagId'];
+              readonly childColumns: readonly ['postId'];
+              readonly targetColumns: readonly ['id'];
+            };
+          };
+        };
+        readonly storage: {
+          readonly table: 'tag';
+          readonly fields: {
+            readonly id: { readonly column: 'id' };
+            readonly label: { readonly column: 'label' };
+          };
+        };
+      };
+      readonly User: {
+        readonly fields: {
+          readonly id: {
+            readonly nullable: false;
+            readonly type: {
+              readonly kind: 'scalar';
+              readonly codecId: 'sql/char@1';
+              readonly typeParams: { readonly length: 36 };
+            };
+          };
+          readonly email: {
+            readonly nullable: false;
+            readonly type: { readonly kind: 'scalar'; readonly codecId: 'sqlite/text@1' };
+          };
+          readonly displayName: {
+            readonly nullable: false;
+            readonly type: { readonly kind: 'scalar'; readonly codecId: 'sqlite/text@1' };
+          };
+          readonly createdAt: {
+            readonly nullable: false;
+            readonly type: { readonly kind: 'scalar'; readonly codecId: 'sqlite/datetime@1' };
+          };
+        };
+        readonly relations: {
+          readonly posts: {
+            readonly to: {
+              readonly namespace: '__unbound__' & NamespaceId;
+              readonly model: 'Post';
+            };
+            readonly cardinality: '1:N';
+            readonly on: {
+              readonly localFields: readonly ['id'];
+              readonly targetFields: readonly ['userId'];
+            };
+          };
+        };
+        readonly storage: {
+          readonly table: 'user';
+          readonly fields: {
+            readonly id: { readonly column: 'id' };
+            readonly email: { readonly column: 'email' };
+            readonly displayName: { readonly column: 'displayName' };
+            readonly createdAt: { readonly column: 'createdAt' };
+          };
+        };
+      };
+    }
+  >,
+  'roots' | 'domain'
+> & {
+  readonly target: 'sqlite';
+  readonly targetFamily: 'sql';
+  readonly roots: {
+    readonly user: { readonly namespace: '__unbound__' & NamespaceId; readonly model: 'User' };
+    readonly post: { readonly namespace: '__unbound__' & NamespaceId; readonly model: 'Post' };
+    readonly tag: { readonly namespace: '__unbound__' & NamespaceId; readonly model: 'Tag' };
+    readonly post_tag: {
+      readonly namespace: '__unbound__' & NamespaceId;
+      readonly model: 'PostTag';
+    };
+  };
+  readonly domain: {
+    readonly namespaces: {
+      readonly __unbound__: {
+        readonly models: {
+          readonly Post: {
+            readonly fields: {
+              readonly id: {
+                readonly nullable: false;
+                readonly type: {
+                  readonly kind: 'scalar';
+                  readonly codecId: 'sql/char@1';
+                  readonly typeParams: { readonly length: 36 };
+                };
+              };
+              readonly title: {
+                readonly nullable: false;
+                readonly type: { readonly kind: 'scalar'; readonly codecId: 'sqlite/text@1' };
+              };
+              readonly userId: {
+                readonly nullable: false;
+                readonly type: {
+                  readonly kind: 'scalar';
+                  readonly codecId: 'sql/char@1';
+                  readonly typeParams: { readonly length: 36 };
+                };
+              };
+              readonly createdAt: {
+                readonly nullable: false;
+                readonly type: { readonly kind: 'scalar'; readonly codecId: 'sqlite/datetime@1' };
+              };
+            };
+            readonly relations: {
+              readonly user: {
+                readonly to: {
+                  readonly namespace: '__unbound__' & NamespaceId;
+                  readonly model: 'User';
+                };
+                readonly cardinality: 'N:1';
+                readonly on: {
+                  readonly localFields: readonly ['userId'];
+                  readonly targetFields: readonly ['id'];
+                };
+              };
+              readonly tags: {
+                readonly to: {
+                  readonly namespace: '__unbound__' & NamespaceId;
+                  readonly model: 'Tag';
+                };
+                readonly cardinality: 'N:M';
+                readonly on: {
+                  readonly localFields: readonly ['id'];
+                  readonly targetFields: readonly ['postId'];
+                };
+                readonly through: {
+                  readonly table: 'post_tag';
+                  readonly parentColumns: readonly ['postId'];
+                  readonly childColumns: readonly ['tagId'];
+                  readonly targetColumns: readonly ['id'];
+                };
+              };
+            };
+            readonly storage: {
+              readonly table: 'post';
+              readonly fields: {
+                readonly id: { readonly column: 'id' };
+                readonly title: { readonly column: 'title' };
+                readonly userId: { readonly column: 'userId' };
+                readonly createdAt: { readonly column: 'createdAt' };
+              };
+            };
+          };
+          readonly PostTag: {
+            readonly fields: {
+              readonly postId: {
+                readonly nullable: false;
+                readonly type: {
+                  readonly kind: 'scalar';
+                  readonly codecId: 'sql/char@1';
+                  readonly typeParams: { readonly length: 36 };
+                };
+              };
+              readonly tagId: {
+                readonly nullable: false;
+                readonly type: {
+                  readonly kind: 'scalar';
+                  readonly codecId: 'sql/char@1';
+                  readonly typeParams: { readonly length: 36 };
+                };
+              };
+            };
+            readonly relations: Record<string, never>;
+            readonly storage: {
+              readonly table: 'post_tag';
+              readonly fields: {
+                readonly postId: { readonly column: 'postId' };
+                readonly tagId: { readonly column: 'tagId' };
+              };
+            };
+          };
+          readonly Tag: {
+            readonly fields: {
+              readonly id: {
+                readonly nullable: false;
+                readonly type: {
+                  readonly kind: 'scalar';
+                  readonly codecId: 'sql/char@1';
+                  readonly typeParams: { readonly length: 36 };
+                };
+              };
+              readonly label: {
+                readonly nullable: false;
+                readonly type: { readonly kind: 'scalar'; readonly codecId: 'sqlite/text@1' };
+              };
+            };
+            readonly relations: {
+              readonly posts: {
+                readonly to: {
+                  readonly namespace: '__unbound__' & NamespaceId;
+                  readonly model: 'Post';
+                };
+                readonly cardinality: 'N:M';
+                readonly on: {
+                  readonly localFields: readonly ['id'];
+                  readonly targetFields: readonly ['tagId'];
+                };
+                readonly through: {
+                  readonly table: 'post_tag';
+                  readonly parentColumns: readonly ['tagId'];
+                  readonly childColumns: readonly ['postId'];
+                  readonly targetColumns: readonly ['id'];
+                };
+              };
+            };
+            readonly storage: {
+              readonly table: 'tag';
+              readonly fields: {
+                readonly id: { readonly column: 'id' };
+                readonly label: { readonly column: 'label' };
+              };
+            };
+          };
+          readonly User: {
+            readonly fields: {
+              readonly id: {
+                readonly nullable: false;
+                readonly type: {
+                  readonly kind: 'scalar';
+                  readonly codecId: 'sql/char@1';
+                  readonly typeParams: { readonly length: 36 };
+                };
+              };
+              readonly email: {
+                readonly nullable: false;
+                readonly type: { readonly kind: 'scalar'; readonly codecId: 'sqlite/text@1' };
+              };
+              readonly displayName: {
+                readonly nullable: false;
+                readonly type: { readonly kind: 'scalar'; readonly codecId: 'sqlite/text@1' };
+              };
+              readonly createdAt: {
+                readonly nullable: false;
+                readonly type: { readonly kind: 'scalar'; readonly codecId: 'sqlite/datetime@1' };
+              };
+            };
+            readonly relations: {
+              readonly posts: {
+                readonly to: {
+                  readonly namespace: '__unbound__' & NamespaceId;
+                  readonly model: 'Post';
+                };
+                readonly cardinality: '1:N';
+                readonly on: {
+                  readonly localFields: readonly ['id'];
+                  readonly targetFields: readonly ['userId'];
+                };
+              };
+            };
+            readonly storage: {
+              readonly table: 'user';
+              readonly fields: {
+                readonly id: { readonly column: 'id' };
+                readonly email: { readonly column: 'email' };
+                readonly displayName: { readonly column: 'displayName' };
+                readonly createdAt: { readonly column: 'createdAt' };
+              };
+            };
+          };
+        };
+      };
+    };
+  };
+  readonly capabilities: {
+    readonly sql: {
+      readonly enums: false;
+      readonly foreignKeys: true;
+      readonly jsonAgg: true;
+      readonly lateral: false;
+      readonly limit: true;
+      readonly orderBy: true;
+      readonly returning: true;
+    };
+  };
+  readonly extensionPacks: {};
+  readonly execution: {
+    readonly executionHash: ExecutionHash;
+    readonly mutations: {
+      readonly defaults: readonly [
+        {
+          readonly ref: { readonly table: 'post'; readonly column: 'id' };
+          readonly onCreate: { readonly kind: 'generator'; readonly id: 'uuidv4' };
+        },
+        {
+          readonly ref: { readonly table: 'tag'; readonly column: 'id' };
+          readonly onCreate: { readonly kind: 'generator'; readonly id: 'uuidv4' };
+        },
+        {
+          readonly ref: { readonly table: 'user'; readonly column: 'id' };
+          readonly onCreate: { readonly kind: 'generator'; readonly id: 'uuidv4' };
+        },
+      ];
+    };
+  };
+  readonly meta: {};
+
+  readonly profileHash: ProfileHash;
+};
+
+export type Contract = ContractWithTypeMaps<ContractBase, TypeMaps>;
+
+export type Namespaces = Contract['storage']['namespaces'];
+export type Models = ContractModelsMap<Contract>;
diff --git a/examples/prisma-next-demo-sqlite/migrations/app/refs/db.contract.json b/examples/prisma-next-demo-sqlite/migrations/app/refs/db.contract.json
new file mode 100644
index 0000000000..9461d82c1f
--- /dev/null
+++ b/examples/prisma-next-demo-sqlite/migrations/app/refs/db.contract.json
@@ -0,0 +1,341 @@
+{
+  "_generated": {
+    "message": "This file is automatically generated by \"prisma-next contract emit\".",
+    "regenerate": "To regenerate, run: prisma-next contract emit",
+    "warning": "⚠️  GENERATED FILE - DO NOT EDIT"
+  },
+  "capabilities": {
+    "sql": {
+      "foreignKeys": true,
+      "jsonAgg": true,
+      "limit": true,
+      "orderBy": true,
+      "returning": true
+    }
+  },
+  "domain": {
+    "namespaces": {
+      "__unbound__": {
+        "models": {
+          "Post": {
+            "fields": {
+              "createdAt": {
+                "nullable": false,
+                "type": { "codecId": "sqlite/datetime@1", "kind": "scalar" }
+              },
+              "id": {
+                "nullable": false,
+                "type": {
+                  "codecId": "sql/char@1",
+                  "kind": "scalar",
+                  "typeParams": { "length": 36 }
+                }
+              },
+              "title": {
+                "nullable": false,
+                "type": { "codecId": "sqlite/text@1", "kind": "scalar" }
+              },
+              "userId": {
+                "nullable": false,
+                "type": {
+                  "codecId": "sql/char@1",
+                  "kind": "scalar",
+                  "typeParams": { "length": 36 }
+                }
+              }
+            },
+            "relations": {
+              "tags": {
+                "cardinality": "N:M",
+                "on": { "localFields": ["id"], "targetFields": ["postId"] },
+                "through": {
+                  "childColumns": ["tagId"],
+                  "parentColumns": ["postId"],
+                  "table": "post_tag",
+                  "targetColumns": ["id"]
+                },
+                "to": { "model": "Tag", "namespace": "__unbound__" }
+              },
+              "user": {
+                "cardinality": "N:1",
+                "on": { "localFields": ["userId"], "targetFields": ["id"] },
+                "to": { "model": "User", "namespace": "__unbound__" }
+              }
+            },
+            "storage": {
+              "fields": {
+                "createdAt": { "column": "createdAt" },
+                "id": { "column": "id" },
+                "title": { "column": "title" },
+                "userId": { "column": "userId" }
+              },
+              "table": "post"
+            }
+          },
+          "PostTag": {
+            "fields": {
+              "postId": {
+                "nullable": false,
+                "type": {
+                  "codecId": "sql/char@1",
+                  "kind": "scalar",
+                  "typeParams": { "length": 36 }
+                }
+              },
+              "tagId": {
+                "nullable": false,
+                "type": {
+                  "codecId": "sql/char@1",
+                  "kind": "scalar",
+                  "typeParams": { "length": 36 }
+                }
+              }
+            },
+            "relations": {},
+            "storage": {
+              "fields": { "postId": { "column": "postId" }, "tagId": { "column": "tagId" } },
+              "table": "post_tag"
+            }
+          },
+          "Tag": {
+            "fields": {
+              "id": {
+                "nullable": false,
+                "type": {
+                  "codecId": "sql/char@1",
+                  "kind": "scalar",
+                  "typeParams": { "length": 36 }
+                }
+              },
+              "label": {
+                "nullable": false,
+                "type": { "codecId": "sqlite/text@1", "kind": "scalar" }
+              }
+            },
+            "relations": {
+              "posts": {
+                "cardinality": "N:M",
+                "on": { "localFields": ["id"], "targetFields": ["tagId"] },
+                "through": {
+                  "childColumns": ["postId"],
+                  "parentColumns": ["tagId"],
+                  "table": "post_tag",
+                  "targetColumns": ["id"]
+                },
+                "to": { "model": "Post", "namespace": "__unbound__" }
+              }
+            },
+            "storage": {
+              "fields": { "id": { "column": "id" }, "label": { "column": "label" } },
+              "table": "tag"
+            }
+          },
+          "User": {
+            "fields": {
+              "createdAt": {
+                "nullable": false,
+                "type": { "codecId": "sqlite/datetime@1", "kind": "scalar" }
+              },
+              "displayName": {
+                "nullable": false,
+                "type": { "codecId": "sqlite/text@1", "kind": "scalar" }
+              },
+              "email": {
+                "nullable": false,
+                "type": { "codecId": "sqlite/text@1", "kind": "scalar" }
+              },
+              "id": {
+                "nullable": false,
+                "type": {
+                  "codecId": "sql/char@1",
+                  "kind": "scalar",
+                  "typeParams": { "length": 36 }
+                }
+              }
+            },
+            "relations": {
+              "posts": {
+                "cardinality": "1:N",
+                "on": { "localFields": ["id"], "targetFields": ["userId"] },
+                "to": { "model": "Post", "namespace": "__unbound__" }
+              }
+            },
+            "storage": {
+              "fields": {
+                "createdAt": { "column": "createdAt" },
+                "displayName": { "column": "displayName" },
+                "email": { "column": "email" },
+                "id": { "column": "id" }
+              },
+              "table": "user"
+            }
+          }
+        }
+      }
+    }
+  },
+  "execution": {
+    "executionHash": "sha256:70c6ceb0ed79d5888519ec84bf32e31a056283fa8d5c7b5c1ba65b709f8595c8",
+    "mutations": {
+      "defaults": [
+        {
+          "onCreate": { "id": "uuidv4", "kind": "generator" },
+          "ref": { "column": "id", "table": "post" }
+        },
+        {
+          "onCreate": { "id": "uuidv4", "kind": "generator" },
+          "ref": { "column": "id", "table": "tag" }
+        },
+        {
+          "onCreate": { "id": "uuidv4", "kind": "generator" },
+          "ref": { "column": "id", "table": "user" }
+        }
+      ]
+    }
+  },
+  "extensionPacks": {},
+  "meta": {},
+  "profileHash": "sha256:3cc333ecad9f3f4c7229370a9d2c37e908cdce0f8d2e9fb132d50605b024eff2",
+  "roots": {
+    "post": { "model": "Post", "namespace": "__unbound__" },
+    "post_tag": { "model": "PostTag", "namespace": "__unbound__" },
+    "tag": { "model": "Tag", "namespace": "__unbound__" },
+    "user": { "model": "User", "namespace": "__unbound__" }
+  },
+  "schemaVersion": "1",
+  "storage": {
+    "namespaces": {
+      "__unbound__": {
+        "id": "__unbound__",
+        "tables": {
+          "post": {
+            "columns": {
+              "createdAt": {
+                "codecId": "sqlite/datetime@1",
+                "default": { "expression": "now()", "kind": "function" },
+                "nativeType": "text",
+                "nullable": false
+              },
+              "id": {
+                "codecId": "sql/char@1",
+                "nativeType": "character",
+                "nullable": false,
+                "typeParams": { "length": 36 }
+              },
+              "title": { "codecId": "sqlite/text@1", "nativeType": "text", "nullable": false },
+              "userId": {
+                "codecId": "sql/char@1",
+                "nativeType": "character",
+                "nullable": false,
+                "typeParams": { "length": 36 }
+              }
+            },
+            "foreignKeys": [
+              {
+                "constraint": true,
+                "index": true,
+                "name": "post_userId_fkey",
+                "source": {
+                  "columns": ["userId"],
+                  "namespaceId": "__unbound__",
+                  "tableName": "post"
+                },
+                "target": { "columns": ["id"], "namespaceId": "__unbound__", "tableName": "user" }
+              }
+            ],
+            "indexes": [],
+            "primaryKey": { "columns": ["id"] },
+            "uniques": []
+          },
+          "post_tag": {
+            "columns": {
+              "postId": {
+                "codecId": "sql/char@1",
+                "nativeType": "character",
+                "nullable": false,
+                "typeParams": { "length": 36 }
+              },
+              "tagId": {
+                "codecId": "sql/char@1",
+                "nativeType": "character",
+                "nullable": false,
+                "typeParams": { "length": 36 }
+              }
+            },
+            "foreignKeys": [
+              {
+                "constraint": true,
+                "index": true,
+                "name": "post_tag_postId_fkey",
+                "source": {
+                  "columns": ["postId"],
+                  "namespaceId": "__unbound__",
+                  "tableName": "post_tag"
+                },
+                "target": { "columns": ["id"], "namespaceId": "__unbound__", "tableName": "post" }
+              },
+              {
+                "constraint": true,
+                "index": true,
+                "name": "post_tag_tagId_fkey",
+                "source": {
+                  "columns": ["tagId"],
+                  "namespaceId": "__unbound__",
+                  "tableName": "post_tag"
+                },
+                "target": { "columns": ["id"], "namespaceId": "__unbound__", "tableName": "tag" }
+              }
+            ],
+            "indexes": [],
+            "primaryKey": { "columns": ["postId", "tagId"], "name": "post_tag_pkey" },
+            "uniques": []
+          },
+          "tag": {
+            "columns": {
+              "id": {
+                "codecId": "sql/char@1",
+                "nativeType": "character",
+                "nullable": false,
+                "typeParams": { "length": 36 }
+              },
+              "label": { "codecId": "sqlite/text@1", "nativeType": "text", "nullable": false }
+            },
+            "foreignKeys": [],
+            "indexes": [],
+            "primaryKey": { "columns": ["id"] },
+            "uniques": []
+          },
+          "user": {
+            "columns": {
+              "createdAt": {
+                "codecId": "sqlite/datetime@1",
+                "default": { "expression": "now()", "kind": "function" },
+                "nativeType": "text",
+                "nullable": false
+              },
+              "displayName": {
+                "codecId": "sqlite/text@1",
+                "nativeType": "text",
+                "nullable": false
+              },
+              "email": { "codecId": "sqlite/text@1", "nativeType": "text", "nullable": false },
+              "id": {
+                "codecId": "sql/char@1",
+                "nativeType": "character",
+                "nullable": false,
+                "typeParams": { "length": 36 }
+              }
+            },
+            "foreignKeys": [],
+            "indexes": [],
+            "primaryKey": { "columns": ["id"] },
+            "uniques": []
+          }
+        }
+      }
+    },
+    "storageHash": "sha256:194cf0bce4a19c7191f9e4ae8670de21707c48678d7b8998d38708a506488c88"
+  },
+  "target": "sqlite",
+  "targetFamily": "sql"
+}
diff --git a/examples/prisma-next-demo-sqlite/migrations/app/refs/db.json b/examples/prisma-next-demo-sqlite/migrations/app/refs/db.json
new file mode 100644
index 0000000000..90d46ecf92
--- /dev/null
+++ b/examples/prisma-next-demo-sqlite/migrations/app/refs/db.json
@@ -0,0 +1,4 @@
+{
+  "hash": "sha256:194cf0bce4a19c7191f9e4ae8670de21707c48678d7b8998d38708a506488c88",
+  "invariants": []
+}
diff --git a/examples/prisma-next-demo-sqlite/prisma/contract.ts b/examples/prisma-next-demo-sqlite/prisma/contract.ts
index cb0ae3d28a..aeebb5bb45 100644
--- a/examples/prisma-next-demo-sqlite/prisma/contract.ts
+++ b/examples/prisma-next-demo-sqlite/prisma/contract.ts
@@ -20,6 +20,22 @@ export const contract = defineContract({}, ({ field, model }) => {
     },
   });
 
+  const Tag = model('Tag', {
+    fields: {
+      id: field.id.uuidv4(),
+      label: field.column(textColumn),
+    },
+  });
+
+  const PostTag = model('PostTag', {
+    fields: {
+      postId: field.uuid(),
+      tagId: field.uuid(),
+    },
+  }).attributes(({ fields, constraints }) => ({
+    id: constraints.id([fields.postId, fields.tagId], { name: 'post_tag_pkey' }),
+  }));
+
   return {
     models: {
       User: User.relations({
@@ -29,6 +45,11 @@ export const contract = defineContract({}, ({ field, model }) => {
       }),
       Post: Post.relations({
         user: rel.belongsTo(User, { from: 'userId', to: 'id' }),
+        tags: rel.manyToMany(() => Tag, {
+          through: () => PostTag,
+          from: 'postId',
+          to: 'tagId',
+        }),
       }).sql(({ cols, constraints }) => ({
         table: 'post',
         foreignKeys: [
@@ -37,6 +58,22 @@ export const contract = defineContract({}, ({ field, model }) => {
           }),
         ],
       })),
+      Tag: Tag.relations({
+        posts: rel.manyToMany(() => Post, {
+          through: () => PostTag,
+          from: 'tagId',
+          to: 'postId',
+        }),
+      }).sql({
+        table: 'tag',
+      }),
+      PostTag: PostTag.sql(({ cols, constraints }) => ({
+        table: 'post_tag',
+        foreignKeys: [
+          constraints.foreignKey(cols.postId, Post.refs.id, { name: 'post_tag_postId_fkey' }),
+          constraints.foreignKey(cols.tagId, Tag.refs.id, { name: 'post_tag_tagId_fkey' }),
+        ],
+      })),
     },
   };
 });
diff --git a/examples/prisma-next-demo-sqlite/scripts/seed.ts b/examples/prisma-next-demo-sqlite/scripts/seed.ts
index 0995fee7f8..ebee198423 100644
--- a/examples/prisma-next-demo-sqlite/scripts/seed.ts
+++ b/examples/prisma-next-demo-sqlite/scripts/seed.ts
@@ -5,7 +5,8 @@
  *
  * Run with: pnpm seed
  *
- * Creates 2 users (alice, bob) and 3 posts.
+ * Creates 2 users (alice, bob), 3 posts, 3 tags, and junction rows demonstrating
+ * the Post ↔ Tag many-to-many relation.
  *
  * Prerequisites:
  * - SQLITE_PATH env var (defaults to ./demo.db)
@@ -70,20 +71,73 @@ async function main() {
     console.log(`Created user: ${alice.email} (id: ${alice.id})`);
     console.log(`Created user: ${bob.email} (id: ${bob.id})`);
 
-    await runtime.execute(
+    const firstPostRows = await runtime.execute(
       db.sql.post
         .insert([{ title: 'First Post', userId: alice.id, createdAt: new Date() }])
+        .returning('id', 'title')
         .build(),
     );
-    await runtime.execute(
+    const secondPostRows = await runtime.execute(
       db.sql.post
         .insert([{ title: 'Second Post', userId: alice.id, createdAt: new Date() }])
+        .returning('id', 'title')
         .build(),
     );
     await runtime.execute(
       db.sql.post.insert([{ title: 'Third Post', userId: bob.id, createdAt: new Date() }]).build(),
     );
 
+    const firstPost = firstPostRows[0] ?? null;
+    const secondPost = secondPostRows[0] ?? null;
+    if (!firstPost || !secondPost) {
+      throw new Error('Failed to create posts');
+    }
+
+    console.log(`Created post: ${firstPost.title} (id: ${firstPost.id})`);
+    console.log(`Created post: ${secondPost.title} (id: ${secondPost.id})`);
+
+    const tagTypeScriptRows = await runtime.execute(
+      db.sql.tag
+        .insert([{ label: 'typescript' }])
+        .returning('id', 'label')
+        .build(),
+    );
+    const tagOrmRows = await runtime.execute(
+      db.sql.tag
+        .insert([{ label: 'orm' }])
+        .returning('id', 'label')
+        .build(),
+    );
+    const tagDemoRows = await runtime.execute(
+      db.sql.tag
+        .insert([{ label: 'demo' }])
+        .returning('id', 'label')
+        .build(),
+    );
+
+    const tagTypeScript = tagTypeScriptRows[0] ?? null;
+    const tagOrm = tagOrmRows[0] ?? null;
+    const tagDemo = tagDemoRows[0] ?? null;
+    if (!tagTypeScript || !tagOrm || !tagDemo) {
+      throw new Error('Failed to create tags');
+    }
+
+    console.log(`Created tag: ${tagTypeScript.label} (id: ${tagTypeScript.id})`);
+    console.log(`Created tag: ${tagOrm.label} (id: ${tagOrm.id})`);
+    console.log(`Created tag: ${tagDemo.label} (id: ${tagDemo.id})`);
+
+    await runtime.execute(
+      db.sql.post_tag
+        .insert([
+          { postId: firstPost.id, tagId: tagTypeScript.id },
+          { postId: firstPost.id, tagId: tagOrm.id },
+          { postId: secondPost.id, tagId: tagOrm.id },
+          { postId: secondPost.id, tagId: tagDemo.id },
+        ])
+        .build(),
+    );
+
+    console.log('Seeded post_tag junction rows.');
     console.log('Seed completed successfully!');
   } finally {
     await runtime.close();
diff --git a/examples/prisma-next-demo-sqlite/src/main.ts b/examples/prisma-next-demo-sqlite/src/main.ts
index b42941ead0..9aa6819b6c 100644
--- a/examples/prisma-next-demo-sqlite/src/main.ts
+++ b/examples/prisma-next-demo-sqlite/src/main.ts
@@ -14,13 +14,28 @@
  *                                          each email — single lower(), single beforeCompile(),
  *                                          repeated execute()
  *
+ * Many-to-many commands (Post ↔ Tag via PostTag junction):
+ * - post-tags <postId>                     Include a post's tags (N:M read)
+ * - posts-with-tag-some <label>            Posts that have at least one tag matching label
+ * - posts-with-tag-none <label>            Posts that have no tag matching label
+ * - posts-with-tag-every <label>           Posts where every tag differs from label
+ * - connect-post-tags <postId> <tagId...>  Link existing tags to a post
+ * - disconnect-post-tags <postId> <tagId...>  Unlink tags from a post
+ * - create-post-with-tags <id> <userId> <title> <label...>
+ *                                          Create post + new tags in one nested mutation
+ *
  * Each command opens a connection, runs the operation, prints the result as
  * JSON, and closes. Exits non-zero on usage errors or runtime failures.
  */
 import 'dotenv/config';
 import { loadAppConfig } from './app-config';
+import { ormClientConnectPostTags } from './orm-client/connect-post-tags';
+import { ormClientCreatePostWithTags } from './orm-client/create-post-with-tags';
 import { ormClientCreateUser } from './orm-client/create-user';
+import { ormClientDisconnectPostTags } from './orm-client/disconnect-post-tags';
 import { ormClientFindUserById } from './orm-client/find-user-by-id';
+import { ormClientGetPostTags } from './orm-client/get-post-tags';
+import { ormClientGetPostsByTagFilter } from './orm-client/get-posts-by-tag-filter';
 import { ormClientGetUserPosts } from './orm-client/get-user-posts';
 import { db } from './prisma/db';
 import { insertUser } from './queries/dml-operations';
@@ -87,11 +102,72 @@ async function main() {
       }
       const results = await getUserByEmailPrepared(args);
       console.log(JSON.stringify(results, null, 2));
+    } else if (cmd === 'post-tags') {
+      const [postId] = args;
+      if (!postId) {
+        console.error('Usage: pnpm start -- post-tags <postId>');
+        process.exitCode = 1;
+        return;
+      }
+      const result = await ormClientGetPostTags(postId, runtime);
+      console.log(JSON.stringify(result, null, 2));
+    } else if (
+      cmd === 'posts-with-tag-some' ||
+      cmd === 'posts-with-tag-none' ||
+      cmd === 'posts-with-tag-every'
+    ) {
+      const [label] = args;
+      if (!label) {
+        console.error(`Usage: pnpm start -- ${cmd} <label>`);
+        process.exitCode = 1;
+        return;
+      }
+      const mode =
+        cmd === 'posts-with-tag-some' ? 'some' : cmd === 'posts-with-tag-none' ? 'none' : 'every';
+      const results = await ormClientGetPostsByTagFilter(mode, label, runtime);
+      console.log(JSON.stringify(results, null, 2));
+    } else if (cmd === 'connect-post-tags') {
+      const [postId, ...tagIds] = args;
+      if (!postId || tagIds.length === 0) {
+        console.error('Usage: pnpm start -- connect-post-tags <postId> <tagId...>');
+        process.exitCode = 1;
+        return;
+      }
+      const result = await ormClientConnectPostTags(postId, tagIds, runtime);
+      console.log(JSON.stringify(result, null, 2));
+    } else if (cmd === 'disconnect-post-tags') {
+      const [postId, ...tagIds] = args;
+      if (!postId || tagIds.length === 0) {
+        console.error('Usage: pnpm start -- disconnect-post-tags <postId> <tagId...>');
+        process.exitCode = 1;
+        return;
+      }
+      const result = await ormClientDisconnectPostTags(postId, tagIds, runtime);
+      console.log(JSON.stringify(result, null, 2));
+    } else if (cmd === 'create-post-with-tags') {
+      const [id, userId, title, ...labels] = args;
+      if (!id || !userId || !title || labels.length === 0) {
+        console.error(
+          'Usage: pnpm start -- create-post-with-tags <id> <userId> <title> <label...>',
+        );
+        process.exitCode = 1;
+        return;
+      }
+      const result = await ormClientCreatePostWithTags(
+        { id, userId, title, tags: labels.map((label) => ({ label })) },
+        runtime,
+      );
+      console.log(JSON.stringify(result, null, 2));
     } else {
       console.log(
-        'Usage: pnpm start -- [users [limit] | repo-user <id> | repo-user-posts <id> [limit] | ' +
-          'repo-create-user <id> <email> <displayName> | insert-user <email> <displayName> | ' +
-          'user-by-email-prepared <email> [<email> ...]]',
+        'Usage: pnpm start -- [users [limit] | repo-user <id> | repo-user-posts <id> [limit] |\n' +
+          '  repo-create-user <id> <email> <displayName> | insert-user <email> <displayName> |\n' +
+          '  user-by-email-prepared <email> [<email> ...] |\n' +
+          '  post-tags <postId> |\n' +
+          '  posts-with-tag-some <label> | posts-with-tag-none <label> | posts-with-tag-every <label> |\n' +
+          '  connect-post-tags <postId> <tagId...> |\n' +
+          '  disconnect-post-tags <postId> <tagId...> |\n' +
+          '  create-post-with-tags <id> <userId> <title> <label...>]',
       );
       process.exitCode = 1;
       return;
diff --git a/examples/prisma-next-demo-sqlite/src/orm-client/connect-post-tags.ts b/examples/prisma-next-demo-sqlite/src/orm-client/connect-post-tags.ts
new file mode 100644
index 0000000000..a99bf60c64
--- /dev/null
+++ b/examples/prisma-next-demo-sqlite/src/orm-client/connect-post-tags.ts
@@ -0,0 +1,30 @@
+import type { DefaultModelRow } from '@prisma-next/sql-orm-client';
+import type { Runtime } from '@prisma-next/sql-runtime';
+import { castAs } from '@prisma-next/utils/casts';
+import type { Contract } from '../prisma/contract.d';
+import { createOrmClient } from './client';
+
+type PostId = DefaultModelRow<Contract, 'Post'>['id'];
+type TagId = DefaultModelRow<Contract, 'Tag'>['id'];
+
+/**
+ * Many-to-many connect example: link existing tags to a post via the
+ * callback mutator. Inserts junction rows for each tag id supplied; does
+ * not create new tags. Returns the post with its updated tag list included.
+ */
+export async function ormClientConnectPostTags(
+  postId: string,
+  tagIds: readonly string[],
+  runtime: Runtime,
+) {
+  const db = createOrmClient(runtime);
+  const updated = await db.Post.where({ id: castAs<PostId>(postId) }).update({
+    tags: (t) => t.connect(tagIds.map((id) => ({ id: castAs<TagId>(id) }))),
+  });
+  if (!updated) {
+    return null;
+  }
+  return db.Post.include('tags', (tag) => tag.orderBy((t) => t.label.asc()))
+    .where({ id: castAs<PostId>(postId) })
+    .first();
+}
diff --git a/examples/prisma-next-demo-sqlite/src/orm-client/create-post-with-tags.ts b/examples/prisma-next-demo-sqlite/src/orm-client/create-post-with-tags.ts
new file mode 100644
index 0000000000..addcb6649e
--- /dev/null
+++ b/examples/prisma-next-demo-sqlite/src/orm-client/create-post-with-tags.ts
@@ -0,0 +1,40 @@
+import type { DefaultModelRow } from '@prisma-next/sql-orm-client';
+import type { Runtime } from '@prisma-next/sql-runtime';
+import { castAs } from '@prisma-next/utils/casts';
+import type { Contract } from '../prisma/contract.d';
+import { createOrmClient } from './client';
+
+type PostRow = DefaultModelRow<Contract, 'Post'>;
+type TagRow = DefaultModelRow<Contract, 'Tag'>;
+
+export interface CreatePostWithTagsInput {
+  readonly id: string;
+  readonly title: string;
+  readonly userId: string;
+  readonly tags: ReadonlyArray<{ readonly label: string }>;
+}
+
+/**
+ * Many-to-many nested create example: insert a new post and simultaneously
+ * create + link new tags via the callback mutator. Demonstrates
+ * `t.create([...])` on an N:M relation from inside a `create()` call.
+ */
+export async function ormClientCreatePostWithTags(
+  input: CreatePostWithTagsInput,
+  runtime: Runtime,
+) {
+  const db = createOrmClient(runtime);
+  return db.Post.create({
+    id: castAs<PostRow['id']>(input.id),
+    title: input.title,
+    userId: castAs<PostRow['userId']>(input.userId),
+    tags: (t) =>
+      t.create(
+        castAs<Array<{ label: TagRow['label'] }>>(
+          input.tags.map((tag) => ({
+            label: tag.label,
+          })),
+        ),
+      ),
+  });
+}
diff --git a/examples/prisma-next-demo-sqlite/src/orm-client/disconnect-post-tags.ts b/examples/prisma-next-demo-sqlite/src/orm-client/disconnect-post-tags.ts
new file mode 100644
index 0000000000..518139afc1
--- /dev/null
+++ b/examples/prisma-next-demo-sqlite/src/orm-client/disconnect-post-tags.ts
@@ -0,0 +1,29 @@
+import type { DefaultModelRow } from '@prisma-next/sql-orm-client';
+import type { Runtime } from '@prisma-next/sql-runtime';
+import { castAs } from '@prisma-next/utils/casts';
+import type { Contract } from '../prisma/contract.d';
+import { createOrmClient } from './client';
+
+type PostId = DefaultModelRow<Contract, 'Post'>['id'];
+type TagId = DefaultModelRow<Contract, 'Tag'>['id'];
+
+/**
+ * Many-to-many disconnect example: unlink tags from a post by deleting the
+ * corresponding junction rows. Returns the post with its remaining tags.
+ */
+export async function ormClientDisconnectPostTags(
+  postId: string,
+  tagIds: readonly string[],
+  runtime: Runtime,
+) {
+  const db = createOrmClient(runtime);
+  const updated = await db.Post.where({ id: castAs<PostId>(postId) }).update({
+    tags: (t) => t.disconnect(tagIds.map((id) => ({ id: castAs<TagId>(id) }))),
+  });
+  if (!updated) {
+    return null;
+  }
+  return db.Post.include('tags', (tag) => tag.orderBy((t) => t.label.asc()))
+    .where({ id: castAs<PostId>(postId) })
+    .first();
+}
diff --git a/examples/prisma-next-demo-sqlite/src/orm-client/get-post-tags.ts b/examples/prisma-next-demo-sqlite/src/orm-client/get-post-tags.ts
new file mode 100644
index 0000000000..7bffd8b300
--- /dev/null
+++ b/examples/prisma-next-demo-sqlite/src/orm-client/get-post-tags.ts
@@ -0,0 +1,19 @@
+import type { DefaultModelRow } from '@prisma-next/sql-orm-client';
+import type { Runtime } from '@prisma-next/sql-runtime';
+import { castAs } from '@prisma-next/utils/casts';
+import type { Contract } from '../prisma/contract.d';
+import { createOrmClient } from './client';
+
+type PostId = DefaultModelRow<Contract, 'Post'>['id'];
+
+/**
+ * Many-to-many include example: fetch a post along with its tags via the
+ * Post.tags N:M relation. Demonstrates `.include('tags', ...)` traversing
+ * the junction table transparently.
+ */
+export async function ormClientGetPostTags(postId: string, runtime: Runtime) {
+  const db = createOrmClient(runtime);
+  return db.Post.include('tags', (tag) => tag.select('id', 'label').orderBy((t) => t.label.asc()))
+    .where({ id: castAs<PostId>(postId) })
+    .first();
+}
diff --git a/examples/prisma-next-demo-sqlite/src/orm-client/get-posts-by-tag-filter.ts b/examples/prisma-next-demo-sqlite/src/orm-client/get-posts-by-tag-filter.ts
new file mode 100644
index 0000000000..747cee382e
--- /dev/null
+++ b/examples/prisma-next-demo-sqlite/src/orm-client/get-posts-by-tag-filter.ts
@@ -0,0 +1,28 @@
+import type { Runtime } from '@prisma-next/sql-runtime';
+import { createOrmClient } from './client';
+
+/**
+ * Many-to-many filter example: list posts using relation filter predicates
+ * on the N:M `tags` relation. Demonstrates `.some()`, `.none()`, and
+ * `.every()` applied to a M:N relation.
+ *
+ * @param mode  'some' | 'none' | 'every' — which predicate to apply
+ * @param label Tag label to match (for some/none) or not match (for every)
+ */
+export async function ormClientGetPostsByTagFilter(
+  mode: 'some' | 'none' | 'every',
+  label: string,
+  runtime: Runtime,
+) {
+  const db = createOrmClient(runtime);
+
+  if (mode === 'some') {
+    return db.Post.where((p) => p.tags.some((t) => t.label.eq(label))).all();
+  }
+
+  if (mode === 'none') {
+    return db.Post.where((p) => p.tags.none((t) => t.label.eq(label))).all();
+  }
+
+  return db.Post.where((p) => p.tags.every((t) => t.label.neq(label))).all();
+}
diff --git a/examples/prisma-next-demo-sqlite/src/prisma/contract.d.ts b/examples/prisma-next-demo-sqlite/src/prisma/contract.d.ts
index ada56e206c..a76371b2c7 100644
--- a/examples/prisma-next-demo-sqlite/src/prisma/contract.d.ts
+++ b/examples/prisma-next-demo-sqlite/src/prisma/contract.d.ts
@@ -17,9 +17,9 @@ import type {
 } from '@prisma-next/contract/types';
 
 export type StorageHash =
-  StorageHashBase<'sha256:5736eda44575a2e995e8c1d5ed6d7884859a882e9551844f776d2a497c6d0154'>;
+  StorageHashBase<'sha256:664e11eed7f1d28dcf79412d71801ffa7c0a6369c717c38a0aa655b033e2213e'>;
 export type ExecutionHash =
-  ExecutionHashBase<'sha256:aa79980d83d295977c2ca3fd5a1407ea2bc67b4538b19971512d2f47ff71338e'>;
+  ExecutionHashBase<'sha256:70c6ceb0ed79d5888519ec84bf32e31a056283fa8d5c7b5c1ba65b709f8595c8'>;
 export type ProfileHash =
   ProfileHashBase<'sha256:3cc333ecad9f3f4c7229370a9d2c37e908cdce0f8d2e9fb132d50605b024eff2'>;
 
@@ -37,6 +37,14 @@ export type FieldOutputTypes = {
     readonly userId: CodecTypes['sql/char@1']['output'];
     readonly createdAt: CodecTypes['sqlite/datetime@1']['output'];
   };
+  readonly PostTag: {
+    readonly postId: CodecTypes['sql/char@1']['output'];
+    readonly tagId: CodecTypes['sql/char@1']['output'];
+  };
+  readonly Tag: {
+    readonly id: CodecTypes['sql/char@1']['output'];
+    readonly label: CodecTypes['sqlite/text@1']['output'];
+  };
   readonly User: {
     readonly id: CodecTypes['sql/char@1']['output'];
     readonly email: CodecTypes['sqlite/text@1']['output'];
@@ -51,6 +59,14 @@ export type FieldInputTypes = {
     readonly userId: CodecTypes['sql/char@1']['input'];
     readonly createdAt: CodecTypes['sqlite/datetime@1']['input'];
   };
+  readonly PostTag: {
+    readonly postId: CodecTypes['sql/char@1']['input'];
+    readonly tagId: CodecTypes['sql/char@1']['input'];
+  };
+  readonly Tag: {
+    readonly id: CodecTypes['sql/char@1']['input'];
+    readonly label: CodecTypes['sqlite/text@1']['input'];
+  };
   readonly User: {
     readonly id: CodecTypes['sql/char@1']['input'];
     readonly email: CodecTypes['sqlite/text@1']['input'];
@@ -121,6 +137,79 @@ type ContractBase = Omit<
                   },
                 ];
               };
+              readonly post_tag: {
+                columns: {
+                  readonly postId: {
+                    readonly nativeType: 'character';
+                    readonly codecId: 'sql/char@1';
+                    readonly nullable: false;
+                    readonly typeParams: { readonly length: 36 };
+                  };
+                  readonly tagId: {
+                    readonly nativeType: 'character';
+                    readonly codecId: 'sql/char@1';
+                    readonly nullable: false;
+                    readonly typeParams: { readonly length: 36 };
+                  };
+                };
+                primaryKey: {
+                  readonly columns: readonly ['postId', 'tagId'];
+                  readonly name: 'post_tag_pkey';
+                };
+                uniques: readonly [];
+                indexes: readonly [];
+                foreignKeys: readonly [
+                  {
+                    readonly source: {
+                      readonly namespaceId: '__unbound__' & NamespaceId;
+                      readonly tableName: 'post_tag';
+                      readonly columns: readonly ['postId'];
+                    };
+                    readonly target: {
+                      readonly namespaceId: '__unbound__' & NamespaceId;
+                      readonly tableName: 'post';
+                      readonly columns: readonly ['id'];
+                    };
+                    readonly name: 'post_tag_postId_fkey';
+                    readonly constraint: true;
+                    readonly index: true;
+                  },
+                  {
+                    readonly source: {
+                      readonly namespaceId: '__unbound__' & NamespaceId;
+                      readonly tableName: 'post_tag';
+                      readonly columns: readonly ['tagId'];
+                    };
+                    readonly target: {
+                      readonly namespaceId: '__unbound__' & NamespaceId;
+                      readonly tableName: 'tag';
+                      readonly columns: readonly ['id'];
+                    };
+                    readonly name: 'post_tag_tagId_fkey';
+                    readonly constraint: true;
+                    readonly index: true;
+                  },
+                ];
+              };
+              readonly tag: {
+                columns: {
+                  readonly id: {
+                    readonly nativeType: 'character';
+                    readonly codecId: 'sql/char@1';
+                    readonly nullable: false;
+                    readonly typeParams: { readonly length: 36 };
+                  };
+                  readonly label: {
+                    readonly nativeType: 'text';
+                    readonly codecId: 'sqlite/text@1';
+                    readonly nullable: false;
+                  };
+                };
+                primaryKey: { readonly columns: readonly ['id'] };
+                uniques: readonly [];
+                indexes: readonly [];
+                foreignKeys: readonly [];
+              };
               readonly user: {
                 columns: {
                   readonly id: {
@@ -197,6 +286,21 @@ type ContractBase = Omit<
               readonly targetFields: readonly ['id'];
             };
           };
+          readonly tags: {
+            readonly to: { readonly namespace: '__unbound__' & NamespaceId; readonly model: 'Tag' };
+            readonly cardinality: 'N:M';
+            readonly on: {
+              readonly localFields: readonly ['id'];
+              readonly targetFields: readonly ['postId'];
+            };
+            readonly through: {
+              readonly table: 'post_tag';
+              readonly namespaceId: '__unbound__';
+              readonly parentColumns: readonly ['postId'];
+              readonly childColumns: readonly ['tagId'];
+              readonly targetColumns: readonly ['id'];
+            };
+          };
         };
         readonly storage: {
           readonly table: 'post';
@@ -209,6 +313,79 @@ type ContractBase = Omit<
           };
         };
       };
+      readonly PostTag: {
+        readonly fields: {
+          readonly postId: {
+            readonly nullable: false;
+            readonly type: {
+              readonly kind: 'scalar';
+              readonly codecId: 'sql/char@1';
+              readonly typeParams: { readonly length: 36 };
+            };
+          };
+          readonly tagId: {
+            readonly nullable: false;
+            readonly type: {
+              readonly kind: 'scalar';
+              readonly codecId: 'sql/char@1';
+              readonly typeParams: { readonly length: 36 };
+            };
+          };
+        };
+        readonly relations: Record<string, never>;
+        readonly storage: {
+          readonly table: 'post_tag';
+          readonly namespaceId: '__unbound__';
+          readonly fields: {
+            readonly postId: { readonly column: 'postId' };
+            readonly tagId: { readonly column: 'tagId' };
+          };
+        };
+      };
+      readonly Tag: {
+        readonly fields: {
+          readonly id: {
+            readonly nullable: false;
+            readonly type: {
+              readonly kind: 'scalar';
+              readonly codecId: 'sql/char@1';
+              readonly typeParams: { readonly length: 36 };
+            };
+          };
+          readonly label: {
+            readonly nullable: false;
+            readonly type: { readonly kind: 'scalar'; readonly codecId: 'sqlite/text@1' };
+          };
+        };
+        readonly relations: {
+          readonly posts: {
+            readonly to: {
+              readonly namespace: '__unbound__' & NamespaceId;
+              readonly model: 'Post';
+            };
+            readonly cardinality: 'N:M';
+            readonly on: {
+              readonly localFields: readonly ['id'];
+              readonly targetFields: readonly ['tagId'];
+            };
+            readonly through: {
+              readonly table: 'post_tag';
+              readonly namespaceId: '__unbound__';
+              readonly parentColumns: readonly ['tagId'];
+              readonly childColumns: readonly ['postId'];
+              readonly targetColumns: readonly ['id'];
+            };
+          };
+        };
+        readonly storage: {
+          readonly table: 'tag';
+          readonly namespaceId: '__unbound__';
+          readonly fields: {
+            readonly id: { readonly column: 'id' };
+            readonly label: { readonly column: 'label' };
+          };
+        };
+      };
       readonly User: {
         readonly fields: {
           readonly id: {
@@ -265,6 +442,11 @@ type ContractBase = Omit<
   readonly roots: {
     readonly user: { readonly namespace: '__unbound__' & NamespaceId; readonly model: 'User' };
     readonly post: { readonly namespace: '__unbound__' & NamespaceId; readonly model: 'Post' };
+    readonly tag: { readonly namespace: '__unbound__' & NamespaceId; readonly model: 'Tag' };
+    readonly post_tag: {
+      readonly namespace: '__unbound__' & NamespaceId;
+      readonly model: 'PostTag';
+    };
   };
   readonly domain: {
     readonly namespaces: {
@@ -309,6 +491,24 @@ type ContractBase = Omit<
                   readonly targetFields: readonly ['id'];
                 };
               };
+              readonly tags: {
+                readonly to: {
+                  readonly namespace: '__unbound__' & NamespaceId;
+                  readonly model: 'Tag';
+                };
+                readonly cardinality: 'N:M';
+                readonly on: {
+                  readonly localFields: readonly ['id'];
+                  readonly targetFields: readonly ['postId'];
+                };
+                readonly through: {
+                  readonly table: 'post_tag';
+                  readonly namespaceId: '__unbound__';
+                  readonly parentColumns: readonly ['postId'];
+                  readonly childColumns: readonly ['tagId'];
+                  readonly targetColumns: readonly ['id'];
+                };
+              };
             };
             readonly storage: {
               readonly table: 'post';
@@ -321,6 +521,79 @@ type ContractBase = Omit<
               };
             };
           };
+          readonly PostTag: {
+            readonly fields: {
+              readonly postId: {
+                readonly nullable: false;
+                readonly type: {
+                  readonly kind: 'scalar';
+                  readonly codecId: 'sql/char@1';
+                  readonly typeParams: { readonly length: 36 };
+                };
+              };
+              readonly tagId: {
+                readonly nullable: false;
+                readonly type: {
+                  readonly kind: 'scalar';
+                  readonly codecId: 'sql/char@1';
+                  readonly typeParams: { readonly length: 36 };
+                };
+              };
+            };
+            readonly relations: Record<string, never>;
+            readonly storage: {
+              readonly table: 'post_tag';
+              readonly namespaceId: '__unbound__';
+              readonly fields: {
+                readonly postId: { readonly column: 'postId' };
+                readonly tagId: { readonly column: 'tagId' };
+              };
+            };
+          };
+          readonly Tag: {
+            readonly fields: {
+              readonly id: {
+                readonly nullable: false;
+                readonly type: {
+                  readonly kind: 'scalar';
+                  readonly codecId: 'sql/char@1';
+                  readonly typeParams: { readonly length: 36 };
+                };
+              };
+              readonly label: {
+                readonly nullable: false;
+                readonly type: { readonly kind: 'scalar'; readonly codecId: 'sqlite/text@1' };
+              };
+            };
+            readonly relations: {
+              readonly posts: {
+                readonly to: {
+                  readonly namespace: '__unbound__' & NamespaceId;
+                  readonly model: 'Post';
+                };
+                readonly cardinality: 'N:M';
+                readonly on: {
+                  readonly localFields: readonly ['id'];
+                  readonly targetFields: readonly ['tagId'];
+                };
+                readonly through: {
+                  readonly table: 'post_tag';
+                  readonly namespaceId: '__unbound__';
+                  readonly parentColumns: readonly ['tagId'];
+                  readonly childColumns: readonly ['postId'];
+                  readonly targetColumns: readonly ['id'];
+                };
+              };
+            };
+            readonly storage: {
+              readonly table: 'tag';
+              readonly namespaceId: '__unbound__';
+              readonly fields: {
+                readonly id: { readonly column: 'id' };
+                readonly label: { readonly column: 'label' };
+              };
+            };
+          };
           readonly User: {
             readonly fields: {
               readonly id: {
@@ -392,6 +665,10 @@ type ContractBase = Omit<
           readonly ref: { readonly table: 'post'; readonly column: 'id' };
           readonly onCreate: { readonly kind: 'generator'; readonly id: 'uuidv4' };
         },
+        {
+          readonly ref: { readonly table: 'tag'; readonly column: 'id' };
+          readonly onCreate: { readonly kind: 'generator'; readonly id: 'uuidv4' };
+        },
         {
           readonly ref: { readonly table: 'user'; readonly column: 'id' };
           readonly onCreate: { readonly kind: 'generator'; readonly id: 'uuidv4' };
diff --git a/examples/prisma-next-demo-sqlite/src/prisma/contract.json b/examples/prisma-next-demo-sqlite/src/prisma/contract.json
index 4b259517e9..7325545a03 100644
--- a/examples/prisma-next-demo-sqlite/src/prisma/contract.json
+++ b/examples/prisma-next-demo-sqlite/src/prisma/contract.json
@@ -8,6 +8,14 @@
       "model": "Post",
       "namespace": "__unbound__"
     },
+    "post_tag": {
+      "model": "PostTag",
+      "namespace": "__unbound__"
+    },
+    "tag": {
+      "model": "Tag",
+      "namespace": "__unbound__"
+    },
     "user": {
       "model": "User",
       "namespace": "__unbound__"
@@ -55,6 +63,34 @@
               }
             },
             "relations": {
+              "tags": {
+                "cardinality": "N:M",
+                "on": {
+                  "localFields": [
+                    "id"
+                  ],
+                  "targetFields": [
+                    "postId"
+                  ]
+                },
+                "through": {
+                  "childColumns": [
+                    "tagId"
+                  ],
+                  "namespaceId": "__unbound__",
+                  "parentColumns": [
+                    "postId"
+                  ],
+                  "table": "post_tag",
+                  "targetColumns": [
+                    "id"
+                  ]
+                },
+                "to": {
+                  "model": "Tag",
+                  "namespace": "__unbound__"
+                }
+              },
               "user": {
                 "cardinality": "N:1",
                 "on": {
@@ -90,6 +126,106 @@
               "table": "post"
             }
           },
+          "PostTag": {
+            "fields": {
+              "postId": {
+                "nullable": false,
+                "type": {
+                  "codecId": "sql/char@1",
+                  "kind": "scalar",
+                  "typeParams": {
+                    "length": 36
+                  }
+                }
+              },
+              "tagId": {
+                "nullable": false,
+                "type": {
+                  "codecId": "sql/char@1",
+                  "kind": "scalar",
+                  "typeParams": {
+                    "length": 36
+                  }
+                }
+              }
+            },
+            "relations": {},
+            "storage": {
+              "fields": {
+                "postId": {
+                  "column": "postId"
+                },
+                "tagId": {
+                  "column": "tagId"
+                }
+              },
+              "namespaceId": "__unbound__",
+              "table": "post_tag"
+            }
+          },
+          "Tag": {
+            "fields": {
+              "id": {
+                "nullable": false,
+                "type": {
+                  "codecId": "sql/char@1",
+                  "kind": "scalar",
+                  "typeParams": {
+                    "length": 36
+                  }
+                }
+              },
+              "label": {
+                "nullable": false,
+                "type": {
+                  "codecId": "sqlite/text@1",
+                  "kind": "scalar"
+                }
+              }
+            },
+            "relations": {
+              "posts": {
+                "cardinality": "N:M",
+                "on": {
+                  "localFields": [
+                    "id"
+                  ],
+                  "targetFields": [
+                    "tagId"
+                  ]
+                },
+                "through": {
+                  "childColumns": [
+                    "postId"
+                  ],
+                  "namespaceId": "__unbound__",
+                  "parentColumns": [
+                    "tagId"
+                  ],
+                  "table": "post_tag",
+                  "targetColumns": [
+                    "id"
+                  ]
+                },
+                "to": {
+                  "model": "Post",
+                  "namespace": "__unbound__"
+                }
+              }
+            },
+            "storage": {
+              "fields": {
+                "id": {
+                  "column": "id"
+                },
+                "label": {
+                  "column": "label"
+                }
+              },
+              "namespaceId": "__unbound__",
+              "table": "tag"
+            }
+          },
           "User": {
             "fields": {
               "createdAt": {
@@ -231,6 +367,100 @@
               },
               "uniques": []
             },
+            "post_tag": {
+              "columns": {
+                "postId": {
+                  "codecId": "sql/char@1",
+                  "nativeType": "character",
+                  "nullable": false,
+                  "typeParams": {
+                    "length": 36
+                  }
+                },
+                "tagId": {
+                  "codecId": "sql/char@1",
+                  "nativeType": "character",
+                  "nullable": false,
+                  "typeParams": {
+                    "length": 36
+                  }
+                }
+              },
+              "foreignKeys": [
+                {
+                  "constraint": true,
+                  "index": true,
+                  "name": "post_tag_postId_fkey",
+                  "source": {
+                    "columns": [
+                      "postId"
+                    ],
+                    "namespaceId": "__unbound__",
+                    "tableName": "post_tag"
+                  },
+                  "target": {
+                    "columns": [
+                      "id"
+                    ],
+                    "namespaceId": "__unbound__",
+                    "tableName": "post"
+                  }
+                },
+                {
+                  "constraint": true,
+                  "index": true,
+                  "name": "post_tag_tagId_fkey",
+                  "source": {
+                    "columns": [
+                      "tagId"
+                    ],
+                    "namespaceId": "__unbound__",
+                    "tableName": "post_tag"
+                  },
+                  "target": {
+                    "columns": [
+                      "id"
+                    ],
+                    "namespaceId": "__unbound__",
+                    "tableName": "tag"
+                  }
+                }
+              ],
+              "indexes": [],
+              "primaryKey": {
+                "columns": [
+                  "postId",
+                  "tagId"
+                ],
+                "name": "post_tag_pkey"
+              },
+              "uniques": []
+            },
+            "tag": {
+              "columns": {
+                "id": {
+                  "codecId": "sql/char@1",
+                  "nativeType": "character",
+                  "nullable": false,
+                  "typeParams": {
+                    "length": 36
+                  }
+                },
+                "label": {
+                  "codecId": "sqlite/text@1",
+                  "nativeType": "text",
+                  "nullable": false
+                }
+              },
+              "foreignKeys": [],
+              "indexes": [],
+              "primaryKey": {
+                "columns": [
+                  "id"
+                ]
+              },
+              "uniques": []
+            },
             "user": {
               "columns": {
                 "createdAt": {
@@ -275,10 +505,10 @@
         "id": "__unbound__"
       }
     },
-    "storageHash": "sha256:5736eda44575a2e995e8c1d5ed6d7884859a882e9551844f776d2a497c6d0154"
+    "storageHash": "sha256:664e11eed7f1d28dcf79412d71801ffa7c0a6369c717c38a0aa655b033e2213e"
   },
   "execution": {
-    "executionHash": "sha256:aa79980d83d295977c2ca3fd5a1407ea2bc67b4538b19971512d2f47ff71338e",
+    "executionHash": "sha256:70c6ceb0ed79d5888519ec84bf32e31a056283fa8d5c7b5c1ba65b709f8595c8",
     "mutations": {
       "defaults": [
         {
@@ -291,6 +521,16 @@
             "table": "post"
           }
         },
+        {
+          "onCreate": {
+            "id": "uuidv4",
+            "kind": "generator"
+          },
+          "ref": {
+            "column": "id",
+            "table": "tag"
+          }
+        },
         {
           "onCreate": {
             "id": "uuidv4",
diff --git a/projects/sql-orm-many-to-many/plan.md b/projects/sql-orm-many-to-many/plan.md
index 6071bbd9d1..266c4640fe 100644
--- a/projects/sql-orm-many-to-many/plan.md
+++ b/projects/sql-orm-many-to-many/plan.md
@@ -5,7 +5,9 @@
 
 ## At a glance
 
-Four slices: one **foundation slice** (slice 0) that makes M:N a validatable contract shape and surfaces the shared `through` descriptor, then a **three-way parallel fan-out** — read, filter, write — each consuming slice 0's hand-off and independent of the others.
+**Runtime core (slices 0–3, complete):** one **foundation slice** (slice 0) makes M:N a validatable contract shape and surfaces the shared `through` descriptor, then a **three-way parallel fan-out** — read, filter, write — each consuming slice 0's hand-off.
+
+**Follow-on (slices 4–6, added 2026-06-02):** demo examples + authoring-surface completeness — SQLite demo examples (done), PSL M:N authoring (a framework gap surfaced while adding the demos), and PG demo examples (blocked by the PSL work). See [§ Follow-on slices](#follow-on-slices--authoring-completeness--demos).
 
 ## Composition
 
@@ -45,3 +47,28 @@ Four slices: one **foundation slice** (slice 0) that makes M:N a validatable con
 ## Sequencing rationale
 
 Slice 0 is a hard gate, not a stylistic choice: until the contract validates an M:N relation and the resolver surfaces `through`, slices 1–3 have no validatable integration fixture to test against and nothing to read `through` from. Once slice 0 lands, the three consumers touch disjoint files (`query-plan-select.ts` / `model-accessor.ts` / `mutation-executor.ts`) and share only the read-only `ResolvedRelation.through` field — no write-write contention — so they parallelise cleanly. They are sequenced after 0 purely by data dependency, not by reviewer pacing.
+
+## Follow-on slices — authoring completeness + demos
+
+Added 2026-06-02 after the runtime core (0–3) shipped: while adding M:N **demo examples** we found the navigable M:N API is authorable **only via the TS contract builder** (`rel.manyToMany`), not PSL — so the PG demo (PSL-emitted) can't yet show it. These slices close that gap. Each is its own slice spec under `slices/`.
+
+- **Slice `04-sqlite-demo-examples`** — Linear: [TML-2790](https://linear.app/prisma-company/issue/TML-2790) — **DONE.**
+  - **Outcome:** the SQLite demo (`examples/prisma-next-demo-sqlite`, TS-authored) demonstrates the full M:N API: `Post ↔ Tag` via `PostTag`, with include / `some`/`none`/`every` filter / nested `connect`/`disconnect`/`create` ORM modules + CLI commands + seed, smoke-tested end-to-end.
+  - **Builds on:** slices 0–3 (the runtime M:N feature).
+  - **Hands to:** a worked reference for the M:N ORM API (the PG demo, slice 6, mirrors it once unblocked).
+
+- **Slice `05-psl-many-to-many-authoring`** — Linear: [TML-2794](https://linear.app/prisma-company/issue/TML-2794) — **planned.**
+  - **Outcome:** PSL can author a navigable M:N relation — the interpreter lowers a junction (explicit `@@id([a,b])` join model and/or implicit `Tag[]` list) to `cardinality:'N:M'` + a `through` descriptor, parity with the TS builder.
+  - **Builds on:** slice 0's contract `through` shape (the lowering target).
+  - **Hands to:** PSL-authored M:N → unblocks the PG demo (slice 6).
+  - **Focus:** `packages/2-sql/2-authoring/contract-psl/src/psl-relation-resolution.ts` (today emits only `N:1`/`1:N`) + the PSL→RelationNode lowering; recognise/collapse the junction into a `through` relation. **Likely large — re-check slice-INVEST at pickup; may warrant promotion to its own project.**
+
+- **Slice `06-pg-demo-examples`** — Linear: [TML-2795](https://linear.app/prisma-company/issue/TML-2795) — **planned, blocked by slice 5.**
+  - **Outcome:** the PG demo (`examples/prisma-next-demo`) demonstrates the M:N API (mirroring slice 4), AND its pre-existing dual-mode contract drift (stale TS source / missing TS-builder discriminator authoring) is reconciled.
+  - **Builds on:** slice 5 (PSL M:N authoring — the PG demo emits from PSL); slice 4 (the example shape to mirror).
+  - **Hands to:** M:N demonstrated in both demos; dual-mode green.
+  - **Focus:** add `Post ↔ Tag` M:N to the PSL source + example modules/CLI/seed/tests; resolve dual-mode (`test:dual-mode` is currently red on the TS leg — fix the TS source or drop it). The dual-mode-drift half is independent of slice 5 and can start first.
+
+### Sequencing (follow-on)
+
+Slice 4 (done) and the **dual-mode-drift half of slice 6** are independent and could have run anytime after the core. Slice 5 (PSL authoring) gates the **M:N-examples half of slice 6**. Note this pushes the project to **7 slices** — past the 1–4 sweet spot; slice 5 in particular is framework-scoped and may be better promoted to its own project at pickup (flagged above).
diff --git a/projects/sql-orm-many-to-many/slices/04-sqlite-demo-examples/spec.md b/projects/sql-orm-many-to-many/slices/04-sqlite-demo-examples/spec.md
new file mode 100644
index 0000000000..6d3c397a1f
--- /dev/null
+++ b/projects/sql-orm-many-to-many/slices/04-sqlite-demo-examples/spec.md
@@ -0,0 +1,31 @@
+# Slice 4: SQLite demo M:N examples — DONE
+
+_Parent project: `projects/sql-orm-many-to-many/`. Linear: [TML-2790](https://linear.app/prisma-company/issue/TML-2790). Status: **complete** (branch `tml-2790-mn-demo-examples`)._
+
+## At a glance
+
+Demonstrate the M:N ORM API end-to-end in the **SQLite** demo (`examples/prisma-next-demo-sqlite`, TS-authored — the only demo that can author M:N today, since the PG demo emits from PSL). Worked reference for include / filter / nested-write through a junction.
+
+## Chosen design (as shipped)
+
+`Post ↔ Tag` (+ reverse `Tag.posts`) M:N via a **pure** `PostTag` junction (`postId`/`tagId`, composite PK, no payload), authored in `prisma/contract.ts` with `rel.manyToMany(() => Tag, { through: () => PostTag, from, to })`. Emitted contract carries `cardinality:'N:M'` + `through`. ORM client modules:
+
+- `get-post-tags.ts` — `.include('tags', t => t.select('id','label')…)`.
+- `get-posts-by-tag-filter.ts` — `.where(p => p.tags.some/none/every(t => t.label.eq(...)))`.
+- `connect-post-tags.ts` / `disconnect-post-tags.ts` — `.update({ tags: t => t.connect/disconnect([{ id }]) })` + readback.
+- `create-post-with-tags.ts` — `.create({ …, tags: t => t.create([{ label }]) })`.
+
+Wired as 6 CLI commands in `src/main.ts`; seed adds tags + junction rows. Smoke-tested end-to-end (SQLite is offline-runnable).
+
+## Scope
+
+**In:** the SQLite demo only — contract, emit, ORM modules, CLI, seed. **Out:** the PG demo (PSL can't author M:N — slice 6, blocked by slice 5).
+
+## Slice-specific done conditions
+
+- [x] Emitted contract has `cardinality:'N:M'` + `through`; `emit:check` + typecheck clean.
+- [x] include / `some`/`none`/`every` / connect / disconnect / create examples run end-to-end (smoke-tested via CLI).
+
+## References
+
+- Parent: `projects/sql-orm-many-to-many/spec.md`. Commits: `72ef8b793` (contract+emit), `883309ecc` (modules/CLI/seed).
diff --git a/projects/sql-orm-many-to-many/slices/05-psl-many-to-many-authoring/plan.md b/projects/sql-orm-many-to-many/slices/05-psl-many-to-many-authoring/plan.md
new file mode 100644
index 0000000000..e511eecf86
--- /dev/null
+++ b/projects/sql-orm-many-to-many/slices/05-psl-many-to-many-authoring/plan.md
@@ -0,0 +1,28 @@
+# Slice 5: PSL M:N authoring — Dispatch plan (provisional)
+
+**Spec:** `projects/sql-orm-many-to-many/slices/05-psl-many-to-many-authoring/spec.md`
+**Linear:** [TML-2794](https://linear.app/prisma-company/issue/TML-2794)
+
+> **Provisional** — the dispatch breakdown depends on PSL-pipeline grounding not yet done (the PSL interpreter / lowering / diagnostic interaction). Firm up at pickup via `drive-specify-slice` + `drive-plan-slice`; **re-check whether this is a slice or a project** (it's framework-scoped). The breakdown below is the expected shape.
+
+### Dispatch 1: PSL junction → `N:M` + `through` lowering
+
+- **Outcome:** the PSL relation resolver/lowering recognises a junction (explicit `@@id([a,b])` join model — form 1) and emits a relation with `cardinality:'N:M'` + a populated `through` descriptor (composite-key-correct), parity with the TS builder. Unit-tested at the lowering level.
+- **Builds on:** slice 0's contract `through` shape (the target); the TS builder's `rel.manyToMany` lowering as the parity reference.
+- **Hands to:** PSL emits navigable M:N relations.
+- **Focus:** `psl-relation-resolution.ts` + the PSL→RelationNode lowering; the `PSL_ORPHANED_BACKRELATION_LIST` diagnostic (relax when a junction is recognised, without regressing legitimate explicit-junction 1:N use).
+
+### Dispatch 2: PSL M:N fixture + ORM-API parity tests
+
+- **Outcome:** a PSL-authored M:N fixture round-trips `validateContract`, and the M:N ORM API (include / `some`/`none`/`every` / nested write) works against it — parity with the TS-authored `User↔Tag` fixture.
+- **Builds on:** dispatch 1.
+- **Hands to:** proven PSL→ORM M:N parity → unblocks the PG demo (slice 6).
+- **Focus:** a PSL fixture mirroring the TS M:N fixture; integration tests (reuse the slice-1/2/3 M:N test patterns); `fixtures:check`.
+
+### Dispatch 3 (conditional): implicit-list authoring
+
+- **Outcome:** Prisma-style implicit `Tag[]`/`Post[]` M:N (no explicit junction) lowers to an implicit junction. **Only if Open Question 1 chooses to include it** — otherwise drop (form 1 alone satisfies the slice).
+
+## Handoff completeness
+
+Slice-DoD reachable: PSL emits `N:M`+`through` (D1) · ORM-API parity from a PSL contract (D2). D2's hand-off (PSL M:N parity) is what slice 6 (PG demo) needs.
diff --git a/projects/sql-orm-many-to-many/slices/05-psl-many-to-many-authoring/spec.md b/projects/sql-orm-many-to-many/slices/05-psl-many-to-many-authoring/spec.md
new file mode 100644
index 0000000000..8d545ad146
--- /dev/null
+++ b/projects/sql-orm-many-to-many/slices/05-psl-many-to-many-authoring/spec.md
@@ -0,0 +1,48 @@
+# Slice 5: PSL many-to-many authoring
+
+_Parent project: `projects/sql-orm-many-to-many/`. Linear: [TML-2794](https://linear.app/prisma-company/issue/TML-2794). Status: **planned** (not started)._
+
+> **Sizing flag:** this is framework-scoped (the PSL interpreter), not an `sql-orm-client` change. It may fail slice-INVEST *Small* and warrant **promotion to its own project**. Re-check at pickup (`drive-triage-work`); the dispatch plan below is provisional pending PSL-pipeline grounding.
+
+## At a glance
+
+PSL can't author a navigable M:N relation. The PSL relation resolver emits only `cardinality:'N:1'`/`'1:N'`; `'N:M'` + `through` comes only from the TS builder (`rel.manyToMany`). PSL routes M:N to explicit junction models (`PSL_ORPHANED_BACKRELATION_LIST`). This slice teaches PSL to lower a junction to a navigable `N:M` + `through`, so PSL-authored schemas get the same M:N ORM API (and the PG demo, slice 6, becomes possible).
+
+## Chosen design (intent — to be firmed at pickup)
+
+Teach the PSL interpreter / lowering to recognise a many-to-many shape and emit a relation with `cardinality:'N:M'` + a `through` descriptor (`{ table, parentColumns, childColumns, targetColumns }`) — the exact shape slice 0 put in the contract and `sql-orm-client`'s `resolveThrough` consumes. Two candidate authoring forms (decide at spec-firm-up):
+
+1. **Explicit junction model** — an `@@id([a, b])` join model with two FK relations (the shape PSL currently emits as three `1:N`/`N:1` relations) is recognised and *additionally* surfaced as a navigable `N:M` on each side. Lowest-magic; matches what the diagnostic already steers authors toward.
+2. **Prisma-style implicit list** — `tags Tag[]` / `posts Post[]` with no explicit junction, lowered to an implicit junction table. More ergonomic, more interpreter work.
+
+Primary surface: `packages/2-sql/2-authoring/contract-psl/src/psl-relation-resolution.ts` (today emits `N:1` at ~line 255, `1:N` at ~line 322 — no `N:M`/`through`) + the PSL→RelationNode lowering + the `PSL_ORPHANED_BACKRELATION_LIST` diagnostic (relax/replace when the junction is recognised).
+
+## Scope
+
+**In:** PSL relation resolution + lowering to emit `N:M` + `through`; the M:N PSL diagnostic; PSL-authored M:N fixtures/tests; round-trip through `validateContract`.
+
+**Out:** `sql-orm-client` runtime (already done, slices 0–3 — consumes `through` regardless of author); the TS builder (already emits `through`); the PG demo (slice 6).
+
+## Pre-investigated edge cases
+
+| Edge case | Disposition |
+|---|---|
+| Composite-key junctions | `through.{parentColumns,childColumns,targetColumns}` are arrays — lowering must handle multi-column FKs (parity with the TS builder) |
+| Self-referential M:N (e.g. User↔User followers) | confirm the lowering handles same-model both-sides |
+| Existing `PSL_ORPHANED_BACKRELATION_LIST` consumers | relaxing the diagnostic must not regress schemas that legitimately want explicit-junction 1:N modelling |
+
+## Slice-specific done conditions
+
+- [ ] A PSL schema with a junction (form decided at firm-up) emits a relation with `cardinality:'N:M'` + populated `through`, round-tripping `validateContract`.
+- [ ] ORM-API parity: `include` / `some`/`none`/`every` / nested write work from a PSL-authored M:N contract (a PSL fixture mirroring the TS `User↔Tag` fixture).
+- [ ] `fixtures:check` green; the M:N diagnostic behaves correctly (no false `PSL_ORPHANED_BACKRELATION_LIST` on a recognised junction).
+
+## Open Questions
+
+1. **Authoring form** — explicit-junction recognition (form 1) vs implicit-list (form 2) vs both. Working position: **start with explicit-junction recognition** (form 1) — smallest, matches the existing diagnostic's guidance; add implicit-list as a follow-up if desired.
+2. **Project vs slice** — likely promote to its own project. Working position: re-triage at pickup.
+
+## References
+
+- Parent: `projects/sql-orm-many-to-many/spec.md` (§ Follow-on scope). Slice 0's contract `through` shape is the lowering target.
+- `packages/2-sql/2-authoring/contract-psl/src/psl-relation-resolution.ts`; the TS builder's `rel.manyToMany` lowering (`contract-lowering.ts`) as the parity reference.
diff --git a/projects/sql-orm-many-to-many/slices/06-pg-demo-examples/plan.md b/projects/sql-orm-many-to-many/slices/06-pg-demo-examples/plan.md
new file mode 100644
index 0000000000..c8fb88ab3e
--- /dev/null
+++ b/projects/sql-orm-many-to-many/slices/06-pg-demo-examples/plan.md
@@ -0,0 +1,24 @@
+# Slice 6: PG demo M:N examples + dual-mode — Dispatch plan (provisional)
+
+**Spec:** `projects/sql-orm-many-to-many/slices/06-pg-demo-examples/spec.md`
+**Linear:** [TML-2795](https://linear.app/prisma-company/issue/TML-2795)
+
+> **Provisional** — half B depends on slice 5 (PSL M:N authoring); the dual-mode-reconciliation approach (half A) is an open decision. Firm up at pickup.
+
+### Dispatch 1: dual-mode reconciliation (independent — can run before slice 5)
+
+- **Outcome:** `pnpm test:dual-mode` is green — either both PSL and TS emit legs pass, or the TS contract source is removed and the demo is cleanly PSL-only (per Open Question 1).
+- **Builds on:** nothing in this project (it's a pre-existing demo bug).
+- **Hands to:** a demo whose contract source(s) are consistent — a clean base for the M:N example additions.
+- **Focus:** `examples/prisma-next-demo` dual-mode setup (`prisma-next.config.ts*`, `prisma/contract.ts`, `src/prisma/contract.prisma`, the `emit:psl`/`emit:ts`/`test:dual-mode` scripts).
+
+### Dispatch 2: PG demo M:N examples (blocked by slice 5)
+
+- **Outcome:** the PG demo demonstrates the M:N API — `Post ↔ Tag` M:N in the PSL source, with include / `some`/`none`/`every` filter / nested `connect`/`disconnect`/`create` ORM modules + CLI commands + seed + integration tests (per the project's integration-test standard), mirroring slice 4.
+- **Builds on:** slice 5 (PSL authors M:N → the PSL source can express it) + dispatch 1 (consistent contract source) + slice 4 (the example shape).
+- **Hands to:** M:N demonstrated in both demos.
+- **Focus:** PSL `Post ↔ Tag` M:N + re-emit; ORM modules mirroring slice 4's; CLI/seed/tests; regenerate migration refs per the demo's current `fixtures/` convention.
+
+## Handoff completeness
+
+Slice-DoD reachable: `test:dual-mode` green (D1) · PG M:N examples per standard (D2). D1 is independent (start anytime); D2 waits on slice 5.
diff --git a/projects/sql-orm-many-to-many/slices/06-pg-demo-examples/spec.md b/projects/sql-orm-many-to-many/slices/06-pg-demo-examples/spec.md
new file mode 100644
index 0000000000..03005ab29d
--- /dev/null
+++ b/projects/sql-orm-many-to-many/slices/06-pg-demo-examples/spec.md
@@ -0,0 +1,42 @@
+# Slice 6: PG demo M:N examples + dual-mode reconciliation
+
+_Parent project: `projects/sql-orm-many-to-many/`. Linear: [TML-2795](https://linear.app/prisma-company/issue/TML-2795). Status: **planned**; M:N-examples half **blocked by slice 5** (TML-2794)._
+
+## At a glance
+
+Bring the M:N demo examples to the **PG** demo (`examples/prisma-next-demo`), mirroring the SQLite demo (slice 4), and reconcile the demo's pre-existing **dual-mode contract drift**. The PG demo emits from PSL, so its M:N examples can't exist until PSL can author M:N (slice 5).
+
+## Chosen design
+
+Two separable halves:
+
+**A. Dual-mode reconciliation (independent — can start before slice 5).** The PG demo is nominally dual-mode (PSL `src/prisma/contract.prisma` + TS `prisma/contract.ts`, expected to emit identically). They're out of sync: the committed contract matches the **PSL** emit; `emit:ts` diverges (drops the discriminated `Task`/`Bug`/`Feature` hierarchy, `displayName`, typed `Address`) → `test:dual-mode` is red on the TS leg. Root cause: the **TS builder can't author the discriminator/`@@base` hierarchy**. Reconcile by one of: (i) add TS-builder discriminator/inheritance authoring (framework feature — bigger), (ii) drop the TS contract source and make the demo PSL-only, or (iii) another agreed approach. Decide at pickup.
+
+**B. M:N examples (blocked by slice 5).** Once PSL authors M:N, add a `Post ↔ Tag` M:N relation to the PSL source (`src/prisma/contract.prisma`) + example ORM modules (include / `some`/`none`/`every` filter / nested `connect`/`disconnect`/`create` via the callback mutator) + CLI commands + seed + integration tests — mirroring slice 4's SQLite modules.
+
+## Scope
+
+**In:** the PG demo only — dual-mode reconciliation (A) + M:N examples on the PSL source (B); integration tests matching the demo's `test/` pattern (`withDevDatabase`).
+
+**Out:** the PSL M:N authoring mechanism itself (slice 5); the SQLite demo (slice 4, done); TS-builder discriminator authoring if reconciliation chooses to drop the TS source instead.
+
+## Pre-investigated edge cases
+
+| Edge case | Disposition |
+|---|---|
+| Dual-mode `emit:check` only diffs the **default (PSL)** config | `test:dual-mode` (run-suite-against-each-emit) is the real dual-mode gate; reconciliation must make BOTH legs green or remove the TS leg |
+| The integration-test standard (whole-row, explicit-select, ≥1 implicit) | applies to the PG M:N examples too (project cross-cutting requirement) |
+| PG demo migration fixtures (reorganised on `main` under `fixtures/`) | M:N relation will add migration refs — regenerate per the demo's current convention |
+
+## Slice-specific done conditions
+
+- [ ] `test:dual-mode` green (both legs pass, or the TS source is removed and the demo is cleanly PSL-only).
+- [ ] PG demo demonstrates the M:N API (include / filter / nested write) — mirroring slice 4 — via CLI commands, seeded, with integration tests per the standard.
+
+## Open Questions
+
+1. **Dual-mode reconciliation approach** — add TS-builder discriminator authoring (i) vs drop the TS source / PSL-only (ii). Working position: lean (ii) PSL-only unless TS-builder discriminator authoring is wanted for its own sake — but this is the operator's call (it touches the demo's dual-mode story).
+
+## References
+
+- Parent: `projects/sql-orm-many-to-many/spec.md` (§ Follow-on scope, § Cross-cutting integration-test standard). Slice 4 (`TML-2790`) is the example shape to mirror; slice 5 (`TML-2794`) is the blocker for half B.
diff --git a/projects/sql-orm-many-to-many/spec.md b/projects/sql-orm-many-to-many/spec.md
index a0a921a3a3..3e79bd70d9 100644
--- a/projects/sql-orm-many-to-many/spec.md
+++ b/projects/sql-orm-many-to-many/spec.md
@@ -39,6 +39,16 @@ The whole project hangs off one new primitive: a uniform **`through` descriptor*
 - **LATERAL / multi-query read strategies.** Removed by TML-2729 / TML-2657; the read path is correlated-only and stays that way.
 - **Wiring the Pothos plugin itself.** This project makes the runtime M:N API shape match what the plugin needs (`{ connect: { id } }` / `{ disconnect: { id } }`); the plugin-side wiring is downstream.
 
+## Follow-on scope (expanded 2026-06-02)
+
+After the runtime core (slices 0–3) shipped, scope expanded to **demonstrate the M:N API end-to-end in the example apps** — and that surfaced a real authoring-surface gap. These are slices 4–6 (see the plan):
+
+- **Demo examples** (previously implicit, now explicit scope). The SQLite demo (`examples/prisma-next-demo-sqlite`, TS-authored) demonstrates include / filter / nested-write M:N — **done** (slice 4 / TML-2790).
+- **PSL many-to-many authoring** (newly in scope — slice 5 / TML-2794). The navigable M:N API is authorable **only via the TS contract builder** (`rel.manyToMany`); PSL emits only `1:N`/`N:1` and routes M:N to explicit junction models. Teaching PSL to lower a junction to `cardinality:'N:M'` + `through` completes the authoring surface. _(Framework-scoped — may be promoted to its own project at pickup.)_
+- **PG demo examples + dual-mode reconciliation** (slice 6 / TML-2795, **blocked by slice 5**). The PG demo emits from PSL, so it can't show M:N until slice 5 lands; it also carries pre-existing dual-mode contract drift (stale TS source) to reconcile.
+
+_Note: the original Non-goal "auto-synthesised junction models" still holds for the **TS** builder; slice 5's PSL implicit-list support (if pursued) is a PSL-authoring convenience, not auto-synthesis in the runtime contract._
+
 ## Place in the larger world
 
 - **sql-orm-client** (`packages/3-extensions/sql-orm-client`) is an optional extension over the SQL contract + query lane — ADR 015 (ORM as Optional Extension).
@@ -71,6 +81,12 @@ Inherits the team-DoD floor ([`drive/calibration/dod.md`](../../drive/calibratio
 - [ ] The runtime M:N callback shape matches what the Pothos plugin needs (`{ connect: { id } }` / `{ disconnect: { id } }`).
 - [ ] ADR for the `through` relation contract extension authored or ADR 121 amended (see ADR pointer).
 
+_Follow-on (slices 4–6):_
+
+- [x] **SQLite demo** demonstrates the M:N API (include / filter / nested write) end-to-end (slice 4 / TML-2790).
+- [ ] **PSL authors M:N** — a PSL junction lowers to `cardinality:'N:M'` + `through`, with ORM-API parity to TS-authored contracts (slice 5 / TML-2794). _(May be promoted to its own project.)_
+- [ ] **PG demo** demonstrates the M:N API and its dual-mode contract sources are reconciled (`test:dual-mode` green) (slice 6 / TML-2795; blocked by slice 5).
+
 ## Contract-impact
 
 _Required: this project changes the contract surface._