@zodmire/core 0.1.0 → 0.1.2

package/mod.mjs

@@ -63,7 +63,7 @@ const VENDORED_FILE_MANIFEST = [
 		sourceRelativePath: "packages/config/composition_config.ts"
 	}
 ];
-/** Rewrite Deno-style `npm:zod@*` imports to bare `"zod"` for end-user consumption. */
+/** Rewrite `npm:zod@*` imports to bare `"zod"` for end-user consumption. */
 function rewriteImports(content) {
 	return content.replace(/["']npm:zod@[^"']*["']/g, "\"zod\"");
 }
@@ -160,6 +160,44 @@ function createReadField(exportName) {
 				sourceSchema: rawSchema,
 				objectShape: def.shape
 			};
+			case zx.tagged("intersection")(rawSchema): {
+				const left = def.left;
+				const right = def.right;
+				if (left?.objectShape && right?.objectShape) return {
+					type: "object",
+					optional: false,
+					array: false,
+					sourceSchema: rawSchema,
+					objectShape: {
+						...left.objectShape,
+						...right.objectShape
+					}
+				};
+				return {
+					type: "intersection",
+					optional: false,
+					array: false,
+					sourceSchema: rawSchema
+				};
+			}
+			case zx.tagged("union")(rawSchema): return {
+				type: "union",
+				optional: false,
+				array: false,
+				sourceSchema: rawSchema
+			};
+			case zx.tagged("record")(rawSchema): return {
+				type: "record",
+				optional: false,
+				array: false,
+				sourceSchema: rawSchema
+			};
+			case zx.tagged("tuple")(rawSchema): return {
+				type: "tuple",
+				optional: false,
+				array: false,
+				sourceSchema: rawSchema
+			};
 			case zx.tagged("string")(rawSchema):
 			case zx.tagged("number")(rawSchema):
 			case zx.tagged("int")(rawSchema):
@@ -470,6 +508,64 @@ function mergeSchemaReadResults(results) {
 
 //#endregion
 //#region packages/core/normalizer.ts
+function generatedCapability() {
+	return {
+		status: "generated",
+		reasons: []
+	};
+}
+function disabledCapability(reason) {
+	return {
+		status: "disabled",
+		reasons: [reason]
+	};
+}
+function runtimeThrowCapability(reasons) {
+	return {
+		status: "runtime-throw",
+		reasons
+	};
+}
+function canMapReadModelOutput$1(readModel, outputFields) {
+	const readModelFields = new Set(readModel.fields.map((field) => camelCase(field.name)));
+	return outputFields.every((field) => readModelFields.has(camelCase(field.name)));
+}
+function resolveGeneratedFindByIdLookupField(readModel, query) {
+	if (readModel.primaryKey.length !== 1) return null;
+	const primaryKeyField = camelCase(readModel.primaryKey[0]);
+	const matchingField = (query.inputFields ?? []).find((field) => camelCase(field.name) === primaryKeyField);
+	if (matchingField) return camelCase(matchingField.name);
+	if ((query.inputFields ?? []).length === 1) return camelCase(query.inputFields[0].name);
+	return null;
+}
+function deriveCommandCapability(command) {
+	const reasons = [];
+	if (!command.effects || command.effects.length === 0) reasons.push("command does not declare any effects");
+	if (command.commandKind === "update" && !command.loadBy) reasons.push("mutation commands require loadBy");
+	return reasons.length === 0 ? generatedCapability() : runtimeThrowCapability(reasons);
+}
+function deriveQueryCapability(query, readModelByName) {
+	const reasons = [];
+	if (!query.readModelName) reasons.push("query does not declare readModelName");
+	const readModel = query.readModelName ? readModelByName.get(query.readModelName) : void 0;
+	if (!readModel) reasons.push(`read-model "${query.readModelName ?? query.name}" is missing`);
+	else {
+		if (!canMapReadModelOutput$1(readModel, query.outputFields)) reasons.push("output fields do not map directly to the read-model");
+		if (query.queryKind === "findById" && !resolveGeneratedFindByIdLookupField(readModel, query)) reasons.push("read-model does not expose a stable findById lookup field");
+	}
+	return reasons.length === 0 ? generatedCapability() : runtimeThrowCapability(reasons);
+}
+function deriveProjectionCapabilities(projection, readModelByName) {
+	const writeReasons = [];
+	if (!readModelByName.has(projection.readModelName)) writeReasons.push(`read-model "${projection.readModelName}" is missing`);
+	for (const source of projection.sources) if (source.mutation.kind === "custom") writeReasons.push(`source "${source.contextName}.${source.aggregateName}.${source.eventName}" requires custom mutation handler "${source.mutation.handlerName}"`);
+	const writeModel = writeReasons.length === 0 ? generatedCapability() : runtimeThrowCapability(writeReasons);
+	return {
+		projector: generatedCapability(),
+		writeModel,
+		rebuild: !projection.rebuild?.enabled ? disabledCapability("projection rebuild is disabled") : writeModel.status === "generated" ? generatedCapability() : runtimeThrowCapability([...writeModel.reasons])
+	};
+}
 function buildContextNormalizedSpec(schemaResult, config) {
 	if (schemaResult.aggregates.length === 0) throw new Error(`[normalizer] No aggregate found in SchemaReadResult. Context "${config.name}" requires at least one aggregate.`);
 	const aggregateNames = new Set(schemaResult.aggregates.map((a) => a.name));
@@ -653,7 +749,8 @@ function buildContextNormalizedSpec(schemaResult, config) {
 			sources: projection.sources.map((source) => ({
 				...source,
 				locality: source.contextName === config.name ? "local" : "external"
-			}))
+			})),
+			capabilities: deriveProjectionCapabilities(projection, readModelByName)
 		};
 	});
 	return {
@@ -685,9 +782,11 @@ function buildContextNormalizedSpec(schemaResult, config) {
 			loadBy: cmd.loadBy,
 			preconditions: cmd.preconditions,
 			emits: cmd.emits,
-			effects: cmd.effects
+			effects: cmd.effects,
+			capability: deriveCommandCapability(cmd)
 		})),
 		queries: schemaResult.queries.map((q) => {
+			const capability = deriveQueryCapability(q, readModelByName);
 			const readSide = {
 				readModelName: q.readModelName ?? pascalCase(q.name),
 				searchFields: [],
@@ -746,7 +845,8 @@ function buildContextNormalizedSpec(schemaResult, config) {
 					pagination: { style: "offset" },
 					filters: q.filters,
 					sorting: q.sorting,
-					computedFields: resolvedComputed
+					computedFields: resolvedComputed,
+					capability
 				};
 			}
 			return {
@@ -758,7 +858,8 @@ function buildContextNormalizedSpec(schemaResult, config) {
 				outputSchemaPath: q.outputSchemaPath,
 				outputSchemaExportName: q.outputSchemaExportName,
 				readModelName: q.readModelName,
-				readSide
+				readSide,
+				capability
 			};
 		}),
 		readModels: normalizedReadModels,
@@ -826,6 +927,7 @@ function walkEntityTree(aggregate, visitor) {
 //#region packages/core/composition_normalizer.ts
 function buildNormalizedCompositionSpec(config, contextSpecs) {
 	assertUniqueCanonicalContextSpecs(contextSpecs);
+	const infrastructure = resolveInfrastructureStrategy(config.infrastructure);
 	const resolveProvidedContextRef = createContextRefResolver(contextSpecs);
 	const resolvedContexts = [];
 	const resolvedContextSpecs = [];
@@ -884,9 +986,60 @@ function buildNormalizedCompositionSpec(config, contextSpecs) {
 		contexts: resolvedContexts,
 		crossContextEvents,
 		acls,
+		infrastructure,
 		materialization: { targetRoot: config.materialization.targetRoot }
 	};
 }
+function resolveInfrastructureStrategy(input) {
+	const supportedTuples = [
+		{
+			architecture: "physical-cqrs",
+			persistence: "postgres",
+			orm: "drizzle"
+		},
+		{
+			architecture: "logical-cqrs",
+			persistence: "postgres",
+			orm: "drizzle"
+		},
+		{
+			architecture: "logical-cqrs",
+			persistence: "mysql",
+			orm: "drizzle"
+		},
+		{
+			architecture: "physical-cqrs",
+			persistence: "mysql",
+			orm: "drizzle"
+		},
+		{
+			architecture: "physical-cqrs",
+			persistence: "postgres",
+			orm: "mikroorm"
+		},
+		{
+			architecture: "logical-cqrs",
+			persistence: "postgres",
+			orm: "mikroorm"
+		},
+		{
+			architecture: "physical-cqrs",
+			persistence: "mysql",
+			orm: "mikroorm"
+		},
+		{
+			architecture: "logical-cqrs",
+			persistence: "mysql",
+			orm: "mikroorm"
+		}
+	];
+	if (!supportedTuples.some((tuple) => tuple.architecture === input.architecture && tuple.persistence === input.persistence && tuple.orm === input.orm)) throw new Error(`[composition] Unsupported infrastructure strategy:\narchitecture=${input.architecture}, persistence=${input.persistence}, orm=${input.orm}\n\nCurrently supported strategies:\n` + supportedTuples.map((tuple) => `- ${tuple.architecture} + ${tuple.persistence} + ${tuple.orm}`).join("\n"));
+	return {
+		architecture: input.architecture,
+		persistence: input.persistence,
+		orm: input.orm
+	};
+}
 function assertUniqueCanonicalContextSpecs(contextSpecs) {
 	const seenModulePaths = /* @__PURE__ */ new Map();
 	for (const spec of contextSpecs) {
@@ -1140,6 +1293,10 @@ function aggregateVariableName$1(spec) {
 function aggregateIdPropertyName$1(spec) {
 	return `${aggregateVariableName$1(spec)}Id`;
 }
+function defaultIdBrandName(name) {
+	const base = pascalCase(name);
+	return base.endsWith("Id") ? base : `${base}Id`;
+}
 function formatFieldType$1(field, indent = 0) {
 	if (field.type === "object" && field.nestedFields && field.nestedFields.length > 0) {
 		const objectType = `{\n${field.nestedFields.map((nestedField) => {
@@ -1367,6 +1524,7 @@ function renderEffectLines(effects, inputVar, spec, indent, selfRef = "this", is
 	const aggregateFieldsByName = new Map(filterManagedAggregateFields$1(spec.aggregate.fields ?? []).map((field) => [camelCase(field.name), field]));
 	let lastPushedEntityVar = null;
 	let lastPushedEntityIdField = null;
+	let lastPushedEntityTypeName = null;
 	const idFieldName = spec.aggregate.idField ? camelCase(spec.aggregate.idField) : null;
 	const lines = [];
 	for (const effect of effects) switch (effect.kind) {
@@ -1397,11 +1555,11 @@ function renderEffectLines(effects, inputVar, spec, indent, selfRef = "this", is
 					}
 					return `${fieldName}: ${aggregateAccess}`;
 				}
-				if (lastPushedEntityVar && !aggregateFieldNames.has(fieldName)) return `${fieldName}: (${lastPushedEntityVar} as any).${fieldName}`;
+				if (lastPushedEntityVar && !aggregateFieldNames.has(fieldName)) return `${fieldName}: (${lastPushedEntityVar} as ${lastPushedEntityTypeName ?? "Record<string, unknown>"}).${fieldName}`;
 				if (availableInputFields.has(fieldName)) return `${fieldName}: ${inputVar}.${fieldName}`;
 				if (fieldName === "occurredAt" || fieldName.endsWith("At")) return `${fieldName}: ${f.type === "date" ? "new Date()" : "new Date().toISOString()"}`;
 				if (fieldName === "recordedBy" || fieldName.endsWith("By")) return `${fieldName}: ${f.type === "string" ? "eventContext.recordedBy.value" : "eventContext.recordedBy"}`;
-				return `${fieldName}: undefined as unknown as ${eventName}Payload["${fieldName}"]`;
+				return `${fieldName}: /* TODO: unmapped ${eventName} payload field "${fieldName}" */ undefined as never`;
 			}).join(", ")} }` : "{}";
 			lines.push(`${indent}${selfRef}.raise(createDomainEvent<${eventName}Payload>({`, `${indent}  eventType: "${contextName}.${eventName}",`, `${indent}  eventVersion: 1,`, `${indent}  entityType: "${aggregateName}",`, `${indent}  entityId: ${selfRef}.id,`, `${indent}  contextName: "${contextName}",`, `${indent}  recordedBy: eventContext.recordedBy,`, `${indent}  correlationId: eventContext.correlationId,`, `${indent}  causationId: eventContext.causationId,`, `${indent}  payload: ${payloadObj},`, `${indent}}));`);
 			break;
@@ -1420,6 +1578,7 @@ function renderEffectLines(effects, inputVar, spec, indent, selfRef = "this", is
 				const entityVar = camelCase(targetChild.name);
 				lastPushedEntityVar = entityVar;
 				lastPushedEntityIdField = targetChild.idField;
+				lastPushedEntityTypeName = entityName;
 				lines.push(`${indent}const ${entityVar} = ${entityName}.create({`, `${indent}  ${camelCase(targetChild.idField)}: ${createIdFn}(crypto.randomUUID()),`, `${indent}  ...${inputVar} as any,`, `${indent}});`, `${indent}${selfRef}.${camelCase(effect.target)}.push(${entityVar});`);
 			} else lines.push(`${indent}${selfRef}.${camelCase(effect.target)}.push(${renderEffectValue(effect.value, inputVar, selfRef)});`);
 			break;
@@ -1520,10 +1679,10 @@ function createAggregateStub(spec) {
 		return `  readonly ${camelCase(child.collectionFieldName)}: ${entityName}[] = [];`;
 	});
 	const constructorAssignments = nonIdFields.map((f) => `    this.${camelCase(f.name)} = props.${camelCase(f.name)};`).join("\n");
-	const idTypeStr = idType ? `BrandedId<"${idType}">` : `BrandedId<string>`;
+	const idTypeStr = `BrandedId<"${idType && idType !== "string" ? pascalCase(idType) : defaultIdBrandName(spec.aggregate.name)}">`;
 	let createBody;
 	if (createCmd?.effects?.length) createBody = `    const instance = new ${aggregateClassName}(id, 0, props);
-${renderEffectLines(createCmd.effects, "props", spec, "    ", "instance", true).join("\n")}
+${renderEffectLines(createCmd.effects.filter((effect) => effect.kind !== "set-field" || effect.value !== `input.${effect.target}`), "props", spec, "    ", "instance", true).join("\n")}
     return instance;`;
 	else createBody = `    return new ${aggregateClassName}(id, 0, props);`;
 	const fieldTypeMap = /* @__PURE__ */ new Map();
@@ -1601,9 +1760,8 @@ ${methodLines.join("\n")}
 		const opt = f.optional ? "?" : "";
 		persistenceLines.push(`  readonly ${camelCase(f.name)}${opt}: ${formatPersistenceFieldType(f)};`);
 	}
-	const fromPersistenceFields = nonIdFields.map((f) => `      ${camelCase(f.name)}: state.${camelCase(f.name)},`);
-	for (const child of spec.aggregate.children ?? []) fromPersistenceFields.push(`      ${camelCase(child.collectionFieldName)}: state.${camelCase(child.collectionFieldName)},`);
-	const fromPersistenceAssignment = fromPersistenceFields.length > 0 ? `    Object.assign(instance, {\n${fromPersistenceFields.join("\n")}\n    });` : "";
+	const fromPersistenceProps = nonIdFields.map((f) => `      ${camelCase(f.name)}: state.${camelCase(f.name)},`).join("\n");
+	const collectionAssignments = (spec.aggregate.children ?? []).map((child) => `    instance.${camelCase(child.collectionFieldName)}.push(...state.${camelCase(child.collectionFieldName)});`).join("\n");
 	return `${imports}
 
 export interface ${aggregateClassName}Props {
@@ -1644,8 +1802,11 @@ ${createBody}
 		rehydrationStateName,
 		children: spec.aggregate.children ?? []
 	})}(state);
-    const instance = new ${aggregateClassName}(state.${camelCase(idField)}, state.version, state as unknown as ${aggregateClassName}Props);
-${fromPersistenceAssignment}
+    const props: ${aggregateClassName}Props = {
+${fromPersistenceProps}
+    };
+    const instance = new ${aggregateClassName}(state.${camelCase(idField)}, state.version, props);
+${collectionAssignments}
     return instance;
   }${mutationMethods.join("")}
 }
@@ -1657,7 +1818,7 @@ function createEntityStub(entity, depthFromDomain = 1) {
 	const idField = entity.idField;
 	const idType = entity.idType;
 	const nonIdFields = fields.filter((f) => f.name !== idField);
-	const idTypeStr = idType && idType !== "string" ? `BrandedId<"${idType}">` : `BrandedId<string>`;
+	const idTypeStr = `BrandedId<"${idType && idType !== "string" ? pascalCase(idType) : defaultIdBrandName(entity.name)}">`;
 	const libRelPath = "../../../../../lib";
 	const imports = [
 		`import { Entity } from "${libRelPath}/entity.base.ts";`,
@@ -1703,9 +1864,8 @@ function createEntityStub(entity, depthFromDomain = 1) {
 		const opt = f.optional ? "?" : "";
 		persistenceLines.push(`  readonly ${camelCase(f.name)}${opt}: ${formatPersistenceFieldType(f)};`);
 	}
-	const entityFromPersistenceFields = nonIdFields.map((f) => `      ${camelCase(f.name)}: state.${camelCase(f.name)},`);
-	for (const child of children) entityFromPersistenceFields.push(`      ${camelCase(child.collectionFieldName)}: state.${camelCase(child.collectionFieldName)},`);
-	const entityFromPersistenceAssignment = entityFromPersistenceFields.length > 0 ? `    Object.assign(instance, {\n${entityFromPersistenceFields.join("\n")}\n    });` : "";
+	const entityFromPersistenceProps = nonIdFields.map((f) => `      ${camelCase(f.name)}: state.${camelCase(f.name)},`).join("\n");
+	const entityCollectionAssignments = children.map((child) => `    instance.${camelCase(child.collectionFieldName)}.push(...state.${camelCase(child.collectionFieldName)});`).join("\n");
 	return `${imports.join("\n")}
 
 export interface ${entityName}Props {
@@ -1746,8 +1906,11 @@ ${constructorAssignments}
 		rehydrationStateName,
 		children: entity.children ?? []
 	})}(state);
-    const instance = new ${entityName}(state.${camelCase(idField)}, state as unknown as ${entityName}Props);
-${entityFromPersistenceAssignment}
+    const props: ${entityName}Props = {
+${entityFromPersistenceProps}
+    };
+    const instance = new ${entityName}(state.${camelCase(idField)}, props);
+${entityCollectionAssignments}
     return instance;
   }
 }
@@ -2059,7 +2222,7 @@ function listQuerySortFieldTypeName$1(query) {
 function listQueryRowTypeName$1(query) {
 	return `${listQueryTypeBaseName$1(query)}Row`;
 }
-function readModelContractName$3(readModelName) {
+function readModelContractName$2(readModelName) {
 	const baseName = pascalCase(readModelName);
 	return baseName.endsWith("View") ? baseName : `${baseName}View`;
 }
@@ -2069,8 +2232,11 @@ function readModelPortBaseFileName(readModelName) {
 function resolvedReadModelName$2(query) {
 	return query.readSide?.readModelName ?? query.readModelName ?? query.name;
 }
+function queryOutputExportName$1(query) {
+	return query.outputSchemaExportName?.trim() || void 0;
+}
 function queryReadModelPortTypeName$1(query) {
-	return `${readModelContractName$3(resolvedReadModelName$2(query))}RepositoryPort`;
+	return `${readModelContractName$2(resolvedReadModelName$2(query))}RepositoryPort`;
 }
 function queryReadModelPortFileName(query) {
 	return `read-models/${readModelPortBaseFileName(resolvedReadModelName$2(query))}.repository.port.ts`;
@@ -2130,11 +2296,11 @@ ${query.outputFields.map((f) => {
 function createListQueryHandlerStub(_spec, query) {
 	const handlerName = `${pascalCase(query.name)}Handler`;
 	const queryTypeName = `${pascalCase(query.name)}Query`;
-	const outputContractName = queryOutputContractName$2(query);
+	const outputContractName = queryOutputContractName$1(query);
 	const readModelPortType = queryReadModelPortTypeName$1(query);
 	const readModelVariable = queryReadModelVariableName$1(query);
 	const readModelMethodName = queryReadModelMethodName$1(query);
-	const viewFileBase = queryViewFileBase$2(query);
+	const viewFileBase = queryViewFileBase$1(query);
 	return `import type { ${queryTypeName} } from "./${kebabCase(query.name)}.query.ts";
 import type { ${outputContractName} } from "../contracts/${viewFileBase}.view.ts";
 import type { ${readModelPortType} } from "../ports/${queryReadModelPortFileName(query)}";
@@ -2162,12 +2328,14 @@ function createHandlerDepsStub(spec) {
 	const repoPort = findRepositoryPort(spec);
 	const repoTypeName = repoPort ? repositoryPortTypeName(repoPort.name) : `${aggregatePascal}Repository`;
 	return `import type { Transaction } from "../../../../lib/transaction.ts";
+import type { AggregateEventTracker } from "../../../shared-kernel/events/aggregate-event-tracker.ts";
 import type { EventCollector } from "../../../shared-kernel/events/event-collector.ts";
 import type { ${repoTypeName} } from "./ports/${repoPort ? repositoryPortFileName(repoPort.name) : `${kebabCase(spec.aggregate.name)}-repository.port.ts`}";
 
 export type ${contextPascal}CommandHandlerDeps = {
   tx: Transaction;
   eventCollector: EventCollector;
+  aggregateEventTracker: AggregateEventTracker;
   repos: {
     ${aggregateVar}s: ${repoTypeName};
   };
@@ -2193,7 +2361,7 @@ ${(query.inputFields ?? []).map((f) => {
 `;
 }
 function createViewContractStub(query) {
-	return `export interface ${queryOutputContractName$2(query)} {
+	return `export interface ${queryOutputContractName$1(query)} {
 ${query.outputFields.map((f) => {
 		const opt = f.optional ? "?" : "";
 		return `  readonly ${camelCase(f.name)}${opt}: ${formatFieldType(f)};`;
@@ -2201,11 +2369,14 @@ ${query.outputFields.map((f) => {
 }
 `;
 }
-function queryOutputContractName$2(query) {
-	const baseName = pascalCase(resolvedReadModelName$2(query));
-	return baseName.endsWith("View") ? baseName : `${baseName}View`;
+function queryOutputContractName$1(query) {
+	const outputExportName = queryOutputExportName$1(query);
+	if (outputExportName) return pascalCase(outputExportName);
+	return readModelContractName$2(resolvedReadModelName$2(query));
 }
-function queryViewFileBase$2(query) {
+function queryViewFileBase$1(query) {
+	const outputExportName = queryOutputExportName$1(query);
+	if (outputExportName) return kebabCase(outputExportName).replace(/-view$/, "");
 	return kebabCase(resolvedReadModelName$2(query)).replace(/-view$/, "");
 }
 function createCommandStub(spec, command) {
@@ -2254,7 +2425,8 @@ function buildCreateHandlerBody(spec, command) {
 		const assignedValue = createPropAssignments.get(fieldName) ?? (commandInputFieldNames.has(fieldName) ? commandInputField?.optional && !field.optional ? `command.payload.${fieldName} ?? ${defaultValue}` : `command.payload.${fieldName}` : defaultValue);
 		if (assignedValue !== void 0) propsLines.push(`      ${fieldName}: ${assignedValue},`);
 	}
-	const idTypeName = hasCustomIdType ? pascalCase(idType) : `BrandedId<"string">`;
+	const defaultIdBrand = `${pascalCase(spec.aggregate.name)}Id`;
+	const idTypeName = hasCustomIdType ? pascalCase(idType) : `BrandedId<"${defaultIdBrand}">`;
 	const creationEventName = command.emits?.[0];
 	const creationEvent = creationEventName ? spec.domainEvents.find((e) => pascalCase(e.name) === pascalCase(creationEventName)) : void 0;
 	const aggregateFieldNames = new Set((spec.aggregate.fields ?? []).map((field) => camelCase(field.name)));
@@ -2285,7 +2457,7 @@ function buildCreateHandlerBody(spec, command) {
 		const payloadName = `${pascalCase(creationEventName)}Payload`;
 		imports.push(`import type { ${payloadName} } from "../../domain/events/${kebabCase(creationEventName)}.event.ts";`);
 	}
-	const idExpr = hasCustomIdType ? `create${pascalCase(idType)}(crypto.randomUUID())` : `createBrandedId("${idType || "string"}", crypto.randomUUID())`;
+	const idExpr = hasCustomIdType ? `create${pascalCase(idType)}(crypto.randomUUID())` : `createBrandedId("${hasCustomIdType ? idType : defaultIdBrand}", crypto.randomUUID())`;
 	let creationEventLines = "";
 	if (creationEvent) {
 		const payloadName = `${pascalCase(creationEventName)}Payload`;
@@ -2304,7 +2476,7 @@ function buildCreateHandlerBody(spec, command) {
 			else if (fieldName === "recordedBy" || fieldName === "correlationId" || fieldName === "causationId") {
 				const metadataExpr = fieldName === "recordedBy" ? f.type === "string" ? "eventContext.recordedBy.value" : "eventContext.recordedBy" : `eventContext.${fieldName}`;
 				payloadFields.push(`      ${fieldName}: ${metadataExpr},`);
-			} else payloadFields.push(`      ${fieldName}: undefined as unknown as ${payloadName}["${fieldName}"],`);
+			} else payloadFields.push(`      ${fieldName}: /* TODO: unmapped ${payloadName} field "${fieldName}" */ undefined as never,`);
 		}
 		creationEventLines = `
   deps.eventCollector.collect([
@@ -2381,7 +2553,7 @@ function buildMutationHandlerBody(spec, command) {
 	}
 	imports.push(`import type { ${notFoundErrorType} } from "../../domain/errors/${aggregateDir}-application-errors.ts";`);
 	if (hasCustomIdType && idCreatorFn && idType) imports.push(`import { ${idCreatorFn} } from "../../../../shared-kernel/entity-ids/${kebabCase(idType)}.ts";`);
-	const domainMethodArg = cmdEmitsEvents ? "command.payload as any, eventContext" : "command.payload as any";
+	const domainMethodArg = cmdEmitsEvents ? "command.payload, eventContext" : "command.payload";
 	const loadByField = command.loadBy?.startsWith("input.") ? command.loadBy.slice(6) : aggregateId;
 	const brandedIdExpr = hasCustomIdType && idCreatorFn ? `${idCreatorFn}(command.payload.${loadByField})` : `command.payload.${loadByField}`;
 	let bodyLines;
@@ -2393,7 +2565,7 @@ function buildMutationHandlerBody(spec, command) {
 		`  const result = ${aggregateVar}.${methodName}(${domainMethodArg});`,
 		`  if (!result.ok) return result;`,
 		`  await deps.repos.${camelCase(spec.aggregate.name)}s.save(${aggregateVar}, loadedVersion, deps.tx);`,
-		`  deps.eventCollector.collect(${aggregateVar}.pullDomainEvents());`,
+		`  deps.aggregateEventTracker.track(${aggregateVar});`,
 		`  return ok(undefined);`
 	];
 	else bodyLines = [
@@ -2403,7 +2575,7 @@ function buildMutationHandlerBody(spec, command) {
 		`  const loadedVersion = ${aggregateVar}.version;`,
 		`  ${aggregateVar}.${methodName}(${domainMethodArg});`,
 		`  await deps.repos.${camelCase(spec.aggregate.name)}s.save(${aggregateVar}, loadedVersion, deps.tx);`,
-		`  deps.eventCollector.collect(${aggregateVar}.pullDomainEvents());`,
+		`  deps.aggregateEventTracker.track(${aggregateVar});`,
 		`  return ok(undefined);`
 	];
 	const handlerErrorTypeExport = hasPreconditions ? `export type ${handlerErrorType} =\n  | ${errorTypes.join("\n  | ")};\n` : `export type ${handlerErrorType} = ${notFoundErrorType};\n`;
@@ -2436,11 +2608,14 @@ export async function ${handlerFnName}(
   command: ${commandTypeName},
   deps: ${depsTypeName},
   eventContext: EventContext,
-): Promise<void> {
+): Promise<never> {
   void command;
   void deps;
   void eventContext;
-  // TODO: load aggregate, execute domain operation, save, pull events
+  throw new Error(
+    "[application_generator] Command \\"${spec.context.name}.${command.name}\\" cannot be fully generated. " +
+      "Expected a create command with effects or a mutation command with both effects and loadBy.",
+  );
 }
 `;
 }
@@ -2457,12 +2632,12 @@ export interface ${queryName} {
 }
 function buildQueryHandlerBody(_spec, query) {
 	const queryTypeName = `${pascalCase(query.name)}Query`;
-	const outputContractName = queryOutputContractName$2(query);
+	const outputContractName = queryOutputContractName$1(query);
 	const readModelPortType = queryReadModelPortTypeName$1(query);
 	const handlerName = `${pascalCase(query.name)}Handler`;
 	const readModelVariable = queryReadModelVariableName$1(query);
 	const readModelMethodName = queryReadModelMethodName$1(query);
-	const viewFileBase = queryViewFileBase$2(query);
+	const viewFileBase = queryViewFileBase$1(query);
 	return `import type { ${queryTypeName} } from "./${kebabCase(query.name)}.query.ts";
 import type { ${outputContractName} } from "../contracts/${viewFileBase}.view.ts";
 import type { ${readModelPortType} } from "../ports/${queryReadModelPortFileName(query)}";
@@ -2483,12 +2658,12 @@ export class ${handlerName} {
 function createQueryHandlerStub(_spec, query) {
 	if (query.outputFields && query.outputFields.length > 0) return buildQueryHandlerBody(_spec, query);
 	const queryTypeName = `${pascalCase(query.name)}Query`;
-	const outputContractName = queryOutputContractName$2(query);
+	const outputContractName = queryOutputContractName$1(query);
 	const readModelPortType = queryReadModelPortTypeName$1(query);
 	const handlerName = `${pascalCase(query.name)}Handler`;
 	const readModelVariable = queryReadModelVariableName$1(query);
 	const readModelMethodName = queryReadModelMethodName$1(query);
-	const viewFileBase = queryViewFileBase$2(query);
+	const viewFileBase = queryViewFileBase$1(query);
 	return `import type { ${queryTypeName} } from "./${kebabCase(query.name)}.query.ts";
 import type { ${outputContractName} } from "../contracts/${viewFileBase}.view.ts";
 import type { ${readModelPortType} } from "../ports/${queryReadModelPortFileName(query)}";
@@ -2551,46 +2726,71 @@ function groupQueriesByReadModel$1(queries) {
 	}));
 }
 function createReadModelRepositoryPortStub(readModelName, queries) {
-	const portTypeName = `${readModelContractName$3(readModelName)}RepositoryPort`;
+	const portTypeName = `${readModelContractName$2(readModelName)}RepositoryPort`;
 	const importLines = /* @__PURE__ */ new Map();
 	let needsPaginatedResult = false;
-	importLines.set("tx", `import type { Transaction } from "../../../../../lib/transaction.ts";`);
+	importLines.set("tx", `import type { Transaction } from "../../../../../../lib/transaction.ts";`);
 	const queryMethodLines = queries.slice().sort((left, right) => left.name.localeCompare(right.name)).map((query) => {
 		const queryTypeName = `${pascalCase(query.name)}Query`;
-		const outputContractName = queryOutputContractName$2(query);
-		const viewFileBase = queryViewFileBase$2(query);
+		const outputContractName = queryOutputContractName$1(query);
+		const viewFileBase = queryViewFileBase$1(query);
 		const returnType = query.queryKind === "list" ? `PaginatedResult<${outputContractName}>` : outputContractName;
 		if (query.queryKind === "list") needsPaginatedResult = true;
-		importLines.set(`query:${queryTypeName}`, `import type { ${queryTypeName} } from "../queries/${kebabCase(query.name)}.query.ts";`);
-		importLines.set(`view:${outputContractName}`, `import type { ${outputContractName} } from "../contracts/${viewFileBase}.view.ts";`);
+		importLines.set(`query:${queryTypeName}`, `import type { ${queryTypeName} } from "../../queries/${kebabCase(query.name)}.query.ts";`);
+		importLines.set(`view:${outputContractName}`, `import type { ${outputContractName} } from "../../contracts/${viewFileBase}.view.ts";`);
 		return `  ${queryReadModelMethodName$1(query)}(query: ${queryTypeName}, tx: Transaction): Promise<${returnType}>;`;
 	});
-	if (needsPaginatedResult) importLines.set("pagination", `import type { PaginatedResult } from "../../../../../lib/pagination.ts";`);
+	if (needsPaginatedResult) importLines.set("pagination", `import type { PaginatedResult } from "../../../../../../lib/pagination.ts";`);
 	return `${[...importLines.values()].join("\n")}
 
 // Read-model repository port. Query handlers share this contract by read-model, not by query.
 export interface ${portTypeName} {
-  // Query methods
 ${queryMethodLines.join("\n")}
-
-  // Projector methods
-  // TODO: add typed row write methods when projector/repository generation lands.
-
-  // Rebuild methods
-  // TODO: add rebuild helpers when projection rebuild scaffolding lands.
 }
 `;
 }
 function createReadModelPortsIndexStub(queries) {
 	return `${groupQueriesByReadModel$1(queries).map(({ readModelName }) => {
-		return `export type { ${`${readModelContractName$3(readModelName)}RepositoryPort`} } from "./${readModelPortBaseFileName(readModelName)}.repository.port.ts";`;
+		return `export type { ${`${readModelContractName$2(readModelName)}RepositoryPort`} } from "./${readModelPortBaseFileName(readModelName)}.repository.port.ts";`;
 	}).join("\n")}\n`;
 }
+function projectionWritePortName$2(projectionName) {
+	return `${pascalCase(projectionName)}WritePort`;
+}
+function projectionWritePortFileName(projectionName) {
+	return `${kebabCase(projectionName)}.projection-write.port.ts`;
+}
+function projectionSourcePayloadTypeName$1(source) {
+	return `${pascalCase(source.eventName)}Payload`;
+}
+function projectionSourcePayloadImportPath$1(source) {
+	return `../../../${normalizeModulePath(source.contextName)}/domain/events/${kebabCase(source.eventName)}.event.ts`;
+}
+function projectionSourceEventType$1(source) {
+	const payloadType = projectionSourcePayloadTypeName$1(source);
+	return `EventEnvelope<${payloadType}> | ${payloadType}`;
+}
+function createProjectionWritePortStub(projection) {
+	const payloadImports = projection.sources.slice().sort((left, right) => left.eventName.localeCompare(right.eventName)).map((source) => `import type { ${projectionSourcePayloadTypeName$1(source)} } from "${projectionSourcePayloadImportPath$1(source)}";`);
+	const methodLines = projection.sources.slice().sort((left, right) => left.eventName.localeCompare(right.eventName)).map((source) => `  on${pascalCase(source.eventName)}(event: ${projectionSourceEventType$1(source)}, tx: Transaction): Promise<void>;`);
+	return `import type { EventEnvelope } from "../../../../../../lib/event-envelope.ts";
+import type { Transaction } from "../../../../../../lib/transaction.ts";
+${payloadImports.join("\n")}
+
+// Projector-facing write port for the "${projection.readModelName}" read model.
+export interface ${projectionWritePortName$2(projection.name)} {
+${methodLines.join("\n")}
+}
+`;
+}
+function createProjectionWritePortsIndexStub(projections) {
+	return `${projections.slice().sort((left, right) => left.name.localeCompare(right.name)).map((projection) => `export type { ${projectionWritePortName$2(projection.name)} } from "./${projectionWritePortFileName(projection.name)}";`).join("\n")}\n`;
+}
 function inputContractFileName(commandOrQueryName) {
 	return `${kebabCase(commandOrQueryName)}.input`;
 }
 function viewContractFileName(query) {
-	return `${kebabCase(resolvedReadModelName$2(query)).replace(/-view$/, "")}.view`;
+	return `${queryViewFileBase$1(query)}.view`;
 }
 function createHandlerMapStub(spec) {
 	const contextPascal = pascalCase(spec.context.name);
@@ -2613,7 +2813,11 @@ ${mapEntries.join("\n")}
 }
 function createContextHandlerDepsStub(contextSpec) {
 	const contextPascal = pascalCase(contextSpec.context.name);
-	const importLines = [`import type { Transaction } from "../../../../lib/transaction.ts";`, `import type { EventCollector } from "../../../shared-kernel/events/event-collector.ts";`];
+	const importLines = [
+		`import type { Transaction } from "../../../../lib/transaction.ts";`,
+		`import type { AggregateEventTracker } from "../../../shared-kernel/events/aggregate-event-tracker.ts";`,
+		`import type { EventCollector } from "../../../shared-kernel/events/event-collector.ts";`
+	];
 	const repoEntries = [];
 	const aclEntries = [];
 	for (const agg of contextSpec.aggregates) {
@@ -2639,6 +2843,7 @@ ${aclEntries.join("\n")}
 export type ${contextPascal}CommandHandlerDeps = {
   tx: Transaction;
   eventCollector: EventCollector;
+  aggregateEventTracker: AggregateEventTracker;
   repos: {
 ${repoEntries.join("\n")}
   };
@@ -2682,9 +2887,9 @@ function createPublishedReadBoundaryStub(contextSpec) {
 		const queryHandlerName = `${pascalCase(query.name)}Handler`;
 		const handlerVarName = `${camelCase(query.name)}Handler`;
 		const queryTypeName = `${pascalCase(query.name)}Query`;
-		const outputContractName = queryOutputContractName$2(query);
+		const outputContractName = queryOutputContractName$1(query);
 		const queryFileName = kebabCase(query.name);
-		const outputFileName = queryViewFileBase$2(query);
+		const outputFileName = queryViewFileBase$1(query);
 		const readModelDepName = queryReadModelVariableName$1(query);
 		const readModelTypeName = queryReadModelPortTypeName$1(query);
 		imports.set(`handler:${queryHandlerName}`, `import { ${queryHandlerName} } from "./queries/${queryFileName}.handler.ts";`);
@@ -2766,16 +2971,25 @@ function buildV5ApplicationArtifacts(spec, options) {
 }
 function buildV5ApplicationContextArtifacts(contextSpec) {
 	const modulePath = normalizeModulePath(contextSpec.context.modulePath);
-	return [
+	const artifacts = [
 		createGeneratedArtifact(buildArtifactPath("core/contexts", modulePath, "application/ports/read-models/index.ts"), createReadModelPortsIndexStub(contextSpec.queries)),
 		createGeneratedArtifact(buildArtifactPath("core/contexts", modulePath, "application/handler-deps.ts"), createContextHandlerDepsStub(contextSpec)),
 		createGeneratedArtifact(buildArtifactPath("core/contexts", modulePath, "application/read-boundary.ts"), createPublishedReadBoundaryStub(contextSpec)),
 		createGeneratedArtifact(buildArtifactPath("core/contexts", modulePath, "application/handler-map.ts"), createContextHandlerMapStub(contextSpec))
 	];
+	const projections = contextSpec.projections ?? [];
+	if (projections.length > 0) {
+		artifacts.push(createGeneratedArtifact(buildArtifactPath("core/contexts", modulePath, "application/ports/projections/index.ts"), createProjectionWritePortsIndexStub(projections)));
+		for (const projection of projections) artifacts.push(createGeneratedArtifact(buildArtifactPath("core/contexts", modulePath, `application/ports/projections/${projectionWritePortFileName(projection.name)}`), createProjectionWritePortStub(projection)));
+	}
+	return artifacts;
 }
 
 //#endregion
 //#region packages/core/generators/infrastructure.ts
+function resolveDrizzlePersistence(infrastructureStrategy) {
+	return infrastructureStrategy?.persistence === "mysql" ? "mysql" : "postgres";
+}
 function isDecimalNumberField(field) {
 	if (field.type !== "number") return false;
 	const explicitColumnType = field.columnType?.toLowerCase();
@@ -2790,10 +3004,12 @@ function isDecimalNumberField(field) {
 	const fieldName = snakeCase(field.name);
 	return /(^|_)(cpk|ppk|ucl|lcl)(_|$)/.test(fieldName) || /(percent|percentage|ratio|rate|average|avg|variance|yield|scrap|drift)/.test(fieldName);
 }
-function drizzleColumnBuilder(field, columnName) {
+function drizzleColumnBuilder(field, columnName, persistence = "postgres") {
 	let builder;
-	if (field.array || field.type === "object" && field.nestedFields && field.nestedFields.length > 0) builder = `jsonb("${columnName}").$type<${formatTsFieldType(field)}>()`;
-	else switch (field.type) {
+	if (field.array || field.type === "object" && field.nestedFields && field.nestedFields.length > 0) {
+		const jsonType = formatTsFieldType(field);
+		builder = persistence === "mysql" ? `json("${columnName}").$type<${jsonType}>()` : `jsonb("${columnName}").$type<${jsonType}>()`;
+	} else switch (field.type) {
 		case "number":
 			builder = isDecimalNumberField(field) ? `real("${columnName}")` : `integer("${columnName}")`;
 			break;
@@ -2900,12 +3116,12 @@ function relativePrefixFromRepositoryDirectory(modulePath) {
 		...modulePath.split("/").filter(Boolean)
 	].map(() => "..").join("/");
 }
-function readModelContractName$2(readModelName) {
+function readModelContractName$1(readModelName) {
 	const baseName = pascalCase(readModelName);
 	return baseName.endsWith("View") ? baseName : `${baseName}View`;
 }
 function readModelRepositoryClassName(readModelName) {
-	return `Drizzle${readModelContractName$2(readModelName)}Repository`;
+	return `Drizzle${readModelContractName$1(readModelName)}Repository`;
 }
 function readModelRepositoryFileBase$1(readModelName) {
 	return kebabCase(readModelName).replace(/-view$/, "");
@@ -2913,13 +3129,29 @@ function readModelRepositoryFileBase$1(readModelName) {
 function readModelTableConstName(readModelName) {
 	return `${camelCase(readModelName)}Table`;
 }
+function mikroOrmRepositoryClassName(aggregateName) {
+	return `MikroOrm${pascalCase(aggregateName)}Repository`;
+}
+function mikroOrmEntityClassName(name) {
+	return `${pascalCase(name)}Record`;
+}
+function mikroOrmEntitySchemaConstName(name) {
+	return `${pascalCase(name)}Schema`;
+}
 function resolvedReadModelName$1(query) {
 	return query.readSide?.readModelName ?? query.readModelName ?? query.name;
 }
-function queryOutputContractName$1(query) {
-	return readModelContractName$2(resolvedReadModelName$1(query));
+function queryOutputExportName(query) {
+	return query.outputSchemaExportName?.trim() || void 0;
 }
-function queryViewFileBase$1(query) {
+function queryOutputContractName(query) {
+	const outputExportName = queryOutputExportName(query);
+	if (outputExportName) return pascalCase(outputExportName);
+	return readModelContractName$1(resolvedReadModelName$1(query));
+}
+function queryViewFileBase(query) {
+	const outputExportName = queryOutputExportName(query);
+	if (outputExportName) return kebabCase(outputExportName).replace(/-view$/, "");
 	return readModelRepositoryFileBase$1(resolvedReadModelName$1(query));
 }
 function queryReadModelMethodName(query) {
@@ -2947,13 +3179,13 @@ const RESERVED_AGGREGATE_FIELD_NAMES = new Set(["version"]);
 function filterManagedAggregateFields(fields) {
 	return fields.filter((field) => !RESERVED_AGGREGATE_FIELD_NAMES.has(camelCase(field.name)));
 }
-function buildTableBlock(tableName, tableConstName, fields, idField, fkColumn, isAggregateRoot = false) {
+function buildTableBlock(tableName, tableConstName, fields, idField, fkColumn, isAggregateRoot = false, persistence = "postgres") {
 	const columnDefs = [];
 	const emittedColumns = /* @__PURE__ */ new Set();
 	for (const field of fields) {
 		const snakeName = snakeCase(field.name);
 		if (emittedColumns.has(snakeName)) continue;
-		const columnDef = field.name === idField ? `text("${snakeName}").primaryKey()` : drizzleColumnBuilder(field, snakeName);
+		const columnDef = field.name === idField ? `text("${snakeName}").primaryKey()` : drizzleColumnBuilder(field, snakeName, persistence);
 		columnDefs.push(`  ${snakeName}: ${columnDef},`);
 		emittedColumns.add(snakeName);
 	}
@@ -2962,16 +3194,16 @@ function buildTableBlock(tableName, tableConstName, fields, idField, fkColumn, i
 		emittedColumns.add(fkColumn.name);
 	}
 	if (isAggregateRoot) columnDefs.push(`  version: integer("version").default(0).notNull(),`);
-	return `export const ${tableConstName} = pgTable("${tableName}", {\n${columnDefs.join("\n")}\n});`;
+	return `export const ${tableConstName} = ${persistence === "mysql" ? "mysqlTable" : "pgTable"}("${tableName}", {\n${columnDefs.join("\n")}\n});`;
 }
-function createDrizzleTableDefinition(spec) {
+function createDrizzleTableDefinition(spec, persistence = "postgres") {
 	const fields = filterManagedAggregateFields(spec.aggregate.fields);
 	if (!fields || fields.length === 0) return null;
 	const children = spec.aggregate.children ?? [];
 	const aggScalarFields = scalarFields(fields, children);
 	const emittedTableNames = /* @__PURE__ */ new Set();
 	const blocks = [];
-	blocks.push(buildTableBlock(spec.aggregate.tableName, `${camelCase(spec.aggregate.name)}Table`, aggScalarFields, spec.aggregate.idField, void 0, true));
+	blocks.push(buildTableBlock(spec.aggregate.tableName, `${camelCase(spec.aggregate.name)}Table`, aggScalarFields, spec.aggregate.idField, void 0, true, persistence));
 	emittedTableNames.add(spec.aggregate.tableName);
 	const aggregate = {
 		name: spec.aggregate.name,
@@ -2988,13 +3220,13 @@ function createDrizzleTableDefinition(spec) {
 		blocks.push(buildTableBlock(entity.tableName, `${camelCase(entity.name)}Table`, entityScalarFields, entity.idField, {
 			name: fkColName,
 			type: "text"
-		}));
+		}, false, persistence));
 		emittedTableNames.add(entity.tableName);
 	});
 	for (const entity of spec.entities ?? []) {
 		if (!entity.tableName || emittedTableNames.has(entity.tableName)) continue;
 		const entityScalarFields = scalarFields(entity.fields, entity.children ?? []);
-		blocks.push(buildTableBlock(entity.tableName, `${camelCase(entity.name)}Table`, entityScalarFields, entity.idField));
+		blocks.push(buildTableBlock(entity.tableName, `${camelCase(entity.name)}Table`, entityScalarFields, entity.idField, void 0, false, persistence));
 		emittedTableNames.add(entity.tableName);
 	}
 	const flatScalarFields = [
@@ -3002,12 +3234,12 @@ function createDrizzleTableDefinition(spec) {
 		...flattenEntities(aggregate).map((entity) => scalarFields(entity.fields, entity.children)),
 		...(spec.entities ?? []).map((entity) => scalarFields(entity.fields, entity.children ?? []))
 	].flat();
-	const pgCoreImportTokens = ["pgTable", "text"];
-	if (flatScalarFields.some((field) => field.type === "number" && !isDecimalNumberField(field))) pgCoreImportTokens.push("integer");
-	if (flatScalarFields.some((field) => isDecimalNumberField(field))) pgCoreImportTokens.push("real");
-	if (flatScalarFields.some((field) => field.type === "boolean")) pgCoreImportTokens.push("boolean");
-	if (flatScalarFields.some((field) => field.array || field.type === "object" && field.nestedFields && field.nestedFields.length > 0)) pgCoreImportTokens.push("jsonb");
-	return `import { ${pgCoreImportTokens.join(", ")} } from "drizzle-orm/pg-core";\n\n${blocks.join("\n\n")}\n`;
+	const coreImportTokens = [persistence === "mysql" ? "mysqlTable" : "pgTable", "text"];
+	if (flatScalarFields.some((field) => field.type === "number" && !isDecimalNumberField(field))) coreImportTokens.push("integer");
+	if (flatScalarFields.some((field) => isDecimalNumberField(field))) coreImportTokens.push("real");
+	if (flatScalarFields.some((field) => field.type === "boolean")) coreImportTokens.push("boolean");
+	if (flatScalarFields.some((field) => field.array || field.type === "object" && field.nestedFields && field.nestedFields.length > 0)) coreImportTokens.push(persistence === "mysql" ? "json" : "jsonb");
+	return `import { ${coreImportTokens.join(", ")} } from "${persistence === "mysql" ? "drizzle-orm/mysql-core" : "drizzle-orm/pg-core"}";\n\n${blocks.join("\n\n")}\n`;
 }
 function buildCodecBlock(_spec, entityName, fields, options) {
 	const varName = camelCase(entityName);
@@ -3078,6 +3310,280 @@ function createPersistenceEqualityBlock(name, fields, options) {
 	return `// Compiled from zx.deepEqual.writeable at generator time using the canonical ${pascalCase(name)} persistence row shape.
 export const ${equalityName} = ${compiledEquality};`;
 }
+function buildMikroOrmRootNode(spec) {
+	const buildChild = (entity, parent) => {
+		const node = {
+			name: entity.name,
+			className: mikroOrmEntityClassName(entity.name),
+			schemaConstName: mikroOrmEntitySchemaConstName(entity.name),
+			fields: entity.fields,
+			scalarFields: scalarFields(entity.fields, entity.children),
+			idField: entity.idField,
+			idType: entity.idType,
+			tableName: entity.tableName,
+			collectionFieldName: entity.collectionFieldName,
+			parent: {
+				className: parent.className,
+				propertyName: camelCase(parent.name),
+				fkFieldName: snakeCase(parent.idField)
+			},
+			children: [],
+			isAggregateRoot: false
+		};
+		node.children = (entity.children ?? []).map((child) => buildChild(child, node));
+		return node;
+	};
+	const rootNode = {
+		name: spec.aggregate.name,
+		className: mikroOrmEntityClassName(spec.aggregate.name),
+		schemaConstName: mikroOrmEntitySchemaConstName(spec.aggregate.name),
+		fields: filterManagedAggregateFields(spec.aggregate.fields),
+		scalarFields: scalarFields(filterManagedAggregateFields(spec.aggregate.fields), spec.aggregate.children ?? []),
+		idField: spec.aggregate.idField,
+		idType: spec.aggregate.idType,
+		tableName: spec.aggregate.tableName,
+		children: [],
+		isAggregateRoot: true
+	};
+	rootNode.children = (spec.aggregate.children ?? []).map((child) => buildChild(child, rootNode));
+	return rootNode;
+}
+function flattenMikroOrmNodes(rootNode) {
+	const nodes = [rootNode];
+	const queue = [...rootNode.children];
+	while (queue.length > 0) {
+		const node = queue.shift();
+		nodes.push(node);
+		queue.push(...node.children);
+	}
+	return nodes;
+}
+function mikroOrmClassFieldType(field) {
+	if (field.type === "object" && field.nestedFields && field.nestedFields.length > 0) return formatTsFieldType(field);
+	switch (field.type) {
+		case "number": return field.array ? "number[]" : "number";
+		case "boolean": return field.array ? "boolean[]" : "boolean";
+		default: return field.array ? "string[]" : "string";
+	}
+}
+function mikroOrmPropertyType(field) {
+	if (field.array || field.type === "object" && field.nestedFields && field.nestedFields.length > 0) return "json";
+	switch (field.type) {
+		case "number": return "number";
+		case "boolean": return "boolean";
+		default: return "string";
+	}
+}
+function createMikroOrmEntitySchemaArtifactContent(spec) {
+	const nodes = flattenMikroOrmNodes(buildMikroOrmRootNode(spec));
+	const contextPrefix = pascalCase(spec.context.name);
+	const imports = [`import { Cascade, EntitySchema${nodes.some((node) => node.children.length > 0) ? ", Collection" : ""} } from "@mikro-orm/core";`];
+	const classBlocks = nodes.map((node) => {
+		const lines = [`export class ${node.className} {`];
+		for (const field of node.scalarFields) lines.push(`  ${camelCase(field.name)}${field.optional ? "?" : "!"}: ${mikroOrmClassFieldType(field)};`);
+		if (node.isAggregateRoot) lines.push(`  version!: number;`);
+		if (node.parent) lines.push(`  ${node.parent.propertyName}!: ${node.parent.className};`);
+		for (const child of node.children) {
+			const collectionName = camelCase(child.collectionFieldName ?? `${child.name}s`);
+			lines.push(`  ${collectionName} = new Collection<${child.className}>(this);`);
+		}
+		lines.push(`}`);
+		return lines.join("\n");
+	});
+	const schemaBlocks = nodes.map((node) => {
+		const propertyLines = [];
+		for (const field of node.scalarFields) {
+			const options = [`type: "${mikroOrmPropertyType(field)}"`, `fieldName: "${snakeCase(field.name)}"`];
+			if (camelCase(field.name) === camelCase(node.idField)) options.push(`primary: true`);
+			if (field.optional) options.push(`nullable: true`);
+			propertyLines.push(`    ${camelCase(field.name)}: { ${options.join(", ")} },`);
+		}
+		if (node.isAggregateRoot) propertyLines.push(`    version: { type: "number", fieldName: "version" },`);
+		if (node.parent) propertyLines.push(`    ${node.parent.propertyName}: { kind: "m:1", entity: () => ${node.parent.className}, fieldName: "${node.parent.fkFieldName}" },`);
+		for (const child of node.children) {
+			const collectionName = camelCase(child.collectionFieldName ?? `${child.name}s`);
+			propertyLines.push(`    ${collectionName}: { kind: "1:m", entity: () => ${child.className}, mappedBy: "${child.parent?.propertyName}", cascade: [Cascade.PERSIST, Cascade.REMOVE], orphanRemoval: true },`);
+		}
+		return `export const ${node.schemaConstName} = new EntitySchema<${node.className}>({
+  name: "${contextPrefix}${node.className}",
+  class: ${node.className},
+  tableName: "${node.tableName}",
+  properties: {
+${propertyLines.join("\n")}
+  },
+});`;
+	});
+	return `${imports.join("\n")}
+
+${classBlocks.join("\n\n")}
+
+${schemaBlocks.join("\n\n")}
+
+export const ${camelCase(spec.aggregate.name)}MikroOrmEntities = [${nodes.map((node) => node.schemaConstName).join(", ")}] as const;
+`;
+}
+function serializeDomainFieldValue(field, sourceExpr) {
+	if (field.type === "date" || field.type === "Date") return `${sourceExpr} instanceof Date ? ${sourceExpr}.toISOString() : String(${sourceExpr})`;
+	return sourceExpr;
+}
+function deserializePersistenceFieldValue(field, sourceExpr) {
+	if (field.type === "date" || field.type === "Date") return `${sourceExpr} ? new Date(${sourceExpr}) : ${sourceExpr}`;
+	return sourceExpr;
+}
+function rehydrateIdExpression(node, sourceExpr) {
+	if (node.idType && node.idType !== "string") return `create${pascalCase(node.idType)}(${sourceExpr})`;
+	return `createBrandedId("string", ${sourceExpr})`;
+}
+function buildMikroOrmNodeHelperBlock(spec, node) {
+	const domainTypeName = node.isAggregateRoot ? `${pascalCase(spec.aggregate.name)}Aggregate` : pascalCase(node.name);
+	const domainVar = "source";
+	const recordVar = "target";
+	const scalarAssignmentLines = node.scalarFields.map((field) => {
+		const propertyName = camelCase(field.name);
+		return `  ${recordVar}.${propertyName} = ${camelCase(field.name) === camelCase(node.idField) ? `String(${domainVar}.id.value)` : serializeDomainFieldValue(field, `${domainVar}.${propertyName}`)};`;
+	});
+	if (node.isAggregateRoot) scalarAssignmentLines.push(`  ${recordVar}.version = ${domainVar}.version;`);
+	const createChildLines = node.children.map((child) => {
+		const collectionName = camelCase(child.collectionFieldName ?? `${child.name}s`);
+		return `  ${recordVar}.${collectionName}.set(${domainVar}.${collectionName}.map((item) => create${child.className}FromDomain(item, ${recordVar})));`;
+	});
+	const syncChildLines = node.children.map((child) => {
+		const collectionName = camelCase(child.collectionFieldName ?? `${child.name}s`);
+		const childIdField = camelCase(child.idField);
+		return `  {
+    const currentById = new Map(${recordVar}.${collectionName}.getItems().map((item: ${child.className}) => [String(item.${childIdField}), item] as const));
+    const nextItems = ${domainVar}.${collectionName}.map((item) => {
+      const existing = currentById.get(String(item.id.value));
+      if (existing) {
+        sync${child.className}FromDomain(existing, item, ${recordVar});
+        return existing;
+      }
+      return create${child.className}FromDomain(item, ${recordVar});
+    });
+    ${recordVar}.${collectionName}.set(nextItems);
+  }`;
+	});
+	const parentParam = node.parent ? `, parent: ${node.parent.className}` : "";
+	const parentAssignment = node.parent ? `  record.${node.parent.propertyName} = parent;\n` : "";
+	const parentSyncParam = node.parent ? `, parent?: ${node.parent.className}` : "";
+	const parentSyncAssignment = node.parent ? `  if (parent) {\n    ${recordVar}.${node.parent.propertyName} = parent;\n  }\n` : "";
+	const domainScalarLines = node.scalarFields.map((field) => {
+		const propertyName = camelCase(field.name);
+		return `    ${propertyName}: ${camelCase(field.name) === camelCase(node.idField) ? rehydrateIdExpression(node, `${recordVar}.${propertyName}`) : deserializePersistenceFieldValue(field, `${recordVar}.${propertyName}`)},`;
+	});
+	if (node.isAggregateRoot) domainScalarLines.push(`    version: ${recordVar}.version,`);
+	for (const child of node.children) {
+		const collectionName = camelCase(child.collectionFieldName ?? `${child.name}s`);
+		domainScalarLines.push(`    ${collectionName}: ${recordVar}.${collectionName}.getItems().map((item: ${child.className}) => map${child.className}ToDomain(item)),`);
+	}
+	return `function create${node.className}FromDomain(source: ${domainTypeName}${parentParam}): ${node.className} {
+  const record = new ${node.className}();
+${parentAssignment}${scalarAssignmentLines.join("\n")}
+${createChildLines.join("\n")}
+  return record;
+}
+
+function sync${node.className}FromDomain(target: ${node.className}, source: ${domainTypeName}${parentSyncParam}): void {
+${parentSyncAssignment}${scalarAssignmentLines.join("\n")}
+${syncChildLines.join("\n")}
+}
+
+function map${node.className}ToDomain(target: ${node.className}): ${domainTypeName} {
+  return ${domainTypeName}.fromPersistence({
+${domainScalarLines.join("\n")}
+  });
+}`;
+}
+function createMikroOrmRepository(spec, portName) {
+	const modulePath = normalizeModulePath(spec.context.modulePath);
+	const relativePrefix = relativePrefixFromRepositoryDirectory(modulePath);
+	const aggregateName = pascalCase(spec.aggregate.name);
+	const aggregateDir = kebabCase(spec.aggregate.name);
+	const repositoryPortType = repositoryPortTypeName(portName);
+	const repositoryClassName = mikroOrmRepositoryClassName(spec.aggregate.name);
+	const rootNode = buildMikroOrmRootNode(spec);
+	const nodes = flattenMikroOrmNodes(rootNode);
+	const needsBrandedIdHelper = nodes.some((node) => !node.idType || node.idType === "string");
+	const customIdImports = /* @__PURE__ */ new Map();
+	for (const node of nodes) if (node.idType && node.idType !== "string") customIdImports.set(node.idType, `import { create${pascalCase(node.idType)} } from "${relativePrefix}/core/shared-kernel/entity-ids/${kebabCase(node.idType)}";`);
+	const notFoundError = (spec.aggregate.applicationErrors ?? [])[0];
+	const notFoundImports = notFoundError ? (() => {
+		const typeName = `${pascalCase(notFoundError.aggregateName)}NotFoundError`;
+		return `import { ${notFoundError.factoryName}, type ${typeName} } from "${relativePrefix}/core/contexts/${modulePath}/domain/errors/${aggregateDir}-application-errors";\n`;
+	})() : "";
+	const notFoundTypeName = notFoundError ? `${pascalCase(notFoundError.aggregateName)}NotFoundError` : "Error";
+	const notFoundFactory = notFoundError?.factoryName ?? "createNotFoundError";
+	const rootIdParamName = `${camelCase(spec.aggregate.name)}Id`;
+	const rootIdTypeName = rootNode.idType && rootNode.idType !== "string" ? pascalCase(rootNode.idType) : "string";
+	const populatePaths = nodes.filter((node) => !node.isAggregateRoot).map((node) => {
+		const segments = [];
+		let current = node;
+		while (current && !current.isAggregateRoot) {
+			segments.unshift(camelCase(current.collectionFieldName ?? current.name));
+			current = current.parent ? nodes.find((candidate) => candidate.className === current.parent?.className) : void 0;
+		}
+		return segments.join(".");
+	}).filter((value, index, array) => value.length > 0 && array.indexOf(value) === index).sort();
+	return `import type { Result } from "${relativePrefix}/lib/result";
+import { ok, err } from "${relativePrefix}/lib/result";
+import type { Transaction } from "${relativePrefix}/lib/transaction";
+import { ConcurrencyConflictError } from "${relativePrefix}/lib/concurrency-conflict-error";
+import type { ${repositoryPortType} } from "${relativePrefix}/core/contexts/${modulePath}/application/ports/${kebabCase(portName)}.port";
+${needsBrandedIdHelper ? `import { createBrandedId } from "${relativePrefix}/lib/branded-id";\n` : ""}${[...customIdImports.values()].join("\n")}${customIdImports.size > 0 ? "\n" : ""}${notFoundImports}import { ${aggregateName}Aggregate } from "${relativePrefix}/core/contexts/${modulePath}/domain/aggregates/${aggregateDir}/${aggregateDir}.aggregate";
+${nodes.filter((node) => !node.isAggregateRoot).map((node) => `import { ${pascalCase(node.name)}Entity as ${pascalCase(node.name)} } from "${relativePrefix}/core/contexts/${modulePath}/domain/entities/${kebabCase(node.name)}.entity";`).join("\n")}${nodes.some((node) => !node.isAggregateRoot) ? "\n" : ""}import { ${nodes.map((node) => node.className).join(", ")} } from "../../entities/${modulePath}/${kebabCase(spec.aggregate.name)}.entity-schema.ts";
+
+const TOUCHED_AGGREGATES_KEY = "__zodmireTouchedAggregates";
+
+function markTouchedAggregate(tx: unknown, aggregateType: string, aggregateId: string): void {
+  const runtimeTx = tx as Record<string, unknown>;
+  const touched = (runtimeTx[TOUCHED_AGGREGATES_KEY] ??= new Map<string, Set<string>>()) as Map<string, Set<string>>;
+  const ids = touched.get(aggregateType) ?? new Set<string>();
+  ids.add(aggregateId);
+  touched.set(aggregateType, ids);
+}
+
+${nodes.slice().reverse().map((node) => buildMikroOrmNodeHelperBlock(spec, node)).join("\n\n")}
+
+export class ${repositoryClassName} implements ${repositoryPortType} {
+  async findById(${rootIdParamName}: ${rootIdTypeName}, tx: Transaction): Promise<Result<${aggregateName}Aggregate, ${notFoundTypeName}>> {
+    const em = tx as any;
+    const record = await em.findOne(${rootNode.className}, { ${camelCase(rootNode.idField)}: ${rootNode.idType && rootNode.idType !== "string" ? `${rootIdParamName}.value` : rootIdParamName} }, { populate: ${populatePaths.length > 0 ? `[${populatePaths.map((path) => `"${path}"`).join(", ")}]` : "[]"} });
+    if (!record) {
+      return err(${notFoundFactory}(String(${rootNode.idType && rootNode.idType !== "string" ? `${rootIdParamName}.value` : rootIdParamName})));
+    }
+
+    return ok(map${rootNode.className}ToDomain(record));
+  }
+
+  async create(${camelCase(spec.aggregate.name)}: ${aggregateName}Aggregate, tx: Transaction): Promise<void> {
+    const em = tx as any;
+    const rootRecord = create${rootNode.className}FromDomain(${camelCase(spec.aggregate.name)});
+    markTouchedAggregate(tx, "${aggregateName}", String(${camelCase(spec.aggregate.name)}.id.value));
+    em.persist(rootRecord);
+    await em.flush();
+  }
+
+  async save(${camelCase(spec.aggregate.name)}: ${aggregateName}Aggregate, expectedVersion: number, tx: Transaction): Promise<void> {
+    const em = tx as any;
+    const current = await em.findOne(${rootNode.className}, { ${camelCase(rootNode.idField)}: String(${camelCase(spec.aggregate.name)}.id.value) }, { populate: ${populatePaths.length > 0 ? `[${populatePaths.map((path) => `"${path}"`).join(", ")}]` : "[]"} });
+
+    if (!current || current.version !== expectedVersion) {
+      throw new ConcurrencyConflictError({
+        aggregateType: "${aggregateName}",
+        aggregateId: String(${camelCase(spec.aggregate.name)}.id.value),
+        expectedVersion,
+        actualVersion: current?.version,
+      });
+    }
+
+    sync${rootNode.className}FromDomain(current, ${camelCase(spec.aggregate.name)});
+    markTouchedAggregate(tx, "${aggregateName}", String(${camelCase(spec.aggregate.name)}.id.value));
+    em.persist(current);
+    await em.flush();
+  }
+}
+`;
+}
 function childTableVar(spec, tableName) {
 	const child = (spec.aggregate.children ?? []).find((c) => c.tableName === tableName);
 	return child ? `${camelCase(child.name)}Table` : `${camelCase(tableName)}Table`;
@@ -3735,29 +4241,39 @@ function buildV5InfrastructureArtifacts(spec, options) {
 	const modulePath = normalizeModulePath(spec.context.modulePath);
 	const scopeKey = sliceArtifactOwnership(modulePath);
 	const artifacts = [];
-	if (!options?.skipContextWideArtifacts) {
-		const tableContent = createDrizzleTableDefinition(spec);
+	const hasDrizzleRepositoryAdapter = spec.adapters.some((adapter) => adapter.kind === "drizzle-repository");
+	spec.adapters.some((adapter) => adapter.kind === "mikroorm-repository");
+	if (!options?.skipContextWideArtifacts && hasDrizzleRepositoryAdapter) {
+		const tableContent = createDrizzleTableDefinition(spec, resolveDrizzlePersistence(options?.infrastructureStrategy));
 		if (tableContent !== null) {
 			const tableLogicalPath = `infrastructure/persistence/${modulePath}/tables.ts`;
 			artifacts.push(createGeneratedArtifact(tableLogicalPath, tableContent, scopeKey));
 		}
 	}
-	const repoArtifacts = spec.adapters.filter((adapter) => adapter.kind === "drizzle-repository").flatMap((adapter) => {
+	const repoArtifacts = spec.adapters.flatMap((adapter) => {
 		const port = spec.ports.find((p) => p.name === adapter.port);
 		if (port === void 0) return [];
-		const logicalPath = buildArtifactPath("infrastructure/persistence/drizzle/repositories", modulePath, `drizzle-${kebabCase(spec.aggregate.name)}.repository.ts`);
-		return [createGeneratedArtifact(buildArtifactPath("infrastructure/persistence/drizzle/repositories", modulePath, `${kebabCase(spec.aggregate.name)}.deep-equal.ts`), createPersistenceEqualityArtifactContent(spec), scopeKey), createGeneratedArtifact(logicalPath, createDrizzleRepositoryWithCodec(spec, port.name), scopeKey)];
+		if (adapter.kind === "drizzle-repository") {
+			const logicalPath = buildArtifactPath("infrastructure/persistence/drizzle/repositories", modulePath, `drizzle-${kebabCase(spec.aggregate.name)}.repository.ts`);
+			return [createGeneratedArtifact(buildArtifactPath("infrastructure/persistence/drizzle/repositories", modulePath, `${kebabCase(spec.aggregate.name)}.deep-equal.ts`), createPersistenceEqualityArtifactContent(spec), scopeKey), createGeneratedArtifact(logicalPath, createDrizzleRepositoryWithCodec(spec, port.name), scopeKey)];
+		}
+		if (adapter.kind === "mikroorm-repository") {
+			const schemaLogicalPath = buildArtifactPath("infrastructure/persistence/mikroorm/entities", modulePath, `${kebabCase(spec.aggregate.name)}.entity-schema.ts`);
+			const logicalPath = buildArtifactPath("infrastructure/persistence/mikroorm/repositories", modulePath, `mikroorm-${kebabCase(spec.aggregate.name)}.repository.ts`);
+			return [createGeneratedArtifact(schemaLogicalPath, createMikroOrmEntitySchemaArtifactContent(spec), scopeKey), createGeneratedArtifact(logicalPath, createMikroOrmRepository(spec, port.name), scopeKey)];
+		}
+		return [];
 	});
 	artifacts.push(...repoArtifacts);
 	return artifacts.sort((left, right) => left.logicalPath.localeCompare(right.logicalPath));
 }
-function createContextDrizzleTableDefinition(contextSpec) {
+function createContextDrizzleTableDefinition(contextSpec, persistence = "postgres") {
 	const blocks = [];
 	const emittedTableNames = /* @__PURE__ */ new Set();
 	let usesInteger = false;
 	let usesReal = false;
 	let usesBoolean = false;
-	let usesJsonb = false;
+	let usesJson = false;
 	for (const agg of contextSpec.aggregates) {
 		const fields = filterManagedAggregateFields(agg.fields);
 		if (!fields || fields.length === 0) continue;
@@ -3766,8 +4282,8 @@ function createContextDrizzleTableDefinition(contextSpec) {
 		if (aggScalarFields.some((field) => field.type === "number" && !isDecimalNumberField(field))) usesInteger = true;
 		if (aggScalarFields.some((field) => isDecimalNumberField(field))) usesReal = true;
 		if (aggScalarFields.some((field) => field.type === "boolean")) usesBoolean = true;
-		if (aggScalarFields.some((field) => field.array)) usesJsonb = true;
-		blocks.push(buildTableBlock(agg.tableName, `${camelCase(agg.name)}Table`, aggScalarFields, agg.idField, void 0, true));
+		if (aggScalarFields.some((field) => field.array)) usesJson = true;
+		blocks.push(buildTableBlock(agg.tableName, `${camelCase(agg.name)}Table`, aggScalarFields, agg.idField, void 0, true, persistence));
 		emittedTableNames.add(agg.tableName);
 		walkEntityTree({
 			name: agg.name,
@@ -3782,12 +4298,12 @@ function createContextDrizzleTableDefinition(contextSpec) {
 			if (entityScalarFields.some((field) => field.type === "number" && !isDecimalNumberField(field))) usesInteger = true;
 			if (entityScalarFields.some((field) => isDecimalNumberField(field))) usesReal = true;
 			if (entityScalarFields.some((field) => field.type === "boolean")) usesBoolean = true;
-			if (entityScalarFields.some((field) => field.array)) usesJsonb = true;
+			if (entityScalarFields.some((field) => field.array)) usesJson = true;
 			const fkColName = snakeCase("idField" in ctx.parent ? ctx.parent.idField : agg.idField);
 			blocks.push(buildTableBlock(entity.tableName, `${camelCase(entity.name)}Table`, entityScalarFields, entity.idField, {
 				name: fkColName,
 				type: "text"
-			}));
+			}, false, persistence));
 			emittedTableNames.add(entity.tableName);
 		});
 	}
@@ -3797,21 +4313,22 @@ function createContextDrizzleTableDefinition(contextSpec) {
 		if (entityScalarFields.some((field) => field.type === "number" && !isDecimalNumberField(field))) usesInteger = true;
 		if (entityScalarFields.some((field) => isDecimalNumberField(field))) usesReal = true;
 		if (entityScalarFields.some((field) => field.type === "boolean")) usesBoolean = true;
-		if (entityScalarFields.some((field) => field.array)) usesJsonb = true;
-		blocks.push(buildTableBlock(entity.tableName, `${camelCase(entity.name)}Table`, entityScalarFields, entity.idField));
+		if (entityScalarFields.some((field) => field.array)) usesJson = true;
+		blocks.push(buildTableBlock(entity.tableName, `${camelCase(entity.name)}Table`, entityScalarFields, entity.idField, void 0, false, persistence));
 		emittedTableNames.add(entity.tableName);
 	}
 	if (blocks.length === 0) return null;
-	const pgCoreImportTokens = ["pgTable", "text"];
-	if (usesInteger) pgCoreImportTokens.push("integer");
-	if (usesReal) pgCoreImportTokens.push("real");
-	if (usesBoolean) pgCoreImportTokens.push("boolean");
-	if (usesJsonb) pgCoreImportTokens.push("jsonb");
-	return `import { ${pgCoreImportTokens.join(", ")} } from "drizzle-orm/pg-core";\n\n${blocks.join("\n\n")}\n`;
-}
-function createReadModelTableDefinition(readModel) {
+	const coreImportTokens = [persistence === "mysql" ? "mysqlTable" : "pgTable", "text"];
+	if (usesInteger) coreImportTokens.push("integer");
+	if (usesReal) coreImportTokens.push("real");
+	if (usesBoolean) coreImportTokens.push("boolean");
+	if (usesJson) coreImportTokens.push(persistence === "mysql" ? "json" : "jsonb");
+	return `import { ${coreImportTokens.join(", ")} } from "${persistence === "mysql" ? "drizzle-orm/mysql-core" : "drizzle-orm/pg-core"}";\n\n${blocks.join("\n\n")}\n`;
+}
+function createReadModelTableDefinition(readModel, persistence = "postgres") {
+	const tableBuilder = persistence === "mysql" ? "mysqlTable" : "pgTable";
 	const importTokens = new Set([
-		"pgTable",
+		tableBuilder,
 		"primaryKey",
 		"text"
 	]);
@@ -3819,8 +4336,8 @@ function createReadModelTableDefinition(readModel) {
 		if (field.type === "number" && !isDecimalNumberField(field)) importTokens.add("integer");
 		if (isDecimalNumberField(field)) importTokens.add("real");
 		if (field.type === "boolean") importTokens.add("boolean");
-		if (field.array || field.type === "object" && field.nestedFields && field.nestedFields.length > 0) importTokens.add("jsonb");
-		return `  ${snakeCase(field.name)}: ${drizzleColumnBuilder(field, snakeCase(field.name))},`;
+		if (field.array || field.type === "object" && field.nestedFields && field.nestedFields.length > 0) importTokens.add(persistence === "mysql" ? "json" : "jsonb");
+		return `  ${snakeCase(field.name)}: ${drizzleColumnBuilder(field, snakeCase(field.name), persistence)},`;
 	});
 	if (readModel.indexes.length > 0) importTokens.add("index");
 	if (readModel.uniqueConstraints.length > 0) importTokens.add("uniqueIndex");
@@ -3829,9 +4346,9 @@ function createReadModelTableDefinition(readModel) {
 	for (const uniqueConstraint of readModel.uniqueConstraints) constraintLines.push(`    ${camelCase(uniqueConstraint.name)}: uniqueIndex("${uniqueConstraint.name}").on(${uniqueConstraint.fields.map((field) => `table.${snakeCase(field)}`).join(", ")}),`);
 	const tableConstName = readModelTableConstName(readModel.name);
 	const typeName = pascalCase(readModel.name);
-	return `import { ${[...importTokens].sort().join(", ")} } from "drizzle-orm/pg-core";
+	return `import { ${[...importTokens].sort().join(", ")} } from "${persistence === "mysql" ? "drizzle-orm/mysql-core" : "drizzle-orm/pg-core"}";
 
-export const ${tableConstName} = pgTable("${readModel.tableName}", {
+export const ${tableConstName} = ${tableBuilder}("${readModel.tableName}", {
 ${columnLines.join("\n")}
 }, (table) => ({
 ${constraintLines.join("\n")}
@@ -3876,22 +4393,139 @@ function buildReadModelCompositionArtifacts(contextSpecs) {
 	};
 	return [createGeneratedArtifact("infrastructure/view-models/drizzle/schema.ts", schemaContent, ownership), createGeneratedArtifact("infrastructure/view-models/drizzle/schema.manifest.json", `${JSON.stringify(manifest, null, 2)}\n`, ownership)];
 }
-function buildV5InfrastructureContextArtifacts(contextSpec) {
+function projectionWriterClassName(projectionName) {
+	const baseName = pascalCase(projectionName);
+	return `MikroOrm${baseName.endsWith("Projection") ? baseName : `${baseName}Projection`}Writer`;
+}
+function drizzleProjectionWriterClassName(projectionName) {
+	const baseName = pascalCase(projectionName);
+	return `Drizzle${baseName.endsWith("Projection") ? baseName : `${baseName}Projection`}Writer`;
+}
+function projectionWritePortName$1(projectionName) {
+	return `${pascalCase(projectionName)}WritePort`;
+}
+function projectionWritePortImportPath(modulePath, projectionName) {
+	return `../../../../../core/contexts/${modulePath}/application/ports/projections/${kebabCase(projectionName)}.projection-write.port.ts`;
+}
+function projectionWriterPayloadTypeName(source) {
+	return `${pascalCase(source.eventName)}Payload`;
+}
+function projectionWriterPayloadImportPath(source) {
+	return `../../../../../core/contexts/${normalizeModulePath(source.contextName)}/domain/events/${kebabCase(source.eventName)}.event.ts`;
+}
+function projectionWriterEventType(source) {
+	const payloadType = projectionWriterPayloadTypeName(source);
+	return `EventEnvelope<${payloadType}> | ${payloadType}`;
+}
+function buildProjectionWriterMethod(readModel, source, executorVariable, executorExpression, persistence = "postgres") {
+	const methodName = `on${pascalCase(source.eventName)}`;
+	const eventType = projectionWriterEventType(source);
+	const payloadLine = `    const payload = (((event as any)?.payload ?? event) ?? {}) as Record<string, unknown>;`;
+	const executorLine = `    const ${executorVariable} = ${executorExpression};`;
+	if (source.mutation.kind === "delete") {
+		const whereClause = source.mutation.matchOn.map((field) => `${snakeCase(field)} = ?`).join(" and ");
+		const deleteParams = source.mutation.matchOn.map((field) => `payload.${field}`).join(", ");
+		return `  async ${methodName}(event: ${eventType}, tx: Transaction): Promise<void> {
+${payloadLine}
+${executorLine}
+    await ${executorVariable}.execute(
+      ${JSON.stringify(`delete from ${readModel.tableName} where ${whereClause}`)},
+      [${deleteParams}],
+    );
+  }`;
+	}
+	const setEntries = Object.entries(source.mutation.set ?? {});
+	const insertColumns = setEntries.map(([fieldName]) => snakeCase(fieldName));
+	const insertParams = setEntries.map(([, mapping]) => buildProjectionMutationValueExpression(mapping));
+	const conflictColumns = source.mutation.matchOn.map((field) => snakeCase(field));
+	const updateAssignments = persistence === "mysql" ? insertColumns.map((column) => `${column} = values(${column})`) : insertColumns.map((column) => `${column} = excluded.${column}`);
+	if (source.mutation.kind === "upsert") {
+		const upsertClause = persistence === "mysql" ? `on duplicate key update ${updateAssignments.join(", ")}` : `on conflict (${conflictColumns.join(", ")}) do update set ${updateAssignments.join(", ")}`;
+		return `  async ${methodName}(event: ${eventType}, tx: Transaction): Promise<void> {
+${payloadLine}
+${executorLine}
+    await ${executorVariable}.execute(
+      ${JSON.stringify(`insert into ${readModel.tableName} (${insertColumns.join(", ")}) values (${insertColumns.map(() => "?").join(", ")}) ${upsertClause}`)},
+      [${insertParams.join(", ")}],
+    );
+  }`;
+	}
+	const updateAssignmentsSql = insertColumns.map((column) => `${column} = ?`).join(", ");
+	const whereClause = source.mutation.matchOn.map((field) => `${snakeCase(field)} = ?`).join(" and ");
+	const whereParams = source.mutation.matchOn.map((field) => `payload.${field}`);
+	return `  async ${methodName}(event: ${eventType}, tx: Transaction): Promise<void> {
+${payloadLine}
+${executorLine}
+    await ${executorVariable}.execute(
+      ${JSON.stringify(`update ${readModel.tableName} set ${updateAssignmentsSql} where ${whereClause}`)},
+      [${[...insertParams, ...whereParams].join(", ")}],
+    );
+  }`;
+}
+function buildProjectionMutationValueExpression(mapping) {
+	if (mapping.kind === "event-field") return `payload.${mapping.field}`;
+	if (mapping.kind === "literal") return JSON.stringify(mapping.value);
+	return `(${mapping.expression})`;
+}
+function createMikroOrmProjectionWriterArtifact(modulePath, projection, readModel, persistence = "postgres") {
+	const className = projectionWriterClassName(projection.name);
+	const writePortName = projectionWritePortName$1(projection.name);
+	const payloadImports = projection.sources.slice().sort((left, right) => left.eventName.localeCompare(right.eventName)).map((source) => `import type { ${projectionWriterPayloadTypeName(source)} } from "${projectionWriterPayloadImportPath(source)}";`);
+	const methodBlocks = projection.sources.slice().sort((left, right) => left.eventName.localeCompare(right.eventName)).map((source) => buildProjectionWriterMethod(readModel, source, "connection", "(tx as any).getConnection()", persistence)).join("\n\n");
+	return createGeneratedArtifact(`infrastructure/persistence/mikroorm/projection-writers/${modulePath}/${kebabCase(projection.name)}.projection-writer.ts`, `import type { EventEnvelope } from "../../../../../lib/event-envelope.ts";
+import type { Transaction } from "../../../../../lib/transaction.ts";
+import type { ${writePortName} } from "${projectionWritePortImportPath(modulePath, projection.name)}";
+${payloadImports.join("\n")}
+
+// Generated tx-scoped MikroORM projection writer for "${projection.readModelName}".
+export class ${className} implements ${writePortName} {
+${methodBlocks}
+}
+`, sliceArtifactOwnership(modulePath));
+}
+function createDrizzleProjectionWriterArtifact(modulePath, projection, readModel, persistence = "postgres") {
+	const className = drizzleProjectionWriterClassName(projection.name);
+	const writePortName = projectionWritePortName$1(projection.name);
+	const payloadImports = projection.sources.slice().sort((left, right) => left.eventName.localeCompare(right.eventName)).map((source) => `import type { ${projectionWriterPayloadTypeName(source)} } from "${projectionWriterPayloadImportPath(source)}";`);
+	const methodBlocks = projection.sources.slice().sort((left, right) => left.eventName.localeCompare(right.eventName)).map((source) => buildProjectionWriterMethod(readModel, source, "executor", "tx as any", persistence)).join("\n\n");
+	return createGeneratedArtifact(`infrastructure/persistence/drizzle/projection-writers/${modulePath}/${kebabCase(projection.name)}.projection-writer.ts`, `import type { EventEnvelope } from "../../../../../lib/event-envelope.ts";
+import type { Transaction } from "../../../../../lib/transaction.ts";
+import type { ${writePortName} } from "${projectionWritePortImportPath(modulePath, projection.name)}";
+${payloadImports.join("\n")}
+
+// Generated tx-scoped Drizzle projection writer for "${projection.readModelName}".
+export class ${className} implements ${writePortName} {
+${methodBlocks}
+}
+`, sliceArtifactOwnership(modulePath));
+}
+function buildV5InfrastructureContextArtifacts(contextSpec, options = {}) {
 	const modulePath = normalizeModulePath(contextSpec.context.modulePath);
 	const scopeKey = sliceArtifactOwnership(modulePath);
 	const artifacts = [];
 	const readModels = contextSpec.readModels ?? [];
-	const tableContent = createContextDrizzleTableDefinition(contextSpec);
+	const tableContent = createContextDrizzleTableDefinition(contextSpec, resolveDrizzlePersistence(options.infrastructureStrategy));
 	if (tableContent !== null) artifacts.push(createGeneratedArtifact(`infrastructure/persistence/${modulePath}/tables.ts`, tableContent, scopeKey));
 	if (readModels.length > 0) {
-		for (const readModel of readModels.slice().sort((left, right) => left.name.localeCompare(right.name))) artifacts.push(createGeneratedArtifact(`infrastructure/view-models/${modulePath}/drizzle/tables/${readModelRepositoryFileBase$1(readModel.name)}.table.ts`, createReadModelTableDefinition(readModel), scopeKey));
+		for (const readModel of readModels.slice().sort((left, right) => left.name.localeCompare(right.name))) artifacts.push(createGeneratedArtifact(`infrastructure/view-models/${modulePath}/drizzle/tables/${readModelRepositoryFileBase$1(readModel.name)}.table.ts`, createReadModelTableDefinition(readModel, resolveDrizzlePersistence(options.infrastructureStrategy)), scopeKey));
 		artifacts.push(createGeneratedArtifact(`infrastructure/view-models/${modulePath}/drizzle/schema.ts`, createReadModelContextSchemaBarrel({
 			...contextSpec,
 			readModels
 		}), scopeKey));
 		artifacts.push(createGeneratedArtifact(`infrastructure/view-models/${modulePath}/tables.ts`, createReadModelCompatibilityBarrel(), scopeKey));
 	} else artifacts.push(createGeneratedArtifact(`infrastructure/view-models/${modulePath}/tables.ts`, createViewModelTablesSkeleton(contextSpec), scopeKey));
-	for (const { readModelName, queries } of groupQueriesByReadModel(contextSpec.queries)) artifacts.push(createGeneratedArtifact(`infrastructure/view-models/drizzle/repositories/${modulePath}/${readModelRepositoryFileBase$1(readModelName)}.repository.ts`, createReadModelRepositorySkeleton(modulePath, readModelName, queries), scopeKey));
+	for (const { readModelName, queries } of groupQueriesByReadModel(contextSpec.queries)) artifacts.push(createGeneratedArtifact(`infrastructure/view-models/drizzle/repositories/${modulePath}/${readModelRepositoryFileBase$1(readModelName)}.repository.ts`, createReadModelRepositoryContent(modulePath, readModelName, queries, readModels, options.infrastructureStrategy), scopeKey));
+	const projections = contextSpec.projections ?? [];
+	if (options.infrastructureStrategy?.orm === "mikroorm") for (const projection of projections) {
+		const readModel = readModels.find((candidate) => candidate.name === projection.readModelName);
+		if (!readModel) continue;
+		artifacts.push(createMikroOrmProjectionWriterArtifact(modulePath, projection, readModel, resolveDrizzlePersistence(options.infrastructureStrategy)));
+	}
+	else if (options.infrastructureStrategy?.orm === "drizzle") for (const projection of projections) {
+		const readModel = readModels.find((candidate) => candidate.name === projection.readModelName);
+		if (!readModel) throw new Error(`[infrastructure_generator] Projection "${projection.name}" cannot be fully generated because read-model "${projection.readModelName}" was not found.`);
+		artifacts.push(createDrizzleProjectionWriterArtifact(modulePath, projection, readModel, resolveDrizzlePersistence(options.infrastructureStrategy)));
+	}
 	return artifacts;
 }
 function createViewModelTablesSkeleton(contextSpec) {
@@ -3906,7 +4540,7 @@ function createViewModelTablesSkeleton(contextSpec) {
 	for (const { readModelName, queries } of groupQueriesByReadModel(contextSpec.queries)) {
 		lines.push(`  ${camelCase(readModelName)}: {`);
 		lines.push(`    readModel: "${readModelName}",`);
-		lines.push(`    contract: "${readModelContractName$2(readModelName)}",`);
+		lines.push(`    contract: "${readModelContractName$1(readModelName)}",`);
 		lines.push(`    servesQueries: [${queries.map((query) => `"${query.name}"`).join(", ")}],`);
 		lines.push(`    suggestedTableName: "${snakeCase(modulePath).replaceAll("/", "_")}_${snakeCase(readModelRepositoryFileBase$1(readModelName))}",`);
 		lines.push(`  },`);
@@ -3915,40 +4549,33 @@ function createViewModelTablesSkeleton(contextSpec) {
 	lines.push(``);
 	return lines.join("\n");
 }
+function createReadModelRepositoryContent(modulePath, readModelName, queries, readModels, infrastructureStrategy) {
+	if (!supportsGeneratedReadModelQueries(infrastructureStrategy)) return createReadModelRepositorySkeleton(modulePath, readModelName, queries);
+	const readModel = readModels.find((candidate) => candidate.name === readModelName);
+	if (!readModel) return createReadModelRepositorySkeleton(modulePath, readModelName, queries);
+	return createSupportedReadModelRepository(modulePath, readModel, queries);
+}
+function supportsGeneratedReadModelQueries(infrastructureStrategy) {
+	if (!infrastructureStrategy) return true;
+	return (infrastructureStrategy.architecture === "physical-cqrs" || infrastructureStrategy.architecture === "logical-cqrs") && (infrastructureStrategy.persistence === "postgres" || infrastructureStrategy.persistence === "mysql");
+}
 function createReadModelRepositorySkeleton(modulePath, readModelName, queries) {
 	const className = readModelRepositoryClassName(readModelName);
-	const portTypeName = `${readModelContractName$2(readModelName)}RepositoryPort`;
+	const portTypeName = `${readModelContractName$1(readModelName)}RepositoryPort`;
 	const fileBase = readModelRepositoryFileBase$1(readModelName);
 	const importLines = /* @__PURE__ */ new Map();
 	let needsPaginatedResult = false;
 	importLines.set("tx", `import type { Transaction } from "../../../../../lib/transaction.ts";`);
 	importLines.set("port", `import type { ${portTypeName} } from "../../../../../core/contexts/${modulePath}/application/ports/read-models/${fileBase}.repository.port.ts";`);
 	const methodBlocks = queries.slice().sort((left, right) => left.name.localeCompare(right.name)).map((query) => {
-		const methodName = queryReadModelMethodName(query);
+		queryReadModelMethodName(query);
 		const queryTypeName = `${pascalCase(query.name)}Query`;
-		const outputTypeName = queryOutputContractName$1(query);
-		const viewFileBase = queryViewFileBase$1(query);
+		const outputTypeName = queryOutputContractName(query);
+		const viewFileBase = queryViewFileBase(query);
 		importLines.set(`query:${queryTypeName}`, `import type { ${queryTypeName} } from "../../../../../core/contexts/${modulePath}/application/queries/${kebabCase(query.name)}.query.ts";`);
 		importLines.set(`view:${outputTypeName}`, `import type { ${outputTypeName} } from "../../../../../core/contexts/${modulePath}/application/contracts/${viewFileBase}.view.ts";`);
-		if (query.queryKind === "list") {
-			needsPaginatedResult = true;
-			return `  async ${methodName}(query: ${queryTypeName}, tx: Transaction): Promise<PaginatedResult<${outputTypeName}>> {
-    void this.db;
-    void tx;
-    const { page = 1, pageSize = 20 } = query.payload;
-    return { items: [], total: 0, page, pageSize };
-  }`;
-		}
-		return `  async ${methodName}(query: ${queryTypeName}, tx: Transaction): Promise<${outputTypeName}> {
-    void this.db;
-    void query;
-    void tx;
-    return {
-${query.outputFields.map((field) => {
-			return `      ${camelCase(field.name)}: ${placeholderValueForField(field)}, // TODO: map from projection row`;
-		}).join("\n")}
-    };
-  }`;
+		if (query.queryKind === "list") needsPaginatedResult = true;
+		return createSingleReadModelMethodSkeleton(query, readModelName);
 	});
 	if (needsPaginatedResult) importLines.set("pagination", `import type { PaginatedResult } from "../../../../../lib/pagination.ts";`);
 	return `${[...importLines.values()].join("\n")}
@@ -3961,76 +4588,273 @@ ${methodBlocks.join("\n\n")}
 }
 `;
 }
+function createSupportedReadModelRepository(modulePath, readModel, queries) {
+	const className = readModelRepositoryClassName(readModel.name);
+	const portTypeName = `${readModelContractName$1(readModel.name)}RepositoryPort`;
+	const fileBase = readModelRepositoryFileBase$1(readModel.name);
+	const importLines = /* @__PURE__ */ new Map();
+	const drizzleImports = /* @__PURE__ */ new Set();
+	let needsPaginatedResult = false;
+	let needsSqlType = false;
+	let needsTableImport = false;
+	importLines.set("tx", `import type { Transaction } from "../../../../../lib/transaction.ts";`);
+	importLines.set("port", `import type { ${portTypeName} } from "../../../../../core/contexts/${modulePath}/application/ports/read-models/${fileBase}.repository.port.ts";`);
+	const methodBlocks = queries.slice().sort((left, right) => left.name.localeCompare(right.name)).map((query) => {
+		const queryTypeName = `${pascalCase(query.name)}Query`;
+		const outputTypeName = queryOutputContractName(query);
+		const viewFileBase = queryViewFileBase(query);
+		importLines.set(`query:${queryTypeName}`, `import type { ${queryTypeName} } from "../../../../../core/contexts/${modulePath}/application/queries/${kebabCase(query.name)}.query.ts";`);
+		importLines.set(`view:${outputTypeName}`, `import type { ${outputTypeName} } from "../../../../../core/contexts/${modulePath}/application/contracts/${viewFileBase}.view.ts";`);
+		const generatedMethod = createGeneratedReadModelMethod(readModel, query, drizzleImports);
+		if (generatedMethod !== null) {
+			needsTableImport = true;
+			if (query.queryKind === "list") {
+				needsPaginatedResult = true;
+				needsSqlType = needsSqlType || generatedMethod.includes("SQL[]");
+			}
+			return generatedMethod;
+		}
+		if (query.queryKind === "list") needsPaginatedResult = true;
+		return createSingleReadModelMethodSkeleton(query, readModel.name);
+	});
+	if (needsTableImport) importLines.set("table", `import { ${readModelTableConstName(readModel.name)} } from "../../../${modulePath}/drizzle/tables/${fileBase}.table.ts";`);
+	if (drizzleImports.size > 0) importLines.set("drizzle", `import { ${[...drizzleImports].sort().join(", ")} } from "drizzle-orm";`);
+	if (needsSqlType) importLines.set("sql", `import type { SQL } from "drizzle-orm";`);
+	if (needsPaginatedResult) importLines.set("pagination", `import type { PaginatedResult } from "../../../../../lib/pagination.ts";`);
+	return `${[...importLines.values()].join("\n")}
 
-//#endregion
-//#region packages/core/generators/projections.ts
-function readModelContractName$1(readModelName) {
-	const baseName = pascalCase(readModelName);
-	return baseName.endsWith("View") ? baseName : `${baseName}View`;
-}
-function readModelRepositoryPortName(readModelName) {
-	return `${readModelContractName$1(readModelName)}RepositoryPort`;
+// Generated read-model repository for the supported infrastructure strategy.
+export class ${className} implements ${portTypeName} {
+  constructor(private readonly db: unknown) {}
+
+${methodBlocks.join("\n\n")}
 }
-function readModelRepositoryPortFileBase(readModelName) {
-	return kebabCase(readModelName).replace(/-view$/, "");
+`;
 }
-function projectionFileBase(projectionName) {
-	return kebabCase(projectionName);
+function createGeneratedReadModelMethod(readModel, query, drizzleImports) {
+	if (!canMapReadModelOutput(readModel, query.outputFields)) return null;
+	if (query.queryKind === "findById") {
+		const lookupField = resolveFindByIdLookupField(readModel, query);
+		if (!lookupField) return null;
+		drizzleImports.add("eq");
+		return createFindByIdReadModelMethod(readModel, query, lookupField);
+	}
+	drizzleImports.add("asc");
+	drizzleImports.add("count");
+	drizzleImports.add("desc");
+	const filterData = buildReadModelFilterData(readModel, query, readModelTableConstName(readModel.name));
+	if (filterData.lines.length > 0) drizzleImports.add("and");
+	for (const drizzleImport of filterData.imports) drizzleImports.add(drizzleImport);
+	return createListReadModelMethod(readModel, query, filterData.lines);
+}
+function canMapReadModelOutput(readModel, outputFields) {
+	const readModelFields = new Set(readModel.fields.map((field) => camelCase(field.name)));
+	return outputFields.every((field) => readModelFields.has(camelCase(field.name)));
+}
+function resolveFindByIdLookupField(readModel, query) {
+	if (readModel.primaryKey.length !== 1) return null;
+	const primaryKeyField = camelCase(readModel.primaryKey[0]);
+	const matchingField = query.inputFields.find((field) => camelCase(field.name) === primaryKeyField);
+	if (matchingField) return camelCase(matchingField.name);
+	if (query.inputFields.length === 1) return camelCase(query.inputFields[0].name);
+	return null;
 }
-function projectionVariableName(projectionName) {
-	return camelCase(projectionName);
+function createFindByIdReadModelMethod(readModel, query, lookupField) {
+	const methodName = queryReadModelMethodName(query);
+	const queryTypeName = `${pascalCase(query.name)}Query`;
+	const outputTypeName = queryOutputContractName(query);
+	const tableConstName = readModelTableConstName(readModel.name);
+	return `  async ${methodName}(query: ${queryTypeName}, tx: Transaction): Promise<${outputTypeName}> {
+    void this.db;
+    const rows = await tx.select()
+      .from(${tableConstName})
+      .where(eq(${tableConstName}.${snakeCase(readModel.primaryKey[0])}, query.payload.${lookupField}))
+      .limit(1);
+
+    const row = rows[0];
+    if (!row) {
+      throw new Error("${outputTypeName} row not found");
+    }
+
+    return {
+${buildReadModelOutputMapping(query.outputFields, "row")}
+    };
+  }`;
+}
+function createListReadModelMethod(readModel, query, filterLines) {
+	const methodName = queryReadModelMethodName(query);
+	const queryTypeName = `${pascalCase(query.name)}Query`;
+	const outputTypeName = queryOutputContractName(query);
+	const tableConstName = readModelTableConstName(readModel.name);
+	const payloadDestructure = filterLines.length > 0 ? `page = 1, pageSize = 20, filters, sortBy, sortDirection` : `page = 1, pageSize = 20, sortBy, sortDirection`;
+	const whereBlock = filterLines.length > 0 ? `    const conditions: SQL[] = [];
+${filterLines.join("\n")}
+
+    const where = conditions.length > 0 ? and(...conditions) : undefined;` : `    const where = undefined;`;
+	const sortFieldEntries = query.sorting.sortableFields.filter((field) => readModel.fields.some((candidate) => camelCase(candidate.name) === camelCase(field))).map((field) => `      ${camelCase(field)}: ${tableConstName}.${snakeCase(field)},`);
+	const defaultSortField = camelCase(query.sorting.defaultSort.field);
+	return `  async ${methodName}(query: ${queryTypeName}, tx: Transaction): Promise<PaginatedResult<${outputTypeName}>> {
+    void this.db;
+    const { ${payloadDestructure} } = query.payload;
+
+${whereBlock}
+    const sortColumn = (({
+${sortFieldEntries.join("\n")}
+    } as Record<string, unknown>)[sortBy ?? "${defaultSortField}"] ?? ${tableConstName}.${snakeCase(query.sorting.defaultSort.field)}) as import("drizzle-orm").AnyColumn;
+    const orderBy = sortDirection === "desc"
+      ? [desc(sortColumn)]
+      : [asc(sortColumn)];
+
+    const [rows, countResult] = await Promise.all([
+      tx.select()
+        .from(${tableConstName})
+        .where(where)
+        .orderBy(...orderBy)
+        .limit(pageSize)
+        .offset((page - 1) * pageSize),
+      tx.select({ count: count() }).from(${tableConstName}).where(where),
+    ]);
+
+    return {
+      items: rows.map((row) => ({
+${buildReadModelOutputMapping(query.outputFields, "row")}
+      })),
+      total: Number(countResult[0]?.count ?? 0),
+      page,
+      pageSize,
+    };
+  }`;
+}
+function buildReadModelFilterData(readModel, query, tableConstName) {
+	const readModelFields = new Set(readModel.fields.map((field) => camelCase(field.name)));
+	const lines = [];
+	const imports = /* @__PURE__ */ new Set();
+	for (const [field, operators] of Object.entries(query.filters)) {
+		const normalizedField = camelCase(field);
+		if (!readModelFields.has(normalizedField)) continue;
+		const columnRef = `${tableConstName}.${snakeCase(field)}`;
+		for (const operator of operators) switch (operator) {
+			case "eq":
+				imports.add("eq");
+				lines.push(`    if (filters?.${normalizedField}?.eq != null) conditions.push(eq(${columnRef}, filters.${normalizedField}.eq));`);
+				break;
+			case "in":
+				imports.add("inArray");
+				lines.push(`    if (filters?.${normalizedField}?.in) conditions.push(inArray(${columnRef}, filters.${normalizedField}.in));`);
+				break;
+			case "gt":
+				imports.add("gt");
+				lines.push(`    if (filters?.${normalizedField}?.gt != null) conditions.push(gt(${columnRef}, filters.${normalizedField}.gt));`);
+				break;
+			case "gte":
+				imports.add("gte");
+				lines.push(`    if (filters?.${normalizedField}?.gte != null) conditions.push(gte(${columnRef}, filters.${normalizedField}.gte));`);
+				break;
+			case "lt":
+				imports.add("lt");
+				lines.push(`    if (filters?.${normalizedField}?.lt != null) conditions.push(lt(${columnRef}, filters.${normalizedField}.lt));`);
+				break;
+			case "lte":
+				imports.add("lte");
+				lines.push(`    if (filters?.${normalizedField}?.lte != null) conditions.push(lte(${columnRef}, filters.${normalizedField}.lte));`);
+				break;
+			case "contains":
+				imports.add("like");
+				lines.push(`    if (filters?.${normalizedField}?.contains) conditions.push(like(${columnRef}, \`%\${filters.${normalizedField}.contains}%\`));`);
+				break;
+			case "startsWith":
+				imports.add("like");
+				lines.push(`    if (filters?.${normalizedField}?.startsWith) conditions.push(like(${columnRef}, \`\${filters.${normalizedField}.startsWith}%\`));`);
+				break;
+		}
+	}
+	return {
+		lines,
+		imports
+	};
+}
+function buildReadModelOutputMapping(outputFields, rowVar) {
+	return outputFields.map((field) => {
+		const outputField = camelCase(field.name);
+		const rowField = snakeCase(field.name);
+		return `        ${outputField}: ${field.optional ? `${rowVar}.${rowField} ?? undefined` : `${rowVar}.${rowField}`},`;
+	}).join("\n");
+}
+function createSingleReadModelMethodSkeleton(query, readModelName) {
+	const methodName = queryReadModelMethodName(query);
+	const queryTypeName = `${pascalCase(query.name)}Query`;
+	const outputTypeName = queryOutputContractName(query);
+	const targetName = readModelName ?? resolvedReadModelName$1(query);
+	if (query.queryKind === "list") return `  async ${methodName}(query: ${queryTypeName}, tx: Transaction): Promise<PaginatedResult<${outputTypeName}>> {
+    void this.db;
+    void tx;
+    throw new Error(
+      "[infrastructure_generator] Query \\"${query.name}\\" for read-model \\"${targetName}\\" cannot be fully generated. " +
+        "Ensure output fields map directly to read-model fields and list-query metadata is fully declared.",
+    );
+  }`;
+	return `  async ${methodName}(query: ${queryTypeName}, tx: Transaction): Promise<${outputTypeName}> {
+    void this.db;
+    void query;
+    void tx;
+    throw new Error(
+      "[infrastructure_generator] Query \\"${query.name}\\" for read-model \\"${targetName}\\" cannot be fully generated. " +
+        "Ensure output fields map directly to read-model fields and findById queries resolve a stable lookup field.",
+    );
+  }`;
+}
+
+//#endregion
+//#region packages/core/generators/projections.ts
+function projectionWritePortName(projectionName) {
+	return `${pascalCase(projectionName)}WritePort`;
+}
+function projectionWritePortVariableName(projectionName) {
+	return camelCase(projectionWritePortName(projectionName));
 }
-function readModelRepositoryVariableName(readModelName) {
-	return camelCase(readModelRepositoryPortName(readModelName));
+function projectionFileBase(projectionName) {
+	return kebabCase(projectionName);
+}
+function projectionVariableName(projectionName) {
+	return camelCase(projectionName);
 }
 function projectionSourceHandlerName(eventName) {
 	return `on${pascalCase(eventName)}`;
 }
+function projectionSourcePayloadTypeName(source) {
+	return `${pascalCase(source.eventName)}Payload`;
+}
+function projectionSourcePayloadImportPath(currentModulePath, source) {
+	return `../../${normalizeModulePath(source.contextName)}/domain/events/${kebabCase(source.eventName)}.event.ts`;
+}
+function projectionSourceEventType(source) {
+	const payloadType = projectionSourcePayloadTypeName(source);
+	return `EventEnvelope<${payloadType}> | ${payloadType}`;
+}
 function buildProjectionSourceMethod(projection, source) {
 	const methodName = projectionSourceHandlerName(source.eventName);
 	const roleComment = source.role === "primary" ? `// Primary source: this event defines row lifecycle for the "${projection.readModelName}" read model.` : `// Enrichment source: update existing rows only; this event must not redefine ownership.`;
-	if (source.mutation.kind === "custom") return `  async ${methodName}(event: unknown, tx: Transaction): Promise<void> {
-    return await this.${source.mutation.handlerName}(event, tx);
-  }
-
-  protected async ${source.mutation.handlerName}(event: unknown, tx: Transaction): Promise<void> {
-    void this.${readModelRepositoryVariableName(projection.readModelName)};
-    void event;
-    void tx;
-    ${roleComment}
-    // Custom projection hook "${source.mutation.handlerName}" for ${source.contextName}.${source.aggregateName}.${source.eventName}.
-    // TODO: implement custom projector logic against the generated read-model repository port.
-  }`;
-	const setFields = source.mutation.kind === "delete" ? "" : Object.entries(source.mutation.set ?? {}).map(([fieldName, valueSource]) => {
-		if (valueSource.kind === "event-field") return `    //   ${fieldName} <- event.${valueSource.field}`;
-		if (valueSource.kind === "literal") return `    //   ${fieldName} <- ${JSON.stringify(valueSource.value)}`;
-		return `    //   ${fieldName} <- ${valueSource.expression}`;
-	}).join("\n");
-	const matchOnComment = `"${source.mutation.matchOn.join("\", \"")}"`;
-	return `  async ${methodName}(event: unknown, tx: Transaction): Promise<void> {
-    void this.${readModelRepositoryVariableName(projection.readModelName)};
-    void event;
-    void tx;
+	return `  async ${methodName}(event: ${projectionSourceEventType(source)}, tx: Transaction): Promise<void> {
     ${roleComment}
-    // Mutation kind: ${source.mutation.kind}
-    // Match on: [${matchOnComment}]
-${setFields}
-    // TODO: call generated projector-facing repository methods when write helpers land.
+    return await this.${projectionWritePortVariableName(projection.name)}.${methodName}(event, tx);
   }`;
 }
 function buildProjectorArtifact(modulePath, projection) {
 	const projectorClassName = projection.name;
-	const repositoryPortName = readModelRepositoryPortName(projection.readModelName);
-	const repositoryPortVar = readModelRepositoryVariableName(projection.readModelName);
+	const writePortName = projectionWritePortName(projection.name);
+	const writePortVar = projectionWritePortVariableName(projection.name);
 	const fileBase = projectionFileBase(projection.name);
+	const payloadImports = projection.sources.slice().sort((left, right) => left.eventName.localeCompare(right.eventName)).map((source) => `import type { ${projectionSourcePayloadTypeName(source)} } from "${projectionSourcePayloadImportPath(modulePath, source)}";`);
 	const methods = projection.sources.slice().sort((left, right) => left.eventName.localeCompare(right.eventName)).map((source) => buildProjectionSourceMethod(projection, source)).join("\n\n");
-	return createGeneratedArtifact(`core/contexts/${modulePath}/application/projections/${fileBase}.projector.ts`, `import type { Transaction } from "../../../../lib/transaction.ts";
-import type { ${repositoryPortName} } from "../ports/read-models/${readModelRepositoryPortFileBase(projection.readModelName)}.repository.port.ts";
+	return createGeneratedArtifact(`core/contexts/${modulePath}/application/projections/${fileBase}.projector.ts`, `import type { EventEnvelope } from "../../../../../lib/event-envelope.ts";
+import type { Transaction } from "../../../../../lib/transaction.ts";
+import type { ${writePortName} } from "../ports/projections/${projectionFileBase(projection.name)}.projection-write.port.ts";
+${payloadImports.join("\n")}
 
 // Auto-generated projector skeleton for the "${projection.readModelName}" read model.
 export class ${projectorClassName} {
   constructor(
-    private readonly ${repositoryPortVar}: ${repositoryPortName},
+    private readonly ${writePortVar}: ${writePortName},
   ) {}
 
 ${methods}
@@ -4043,20 +4867,53 @@ function buildProjectionRebuildArtifact(modulePath, projection) {
 	const projectorClassName = projection.name;
 	const rebuildFunctionName = `rebuild${pascalCase(projection.name)}`;
 	const batchSize = projection.rebuild.batchSize ?? 500;
-	return createGeneratedArtifact(`core/contexts/${modulePath}/application/projections/${fileBase}.rebuild.ts`, `import type { Transaction } from "../../../../lib/transaction.ts";
+	return createGeneratedArtifact(`core/contexts/${modulePath}/application/projections/${fileBase}.rebuild.ts`, `import type { Transaction } from "../../../../../lib/transaction.ts";
 import type { ${projectorClassName} } from "./${fileBase}.projector.ts";
 
+export type ProjectionRebuildBatch = {
+  readonly events: Array<{
+    readonly type: string;
+    readonly payload?: unknown;
+  }>;
+};
+
+export interface ProjectionRebuildEventSource {
+  stream(args: {
+    projectionName: string;
+    strategy: string;
+    batchSize: number;
+    tx: Transaction;
+  }): AsyncIterable<ProjectionRebuildBatch>;
+}
+
 export type ${pascalCase(projection.name)}RebuildDeps = {
   projector: ${projectorClassName};
+  eventSource: ProjectionRebuildEventSource;
   transaction: Transaction;
 };
 
-// Auto-generated rebuild scaffold for the "${projection.readModelName}" read model.
+// Auto-generated rebuild runner for the "${projection.readModelName}" read model.
 export async function ${rebuildFunctionName}(deps: ${pascalCase(projection.name)}RebuildDeps): Promise<void> {
-  void deps;
-  // Strategy: ${projection.rebuild.strategy}
-  // Batch size: ${batchSize}
-  // TODO: replay authoritative events and route them through the projector in stable batches.
+  const batchSize = ${batchSize};
+
+  for await (
+    const batch of deps.eventSource.stream({
+      projectionName: "${projection.name}",
+      strategy: "${projection.rebuild.strategy}",
+      batchSize,
+      tx: deps.transaction,
+    })
+  ) {
+    for (const event of batch.events) {
+      switch (event.type) {
+${projection.sources.slice().sort((left, right) => left.eventName.localeCompare(right.eventName)).map((source) => `        case "${source.contextName}.${source.aggregateName}.${source.eventName}":
+          await deps.projector.${projectionSourceHandlerName(source.eventName)}(event, deps.transaction);
+          break;`).join("\n")}
+        default:
+          break;
+      }
+    }
+  }
 }
 `, contextArtifactOwnership(modulePath));
 }
@@ -4074,7 +4931,8 @@ function buildProjectionSubscriptionsArtifact(contextSpec) {
 	const depsTypeName = `${pascalCase(contextSpec.context.name)}ProjectionSubscriptionDeps`;
 	const builderName = `build${pascalCase(contextSpec.context.name)}ProjectionSubscriptions`;
 	const dependencyLines = contextSpec.projections.map((projection) => `  ${projectionVariableName(projection.name)}: ${projection.name};`);
-	const importLines = contextSpec.projections.map((projection) => `import type { ${projection.name} } from "../../core/contexts/${modulePath}/application/projections/${projectionFileBase(projection.name)}.projector.ts";`);
+	const importLines = contextSpec.projections.map((projection) => `import type { ${projection.name} } from "../../../core/contexts/${modulePath}/application/projections/${projectionFileBase(projection.name)}.projector.ts";`);
+	const eventImports = contextSpec.projections.flatMap((projection) => projection.sources.map((source) => `import type { ${projectionSourcePayloadTypeName(source)} } from "../../../core/contexts/${normalizeModulePath(source.contextName)}/domain/events/${kebabCase(source.eventName)}.event.ts";`));
 	const subscriptionEntries = contextSpec.projections.flatMap((projection) => projection.sources.map((source) => {
 		const subscriptionName = projection.subscription?.subscriptionName ?? projection.name;
 		const consumerGroup = projection.subscription?.consumerGroup;
@@ -4084,11 +4942,13 @@ function buildProjectionSubscriptionsArtifact(contextSpec) {
       subscriptionName: "${subscriptionName}",
       eventName: "${source.contextName}.${source.aggregateName}.${source.eventName}",
       role: "${source.role}",${consumerGroupLine}
-      handle: (event, tx) => deps.${projectionVariableName(projection.name)}.${projectionSourceHandlerName(source.eventName)}(event, tx),
+      handle: (event: ${projectionSourceEventType(source)}, tx) => deps.${projectionVariableName(projection.name)}.${projectionSourceHandlerName(source.eventName)}(event, tx),
     }`;
 	}));
-	return createGeneratedArtifact(`infrastructure/messaging/projection-subscriptions/${modulePath}.ts`, `import type { Transaction } from "../../lib/transaction.ts";
+	return createGeneratedArtifact(`infrastructure/messaging/projection-subscriptions/${modulePath}.ts`, `import type { EventEnvelope } from "../../../lib/event-envelope.ts";
+import type { Transaction } from "../../../lib/transaction.ts";
 ${importLines.join("\n")}
+${[...new Set(eventImports)].join("\n")}
 
 export type ProjectionSubscription = {
   projectionName: string;
@@ -4096,7 +4956,7 @@ export type ProjectionSubscription = {
   eventName: string;
   role: "primary" | "enrichment";
   consumerGroup?: string;
-  handle: (event: unknown, tx: Transaction) => Promise<void>;
+  handle: (event: EventEnvelope<unknown>, tx: Transaction) => Promise<void>;
 };
 
 export type ${depsTypeName} = {
@@ -4372,6 +5232,34 @@ export class EventCollector {
 }
 `;
 }
+function generateAggregateEventTracker() {
+	return `import type { EventEnvelope } from "../../../lib/event-envelope.ts";
+import { EventCollector } from "./event-collector.ts";
+
+type EventSourceAggregate = {
+  pullDomainEvents(): EventEnvelope<unknown>[];
+};
+
+export class AggregateEventTracker {
+  private readonly tracked = new Set<EventSourceAggregate>();
+
+  track(aggregate: EventSourceAggregate): void {
+    this.tracked.add(aggregate);
+  }
+
+  releaseInto(eventCollector: EventCollector): void {
+    for (const aggregate of this.tracked) {
+      eventCollector.collect(aggregate.pullDomainEvents());
+    }
+    this.tracked.clear();
+  }
+
+  reset(): void {
+    this.tracked.clear();
+  }
+}
+`;
+}
 function generateDomainErrors() {
 	return `export type { DomainError } from '../../../lib/domain-error.ts';
 export type { ApplicationError } from '../../../lib/application-error.ts';
@@ -4452,6 +5340,7 @@ function buildV5SharedKernelArtifacts(spec) {
 	const base = [
 		createGeneratedArtifact("core/shared-kernel/result.ts", generateResultReExport(), ownership),
 		createGeneratedArtifact("core/shared-kernel/events/event-collector.ts", generateEventCollector(), ownership),
+		createGeneratedArtifact("core/shared-kernel/events/aggregate-event-tracker.ts", generateAggregateEventTracker(), ownership),
 		createGeneratedArtifact("core/shared-kernel/events/event-context.ts", generateEventContext(), ownership),
 		createGeneratedArtifact("core/shared-kernel/errors/domain-errors.ts", generateDomainErrors(), ownership),
 		createGeneratedArtifact("core/shared-kernel/trpc-error-mapper.ts", generateTrpcErrorMapper(), ownership),
@@ -4910,7 +5799,11 @@ function createApplicationError() {
 }
 `;
 }
-function createTransaction() {
+function createTransaction(infrastructureStrategy) {
+	if (infrastructureStrategy?.persistence === "mysql") return `import type { MySqlTransaction } from "drizzle-orm/mysql-core";
+
+export type Transaction = MySqlTransaction<any, any, any, any>;
+`;
 	return `import type { PgTransaction } from 'drizzle-orm/pg-core';
 
 export type Transaction = PgTransaction<any, any, any>;
@@ -5004,7 +5897,7 @@ export type ListResult<T> = {
 };
 `;
 }
-function buildV5LibArtifacts() {
+function buildV5LibArtifacts(infrastructureStrategy) {
 	const ownership = sharedArtifactOwnership("lib");
 	return [
 		createGeneratedArtifact("lib/branded-id.ts", createBrandedId(), ownership),
@@ -5016,7 +5909,7 @@ function buildV5LibArtifacts() {
 		createGeneratedArtifact("lib/result.ts", createResult(), ownership),
 		createGeneratedArtifact("lib/domain-error.ts", createDomainError(), ownership),
 		createGeneratedArtifact("lib/application-error.ts", createApplicationError(), ownership),
-		createGeneratedArtifact("lib/transaction.ts", createTransaction(), ownership),
+		createGeneratedArtifact("lib/transaction.ts", createTransaction(infrastructureStrategy), ownership),
 		createGeneratedArtifact("lib/concurrency-conflict-error.ts", createConcurrencyConflictError(), ownership),
 		createGeneratedArtifact("lib/pagination.ts", createPagination(), ownership)
 	];
@@ -5126,26 +6019,29 @@ function buildConsumerAclArtifacts(contextSpec) {
 
 //#endregion
 //#region packages/core/orchestrator.ts
-function generateContextArtifacts(contextSpec) {
+function generateContextArtifacts(contextSpec, options = {}) {
 	const perAggregateArtifacts = sliceContextIntoAggregateViews(contextSpec).flatMap((view) => {
 		const ownership = sliceArtifactOwnership(`${view.context.modulePath}/${kebabCase(view.aggregate.name)}`);
 		return [
 			...applyOwnershipIfMissing(buildV5DomainArtifacts(view), ownership),
 			...applyOwnershipIfMissing(buildV5ApplicationArtifacts(view, { skipContextWideArtifacts: true }), ownership),
-			...buildV5InfrastructureArtifacts(view, { skipContextWideArtifacts: true }),
+			...buildV5InfrastructureArtifacts(view, {
+				skipContextWideArtifacts: true,
+				infrastructureStrategy: options.infrastructureStrategy
+			}),
 			...applyOwnershipIfMissing(buildV5TestArtifacts(view), ownership)
 		];
 	});
 	const ctxOwnership = contextArtifactOwnership(contextSpec.context.modulePath);
 	const infraOwnership = sliceArtifactOwnership(contextSpec.context.modulePath);
 	const perContextArtifacts = [
-		...buildV5LibArtifacts(),
+		...buildV5LibArtifacts(options.infrastructureStrategy),
 		...buildV5SharedKernelArtifacts(contextSpec),
 		...buildV5PortArtifacts(),
 		...applyOwnershipIfMissing(buildV5ApplicationContextArtifacts(contextSpec), ctxOwnership),
 		...applyOwnershipIfMissing(buildConsumerAclArtifacts(contextSpec), ctxOwnership),
 		...applyOwnershipIfMissing(buildProjectionArtifacts(contextSpec), ctxOwnership),
-		...applyOwnershipIfMissing(buildV5InfrastructureContextArtifacts(contextSpec), infraOwnership),
+		...applyOwnershipIfMissing(buildV5InfrastructureContextArtifacts(contextSpec, { infrastructureStrategy: options.infrastructureStrategy }), infraOwnership),
 		...applyOwnershipIfMissing(buildV5PresentationArtifacts(contextSpec), ctxOwnership),
 		...applyOwnershipIfMissing(buildV5RouteArtifacts(contextSpec), ctxOwnership)
 	];
@@ -5752,6 +6648,7 @@ function createIntegrationEvent() {
 
 export interface IntegrationEvent<TPayload> {
   readonly type: string;
+  readonly version: number;
   readonly payload: TPayload;
   readonly eventContext: EventContext;
 }
@@ -5787,6 +6684,20 @@ export class DrizzleTransactionManager implements TransactionManager {
 }
 `;
 }
+function createMikroOrmTransactionManager() {
+	return `import type { TransactionManager } from "./transaction-manager.ts";
+
+export class MikroOrmTransactionManager implements TransactionManager {
+  constructor(private readonly em: unknown) {}
+
+  async withTransaction<T>(work: (tx: unknown) => Promise<T>): Promise<T> {
+    return (this.em as any).transactional(async (tx: unknown) => {
+      return work(tx);
+    });
+  }
+}
+`;
+}
 function createTransactionAbortError() {
 	return `export class TransactionAbortError extends Error {
   constructor(public readonly innerError: unknown) {
@@ -5797,11 +6708,13 @@ function createTransactionAbortError() {
 `;
 }
 function createHandlerDeps() {
-	return `import type { EventCollector } from "../../core/shared-kernel/events/event-collector.ts";
+	return `import type { AggregateEventTracker } from "../../core/shared-kernel/events/aggregate-event-tracker.ts";
+import type { EventCollector } from "../../core/shared-kernel/events/event-collector.ts";
 
 export type HandlerDeps = {
   readonly tx: unknown;
   readonly eventCollector: EventCollector;
+  readonly aggregateEventTracker: AggregateEventTracker;
   readonly repos: Record<string, unknown>;
   readonly acls: Record<string, unknown>;
 };
@@ -5813,6 +6726,7 @@ function buildCompositionTypeArtifacts() {
 		createGeneratedArtifact("infrastructure/messaging/integration-event.ts", createIntegrationEvent(), ownership),
 		createGeneratedArtifact("infrastructure/unit-of-work/transaction-manager.ts", createTransactionManager(), ownership),
 		createGeneratedArtifact("infrastructure/unit-of-work/drizzle-transaction-manager.ts", createDrizzleTransactionManager(), ownership),
+		createGeneratedArtifact("infrastructure/unit-of-work/mikroorm-transaction-manager.ts", createMikroOrmTransactionManager(), ownership),
 		createGeneratedArtifact("infrastructure/unit-of-work/transaction-abort-error.ts", createTransactionAbortError(), ownership),
 		createGeneratedArtifact("infrastructure/unit-of-work/handler-deps.ts", createHandlerDeps(), ownership)
 	].sort((left, right) => left.logicalPath.localeCompare(right.logicalPath));
@@ -5825,6 +6739,7 @@ function createCommandBusImpl() {
 import type { TransactionManager } from "../unit-of-work/transaction-manager.ts";
 import { TransactionAbortError } from "../unit-of-work/transaction-abort-error.ts";
 import type { HandlerDeps } from "../unit-of-work/handler-deps.ts";
+import { AggregateEventTracker } from "../../core/shared-kernel/events/aggregate-event-tracker.ts";
 import { EventCollector } from "../../core/shared-kernel/events/event-collector.ts";
 import type { CommandEnvelope } from "../../core/shared-kernel/commands/command-envelope.ts";
 import type { EventContext } from "../../core/shared-kernel/events/event-context.ts";
@@ -5836,6 +6751,9 @@ import type { EventEnvelope } from "../../lib/event-envelope.ts";
 type OutboxWriter = {
   append(tx: unknown, events: EventEnvelope<unknown>[]): Promise<void>;
 };
+type OutboxRelay = {
+  afterCommit(): void;
+};
 type RepositoryFactory = {
   create(tx: unknown): Record<string, unknown>;
 };
@@ -5855,6 +6773,8 @@ type InternalHandlerFn = (
 ) => Promise<Result<unknown, unknown>>;
 
 export class CommandBusImpl implements CommandBusPort {
+  private relay: OutboxRelay | undefined;
+
   constructor(
     private readonly txManager: TransactionManager,
     private readonly repoFactory: RepositoryFactory,
@@ -5862,6 +6782,10 @@ export class CommandBusImpl implements CommandBusPort {
     private readonly outboxWriter: OutboxWriter,
   ) {}
 
+  setRelay(relay: OutboxRelay): void {
+    this.relay = relay;
+  }
+
   // Internal handler type: receives deps injected by withUnitOfWork.
   // This is different from TestCommandBus which registers pre-bound
   // handlers with signature (command, eventContext) — deps closed over
@@ -5889,9 +6813,11 @@ export class CommandBusImpl implements CommandBusPort {
   ): Promise<TResult> {
     const { handler, contextKey: commandContext } = this.resolveHandler(command.type);
     try {
-      return await this.withUnitOfWork(commandContext, (deps) =>
+      const result = await this.withUnitOfWork(commandContext, (deps) =>
         handler(command, deps, eventContext)
       ) as TResult;
+      this.relay?.afterCommit();
+      return result;
     } catch (error) {
       if (error instanceof TransactionAbortError) {
         // Reconstitute the failure Result that triggered rollback.
@@ -5922,16 +6848,24 @@ export class CommandBusImpl implements CommandBusPort {
     work: (deps: HandlerDeps) => Promise<Result<T, unknown>>
   ): Promise<Result<T, unknown>> {
     return this.txManager.withTransaction(async (tx) => {
+      const aggregateEventTracker = new AggregateEventTracker();
       const eventCollector = new EventCollector();
       const repos = this.repoFactory.create(tx);
       const acls = this.aclFactory.create(tx, commandContext);
 
-      const result = await work({ tx, eventCollector, repos, acls });
+      const result = await work({
+        tx,
+        eventCollector,
+        aggregateEventTracker,
+        repos,
+        acls,
+      });
 
       if (!result.ok) {
         throw new TransactionAbortError(result.error);
       }
 
+      aggregateEventTracker.releaseInto(eventCollector);
       const events = eventCollector.drain();
 
       if (events.length > 0) {
@@ -5976,16 +6910,38 @@ function buildCompositionBusArtifacts() {
 
 //#endregion
 //#region packages/core/generators/composition_outbox.ts
-function createOutboxTable() {
-	return `import { pgTable, uuid, varchar, jsonb, timestamp } from "drizzle-orm/pg-core";
+function createOutboxTable(infrastructureStrategy) {
+	if (infrastructureStrategy?.persistence === "mysql") return `import { sql } from "drizzle-orm";
+import { int, json, mysqlTable, timestamp, varchar } from "drizzle-orm/mysql-core";
+
+export const outboxEvents = mysqlTable("outbox_events", {
+  id: varchar("id", { length: 36 }).primaryKey().default(sql\`(uuid())\`),
+  eventType: varchar("event_type", { length: 255 }).notNull(),
+  eventVersion: int("event_version").notNull(),
+  payload: json("payload").notNull(),
+  metadata: json("metadata").notNull(),
+  occurredAt: timestamp("occurred_at").notNull().defaultNow(),
+  status: varchar("status", { length: 50 }).notNull().default("pending"),
+  attempts: int("attempts").notNull().default(0),
+  processedAt: timestamp("processed_at"),
+  failedAt: timestamp("failed_at"),
+  error: json("error"),
+});
+`;
+	return `import { pgTable, uuid, varchar, jsonb, timestamp, integer } from "drizzle-orm/pg-core";
 
 export const outboxEvents = pgTable("outbox_events", {
   id: uuid("id").primaryKey().defaultRandom(),
   eventType: varchar("event_type", { length: 255 }).notNull(),
+  eventVersion: integer("event_version").notNull(),
   payload: jsonb("payload").notNull(),
   metadata: jsonb("metadata").notNull(),
   occurredAt: timestamp("occurred_at").notNull().defaultNow(),
   status: varchar("status", { length: 50 }).notNull().default("pending"),
+  attempts: integer("attempts").notNull().default(0),
+  processedAt: timestamp("processed_at"),
+  failedAt: timestamp("failed_at"),
+  error: jsonb("error"),
 });
 `;
 }
@@ -6001,6 +6957,7 @@ export class OutboxWriter {
     for (const event of events) {
       await db.insert(outboxEvents).values({
         eventType: event.eventType,
+        eventVersion: event.eventVersion,
         payload: event.payload,
         metadata: {
           correlationId: event.correlationId,
@@ -6015,9 +6972,221 @@ export class OutboxWriter {
 }
 `;
 }
-function buildCompositionOutboxArtifacts() {
+function createOutboxDispatcher() {
+	return `import { asc, eq } from "drizzle-orm";
+import { outboxEvents } from "./outbox.table.ts";
+import type {
+  EventSubscription,
+  IntegrationEvent,
+} from "../messaging/integration-event.ts";
+
+export type OutboxDispatcherConfig = {
+  readonly maxAttempts?: number;
+  readonly batchSize?: number;
+};
+
+type OutboxRow = typeof outboxEvents.$inferSelect;
+
+type OutboxMetadata = {
+  correlationId: string;
+  causationId: string;
+  recordedBy: string;
+  occurredAt: string;
+};
+
+type HandlerError = {
+  handler: string;
+  error: string;
+};
+
+export class OutboxDispatcher {
+  private readonly maxAttempts: number;
+  private readonly batchSize: number;
+  private readonly handlersByEventType: Map<string, EventSubscription[]>;
+
+  constructor(
+    private readonly db: unknown,
+    subscriptions: EventSubscription[],
+    config?: OutboxDispatcherConfig,
+  ) {
+    this.maxAttempts = config?.maxAttempts ?? 5;
+    this.batchSize = config?.batchSize ?? 100;
+
+    const index = new Map<string, EventSubscription[]>();
+    for (const subscription of subscriptions) {
+      const existing = index.get(subscription.eventType) ?? [];
+      existing.push(subscription);
+      index.set(subscription.eventType, existing);
+    }
+    this.handlersByEventType = index;
+  }
+
+  async dispatchPending(): Promise<{ processed: number; failed: number }> {
+    const drizzle = this.db as any;
+    let processed = 0;
+    let failed = 0;
+
+    const rows: OutboxRow[] = await drizzle
+      .select()
+      .from(outboxEvents)
+      .where(eq(outboxEvents.status, "pending"))
+      .orderBy(asc(outboxEvents.occurredAt))
+      .limit(this.batchSize);
+
+    for (const row of rows) {
+      const ok = await this.dispatchRow(row);
+      if (ok) {
+        processed += 1;
+      } else {
+        failed += 1;
+      }
+    }
+
+    return { processed, failed };
+  }
+
+  private async dispatchRow(row: OutboxRow): Promise<boolean> {
+    const handlers = this.handlersByEventType.get(row.eventType);
+    if (!handlers || handlers.length === 0) {
+      await this.updateStatus(row.id, "processed", { processedAt: new Date() });
+      return true;
+    }
+
+    const metadata = (row.metadata ?? {}) as Partial<OutboxMetadata>;
+    const event: IntegrationEvent<unknown> = {
+      type: row.eventType,
+      version: row.eventVersion,
+      payload: row.payload,
+      eventContext: {
+        correlationId: metadata.correlationId as any,
+        causationId: metadata.causationId as any,
+        recordedBy: metadata.recordedBy as any,
+      },
+    };
+
+    const errors: HandlerError[] = [];
+    for (const subscription of handlers) {
+      try {
+        await subscription.handler(event);
+      } catch (error) {
+        errors.push({
+          handler: subscription.handler.name || subscription.eventType,
+          error: error instanceof Error ? error.message : String(error),
+        });
+      }
+    }
+
+    if (errors.length === 0) {
+      await this.updateStatus(row.id, "processed", {
+        processedAt: new Date(),
+        error: null,
+      });
+      return true;
+    }
+
+    const nextAttempts = (row.attempts ?? 0) + 1;
+    if (nextAttempts >= this.maxAttempts) {
+      await this.updateStatus(row.id, "failed", {
+        attempts: nextAttempts,
+        failedAt: new Date(),
+        error: errors,
+      });
+    } else {
+      await this.updateStatus(row.id, "pending", {
+        attempts: nextAttempts,
+        error: errors,
+      });
+    }
+
+    return false;
+  }
+
+  private async updateStatus(
+    id: string,
+    status: "pending" | "processed" | "failed",
+    fields: Record<string, unknown>,
+  ): Promise<void> {
+    const drizzle = this.db as any;
+    await drizzle
+      .update(outboxEvents)
+      .set({ status, ...fields })
+      .where(eq(outboxEvents.id, id));
+  }
+}
+`;
+}
+function createOutboxRelay() {
+	return `import type { OutboxDispatcher } from "./outbox-dispatcher.ts";
+
+export class OutboxRelay {
+  constructor(private readonly dispatcher: OutboxDispatcher) {}
+
+  afterCommit(): void {
+    void this.dispatcher.dispatchPending().catch(() => {
+      // Swallowed - the poller retries on the next cycle.
+    });
+  }
+}
+`;
+}
+function createOutboxPoller() {
+	return `import type { OutboxDispatcher } from "./outbox-dispatcher.ts";
+
+export type OutboxPollerConfig = {
+  readonly intervalMs?: number;
+};
+
+export class OutboxPoller {
+  private handle: ReturnType<typeof setInterval> | null = null;
+  private polling = false;
+  private readonly intervalMs: number;
+
+  constructor(
+    private readonly dispatcher: OutboxDispatcher,
+    config?: OutboxPollerConfig,
+  ) {
+    this.intervalMs = config?.intervalMs ?? 5_000;
+  }
+
+  start(): void {
+    if (this.handle) return;
+    void this.poll();
+    this.handle = setInterval(() => void this.poll(), this.intervalMs);
+  }
+
+  stop(): void {
+    if (!this.handle) return;
+    clearInterval(this.handle);
+    this.handle = null;
+  }
+
+  get running(): boolean {
+    return this.handle !== null;
+  }
+
+  private async poll(): Promise<void> {
+    if (this.polling) return;
+    this.polling = true;
+    try {
+      await this.dispatcher.dispatchPending();
+    } catch {
+      // Swallowed - the next cycle retries.
+    } finally {
+      this.polling = false;
+    }
+  }
+}
+`;
+}
+function buildCompositionOutboxArtifacts(infrastructureStrategy) {
 	const ownership = sharedArtifactOwnership("composition");
-	return [createGeneratedArtifact("infrastructure/outbox/outbox.table.ts", createOutboxTable(), ownership), createGeneratedArtifact("infrastructure/outbox/outbox-writer.ts", createOutboxWriter(), ownership)].sort((left, right) => left.logicalPath.localeCompare(right.logicalPath));
+	return [
+		createGeneratedArtifact("infrastructure/outbox/outbox-dispatcher.ts", createOutboxDispatcher(), ownership),
+		createGeneratedArtifact("infrastructure/outbox/outbox-poller.ts", createOutboxPoller(), ownership),
+		createGeneratedArtifact("infrastructure/outbox/outbox-relay.ts", createOutboxRelay(), ownership),
+		createGeneratedArtifact("infrastructure/outbox/outbox.table.ts", createOutboxTable(infrastructureStrategy), ownership),
+		createGeneratedArtifact("infrastructure/outbox/outbox-writer.ts", createOutboxWriter(), ownership)
+	].sort((left, right) => left.logicalPath.localeCompare(right.logicalPath));
 }
 
 //#endregion
@@ -6105,34 +7274,53 @@ function renderMappedType(fields) {
 ${Object.entries(fields).map(([fieldName, expr]) => `  readonly ${camelCase(fieldName)}: ${mappingValueType(expr)};`).join("\n")}
 }`;
 }
-function sourceQueryViewTypeName(acl) {
-	const baseName = acl.sourceQuery.readModelName ? pascalCase(acl.sourceQuery.readModelName) : pascalCase(acl.sourceQuery.name);
-	return baseName.endsWith("View") ? baseName : `${baseName}View`;
+function mapReadAclFieldTypeToTS(type) {
+	switch (type) {
+		case "string": return "string";
+		case "number": return "number";
+		case "boolean": return "boolean";
+		case "date": return "string";
+		case "enum": return "string";
+		case "union": return "string | number | boolean | null";
+		case "record": return "Record<string, unknown>";
+		case "tuple": return "[unknown, ...unknown[]]";
+		case "intersection": return "Record<string, unknown>";
+		default: return "unknown";
+	}
 }
-function sourceQueryViewFileName(acl) {
-	return `${(acl.sourceQuery.readModelName ? kebabCase(acl.sourceQuery.readModelName) : kebabCase(acl.sourceQuery.name)).replace(/-view$/, "")}.view.ts`;
+function formatReadAclFieldType(field, indent = 0) {
+	if (field.type === "object" && field.nestedFields && field.nestedFields.length > 0) {
+		const objectType = `{\n${field.nestedFields.map((nestedField) => {
+			const opt = nestedField.optional ? "?" : "";
+			return `${"  ".repeat(indent + 1)}readonly ${camelCase(nestedField.name)}${opt}: ${formatReadAclFieldType(nestedField, indent + 1)};`;
+		}).join("\n")}\n${"  ".repeat(indent)}}`;
+		return field.array ? `Array<${objectType}>` : objectType;
+	}
+	const base = mapReadAclFieldTypeToTS(field.type);
+	return field.array ? `${base}[]` : base;
+}
+function formatReadAclListItemType(outputFields) {
+	return `Array<{\n${outputFields.map((field) => {
+		const opt = field.optional ? "?" : "";
+		return `  readonly ${camelCase(field.name)}${opt}: ${formatReadAclFieldType(field, 1)};`;
+	}).join("\n")}\n}>`;
 }
 function readResponseFieldType(acl, mapping) {
 	if (mapping.kind === "const") return mappingValueType({ const: mapping.value });
-	const viewTypeName = sourceQueryViewTypeName(acl);
 	if (acl.sourceQuery.queryKind === "list") {
-		if (mapping.sourcePath === "result.items") return `${viewTypeName}[]`;
+		if (mapping.sourcePath === "result.items") return formatReadAclListItemType(acl.sourceQuery.outputFields);
 		if (mapping.sourcePath === "result.total" || mapping.sourcePath === "result.page" || mapping.sourcePath === "result.pageSize") return "number";
 	}
 	const sourceFieldName = mapping.sourcePath.replace(/^result\./, "");
 	const sourceField = acl.sourceQuery.outputFields.find((field) => camelCase(field.name) === camelCase(sourceFieldName));
-	return sourceField ? `${viewTypeName}[${JSON.stringify(sourceField.name)}]` : "unknown";
+	return sourceField ? formatReadAclFieldType(sourceField) : "unknown";
 }
 function buildReadAclContractContent(acl) {
 	normalizeModulePath(acl.consumerContext.modulePath);
-	const sourceModulePath = normalizeModulePath(acl.sourceContext.modulePath);
 	const requestTypeName = aclRequestTypeName(acl.port);
 	const responseTypeName = aclResponseTypeName(acl.port);
-	const viewTypeName = sourceQueryViewTypeName(acl);
-	const viewFileName = sourceQueryViewFileName(acl);
 	const responseLines = acl.responseMappings.map((mapping) => `  readonly ${camelCase(mapping.targetPath)}: ${readResponseFieldType(acl, mapping)};`);
 	return `import type { Transaction } from "../../../../../lib/transaction.ts";
-import type { ${viewTypeName} } from "../../../${sourceModulePath}/application/contracts/${viewFileName}";
 
 export type ${requestTypeName} = ${renderMappedType(Object.fromEntries(acl.requestMappings.map((mapping) => [mapping.targetPath, mapping.kind === "from" ? { from: mapping.sourcePath } : { const: mapping.value }])))};
 
@@ -6421,6 +7609,24 @@ function buildCompositionAclArtifacts(compositionSpec) {
 	].sort((left, right) => left.logicalPath.localeCompare(right.logicalPath));
 }
 
+//#endregion
+//#region packages/core/generators/composition_dependencies.ts
+function resolveRuntimeDependencies(compositionSpec) {
+	const dependencies = new Set(["drizzle-orm"]);
+	if (compositionSpec.infrastructure.persistence === "postgres") dependencies.add("postgres");
+	else if (compositionSpec.infrastructure.persistence === "mysql") dependencies.add("mysql2");
+	if (compositionSpec.infrastructure.orm === "mikroorm") dependencies.add("@mikro-orm/core");
+	return [...dependencies].sort((left, right) => left.localeCompare(right));
+}
+function buildCompositionDependencyManifestArtifacts(compositionSpec) {
+	const manifest = {
+		kind: "zodmire-dependency-manifest",
+		infrastructure: compositionSpec.infrastructure,
+		dependencies: resolveRuntimeDependencies(compositionSpec)
+	};
+	return [createGeneratedArtifact("codegen/dependency-manifest.json", `${JSON.stringify(manifest, null, 2)}\n`, sharedArtifactOwnership("composition"))];
+}
+
 //#endregion
 //#region packages/core/generators/composition_container.ts
 /**
@@ -6432,6 +7638,8 @@ function buildCompositionContainerArtifacts(compositionSpec, contextSpecs) {
 	return [createGeneratedArtifact("infrastructure/di/container.ts", buildContainerContent(compositionSpec, contextSpecs), ownership), createGeneratedArtifact("infrastructure/di/repo-factory.ts", buildRepoFactoryContent(contextSpecs), ownership)].sort((left, right) => left.logicalPath.localeCompare(right.logicalPath));
 }
 function buildContainerContent(compositionSpec, contextSpecs) {
+	assertSupportedContainerStrategy(compositionSpec);
+	const runtime = resolveContainerRuntime(compositionSpec);
 	const readContexts = uniqueReadContexts(compositionSpec.acls);
 	const readContextNames = buildCollisionSafeModulePathNames(readContexts.map((context) => context.modulePath));
 	const commandContextNames = buildCollisionSafeModulePathNames(contextSpecs.map((context) => context.context.modulePath));
@@ -6441,7 +7649,10 @@ function buildContainerContent(compositionSpec, contextSpecs) {
 		``,
 		`import { CommandBusImpl } from "../messaging/command-bus.impl.ts";`,
 		`import { QueryBusImpl } from "../messaging/query-bus.impl.ts";`,
-		`import { DrizzleTransactionManager } from "../unit-of-work/drizzle-transaction-manager.ts";`,
+		`import { ${runtime.transactionManagerClassName} } from "../unit-of-work/${runtime.transactionManagerFileBase}.ts";`,
+		`import { OutboxDispatcher } from "../outbox/outbox-dispatcher.ts";`,
+		`import { OutboxPoller } from "../outbox/outbox-poller.ts";`,
+		`import { OutboxRelay } from "../outbox/outbox-relay.ts";`,
 		`import { OutboxWriter } from "../outbox/outbox-writer.ts";`,
 		`import { AclFactory } from "./acl-factory.ts";`,
 		`import { RepositoryFactory } from "./repo-factory.ts";`,
@@ -6460,7 +7671,8 @@ function buildContainerContent(compositionSpec, contextSpecs) {
 		for (const query of uniqueQueriesByReadModel(contextSpec.queries)) {
 			const repoClassName = queryReadModelRepositoryClassName(query);
 			const repoAlias = queryReadModelRepositoryAlias(boundaryPlan.symbolStem, query);
-			importLines.push(repoAlias === repoClassName ? `import { ${repoClassName} } from "../view-models/drizzle/repositories/${modulePath}/${queryViewFileBase(query)}.repository.ts";` : `import { ${repoClassName} as ${repoAlias} } from "../view-models/drizzle/repositories/${modulePath}/${queryViewFileBase(query)}.repository.ts";`);
+			const repoFileBase = readModelRepositoryFileBase(resolvedReadModelName(query));
+			importLines.push(repoAlias === repoClassName ? `import { ${repoClassName} } from "../view-models/drizzle/repositories/${modulePath}/${repoFileBase}.repository.ts";` : `import { ${repoClassName} as ${repoAlias} } from "../view-models/drizzle/repositories/${modulePath}/${repoFileBase}.repository.ts";`);
 		}
 	}
 	for (const spec of contextSpecs) {
@@ -6484,15 +7696,16 @@ function buildContainerContent(compositionSpec, contextSpecs) {
 		`  readonly commandBus: CommandBusPort;`,
 		`  readonly queryBus: QueryBusPort;`,
 		`  readonly integrationEventSubscriptions: EventSubscription[];`,
-		`  readonly db: unknown;`,
+		`  readonly outboxPoller: OutboxPoller;`,
+		...runtime.containerFields.map((field) => `  readonly ${field}: unknown;`),
 		`};`
 	];
 	const createContainerLines = [
 		``,
-		`export function createContainer(deps: { db: unknown }): Container {`,
+		`export function createContainer(deps: { ${runtime.dependencyFields.map((field) => `${field}: unknown`).join("; ")} }): Container {`,
 		`  const outboxWriter = new OutboxWriter();`,
 		`  const repoFactory = new RepositoryFactory();`,
-		`  const txManager = new DrizzleTransactionManager(deps.db);`
+		`  const txManager = new ${runtime.transactionManagerClassName}(${runtime.transactionDependencyRef});`
 	];
 	for (const context of readContexts) {
 		const contextSpec = contextSpecs.find((spec) => spec.context.modulePath.toLowerCase() === context.modulePath.toLowerCase());
@@ -6500,7 +7713,7 @@ function buildContainerContent(compositionSpec, contextSpecs) {
 		const boundaryPlan = readContextNames.get(context.modulePath);
 		const boundaryVar = `${boundaryPlan.propertyStem}PublishedReadBoundary`;
 		const boundaryAlias = `create${boundaryPlan.symbolStem}PublishedReadBoundary`;
-		const boundaryDeps = buildPublishedReadBoundaryDeps(contextSpec, boundaryPlan.symbolStem);
+		const boundaryDeps = buildPublishedReadBoundaryDeps(contextSpec, boundaryPlan.symbolStem, runtime.readRepositoryDependencyRef);
 		createContainerLines.push(`  const ${boundaryVar} = ${boundaryAlias}(${boundaryDeps});`);
 	}
 	createContainerLines.push(`  let commandBus: CommandBusImpl | undefined;`, `  const commandBusPort: CommandBusPort = {`, `    execute: (command, eventContext) => {`, `      if (!commandBus) {`, `        throw new Error("Command bus is not initialized");`, `      }`, `      return commandBus.execute(command, eventContext);`, `    },`, `  };`);
@@ -6531,7 +7744,9 @@ function buildContainerContent(compositionSpec, contextSpecs) {
 		createContainerLines.push(`  const integrationEventSubscriptions: EventSubscription[] = [];`);
 	}
 	createContainerLines.push(``);
-	createContainerLines.push(`  return { commandBus: commandBus!, queryBus, integrationEventSubscriptions, db: deps.db };`);
+	createContainerLines.push(`  const outboxDispatcher = new OutboxDispatcher(${runtime.transactionDependencyRef}, integrationEventSubscriptions);`, `  const outboxRelay = new OutboxRelay(outboxDispatcher);`, `  commandBus.setRelay(outboxRelay);`, `  const outboxPoller = new OutboxPoller(outboxDispatcher);`);
+	createContainerLines.push(``);
+	createContainerLines.push(`  return { commandBus: commandBus!, queryBus, integrationEventSubscriptions, outboxPoller, ${runtime.containerFields.map((field) => `${field}: deps.${field}`).join(", ")} };`);
 	createContainerLines.push(`}`);
 	createContainerLines.push(``);
 	return [
@@ -6540,11 +7755,50 @@ function buildContainerContent(compositionSpec, contextSpecs) {
 		...createContainerLines
 	].join("\n");
 }
-function buildPublishedReadBoundaryDeps(spec, contextSymbolStem) {
+function buildPublishedReadBoundaryDeps(spec, contextSymbolStem, readRepositoryDependencyRef) {
 	const entries = /* @__PURE__ */ new Map();
-	for (const query of uniqueQueriesByReadModel(spec.queries)) entries.set(queryReadModelVariableName(query), `${queryReadModelVariableName(query)}: new ${queryReadModelRepositoryAlias(contextSymbolStem, query)}(deps.db)`);
+	for (const query of uniqueQueriesByReadModel(spec.queries)) entries.set(queryReadModelVariableName(query), `${queryReadModelVariableName(query)}: new ${queryReadModelRepositoryAlias(contextSymbolStem, query)}(${readRepositoryDependencyRef})`);
 	return `{ ${[...entries.values()].join(", ")} }`;
 }
+function assertSupportedContainerStrategy(compositionSpec) {
+	const { architecture, persistence, orm } = compositionSpec.infrastructure;
+	if (!(architecture === "physical-cqrs" && persistence === "postgres" && (orm === "drizzle" || orm === "mikroorm") || architecture === "logical-cqrs" && (persistence === "postgres" && (orm === "drizzle" || orm === "mikroorm") || persistence === "mysql" && (orm === "drizzle" || orm === "mikroorm")) || architecture === "physical-cqrs" && persistence === "mysql" && (orm === "drizzle" || orm === "mikroorm"))) throw new Error(`[composition_container] Unsupported infrastructure strategy: ${architecture} + ${persistence} + ${orm}`);
+}
+function resolveContainerRuntime(compositionSpec) {
+	const { architecture, orm } = compositionSpec.infrastructure;
+	if (architecture === "physical-cqrs" && orm === "drizzle") return {
+		transactionManagerClassName: "DrizzleTransactionManager",
+		transactionManagerFileBase: "drizzle-transaction-manager",
+		transactionDependencyRef: "deps.writeDb",
+		readRepositoryDependencyRef: "deps.readDb",
+		dependencyFields: ["writeDb", "readDb"],
+		containerFields: ["writeDb", "readDb"]
+	};
+	if (architecture === "logical-cqrs" && orm === "drizzle") return {
+		transactionManagerClassName: "DrizzleTransactionManager",
+		transactionManagerFileBase: "drizzle-transaction-manager",
+		transactionDependencyRef: "deps.db",
+		readRepositoryDependencyRef: "deps.db",
+		dependencyFields: ["db"],
+		containerFields: ["db"]
+	};
+	if (architecture === "physical-cqrs" && orm === "mikroorm") return {
+		transactionManagerClassName: "MikroOrmTransactionManager",
+		transactionManagerFileBase: "mikroorm-transaction-manager",
+		transactionDependencyRef: "deps.writeEm",
+		readRepositoryDependencyRef: "deps.readDb",
+		dependencyFields: ["writeEm", "readDb"],
+		containerFields: ["writeEm", "readDb"]
+	};
+	return {
+		transactionManagerClassName: "MikroOrmTransactionManager",
+		transactionManagerFileBase: "mikroorm-transaction-manager",
+		transactionDependencyRef: "deps.em",
+		readRepositoryDependencyRef: "deps.db",
+		dependencyFields: ["em", "db"],
+		containerFields: ["em", "db"]
+	};
+}
 function resolvedReadModelName(query) {
 	return query.readSide?.readModelName ?? query.readModelName ?? query.name;
 }
@@ -6563,23 +7817,17 @@ function uniqueQueriesByReadModel(queries) {
 	}
 	return [...queriesByReadModel.values()].sort((left, right) => resolvedReadModelName(left).localeCompare(resolvedReadModelName(right)));
 }
-function queryOutputContractName(query) {
-	return readModelContractName(resolvedReadModelName(query));
-}
-function queryViewFileBase(query) {
-	return readModelRepositoryFileBase(resolvedReadModelName(query));
-}
 function queryReadModelPortTypeName(query) {
-	return `${queryOutputContractName(query)}RepositoryPort`;
+	return `${readModelContractName(resolvedReadModelName(query))}RepositoryPort`;
 }
 function queryReadModelVariableName(query) {
 	return camelCase(queryReadModelPortTypeName(query));
 }
 function queryReadModelRepositoryClassName(query) {
-	return `Drizzle${queryOutputContractName(query)}Repository`;
+	return `Drizzle${readModelContractName(resolvedReadModelName(query))}Repository`;
 }
 function queryReadModelRepositoryAlias(contextSymbolStem, query) {
-	return `${contextSymbolStem}${queryOutputContractName(query)}Repository`;
+	return `${contextSymbolStem}${readModelContractName(resolvedReadModelName(query))}Repository`;
 }
 function uniqueReadContexts(acls) {
 	const seen = /* @__PURE__ */ new Set();
@@ -6594,24 +7842,31 @@ function uniqueReadContexts(acls) {
 	return contexts;
 }
 function buildRepoFactoryContent(contextSpecs) {
-	const repositoryDefs = contextSpecs.flatMap((spec) => spec.aggregates.map((aggregate) => ({
-		aggregateName: aggregate.name,
-		modulePath: spec.context.modulePath,
-		repoFile: `drizzle-${kebabCase(aggregate.name)}.repository.ts`,
-		aggregateAliasBase: `Drizzle${pascalCase(aggregate.name)}Repository`,
-		aggregateFieldBase: `${camelCase(aggregate.name)}s`
-	})));
+	const repositoryDefs = contextSpecs.flatMap((spec) => spec.aggregates.map((aggregate) => {
+		const repositoryPort = spec.ports.find((port) => port.kind === "repository" && port.target === aggregate.name);
+		const isMikroOrm = (repositoryPort ? spec.adapters.find((candidate) => candidate.port === repositoryPort.name && (candidate.kind === "drizzle-repository" || candidate.kind === "mikroorm-repository")) : void 0)?.kind === "mikroorm-repository";
+		const providerPrefix = isMikroOrm ? "mikroorm" : "drizzle";
+		const repositoryClassPrefix = isMikroOrm ? "MikroOrm" : "Drizzle";
+		return {
+			aggregateName: aggregate.name,
+			modulePath: spec.context.modulePath,
+			repoFile: `${providerPrefix}-${kebabCase(aggregate.name)}.repository.ts`,
+			repoImportBasePath: `../persistence/${providerPrefix}/repositories`,
+			aggregateAliasBase: `${repositoryClassPrefix}${pascalCase(aggregate.name)}Repository`,
+			aggregateFieldBase: `${camelCase(aggregate.name)}s`
+		};
+	}));
 	assertNoSameContextRepoFileCollisions(repositoryDefs);
 	const namingPlan = buildRepositoryNamingPlan(repositoryDefs);
 	const lines = [`// Auto-generated repository factory — do not edit by hand`, ``];
 	for (const repositoryDef of repositoryDefs) {
-		const aggName = repositoryDef.aggregateName;
+		repositoryDef.aggregateName;
 		const modulePath = normalizeModulePath(repositoryDef.modulePath);
-		const repoClass = `Drizzle${pascalCase(aggName)}Repository`;
+		const repoClass = repositoryDef.aggregateAliasBase;
 		const { repoAlias } = namingPlan.get(repositoryKey(repositoryDef));
 		const repoFile = repositoryDef.repoFile;
-		if (repoAlias === repoClass) lines.push(`import { ${repoClass} } from "../persistence/drizzle/repositories/${modulePath}/${repoFile}";`);
-		else lines.push(`import { ${repoClass} as ${repoAlias} } from "../persistence/drizzle/repositories/${modulePath}/${repoFile}";`);
+		if (repoAlias === repoClass) lines.push(`import { ${repoClass} } from "${repositoryDef.repoImportBasePath}/${modulePath}/${repoFile}";`);
+		else lines.push(`import { ${repoClass} as ${repoAlias} } from "${repositoryDef.repoImportBasePath}/${modulePath}/${repoFile}";`);
 	}
 	lines.push(``);
 	lines.push(`export class RepositoryFactory {`);
@@ -6749,9 +8004,14 @@ export {};
 	const payloadTypeNames = [];
 	for (const evt of compositionSpec.crossContextEvents) {
 		const fields = getPayloadFields(evt.payloadSchema);
-		payloadTypeNames.push(evt.payloadTypeName);
-		lines.push(`export interface ${evt.payloadTypeName} {`);
-		for (const field of fields) lines.push(`  readonly ${field.name}: ${field.type};`);
+		const payloadTypeName = integrationPayloadTypeName(evt);
+		payloadTypeNames.push(payloadTypeName);
+		lines.push(`export interface ${payloadTypeName} {`);
+		for (const field of fields) {
+			const opt = field.optional ? "?" : "";
+			const comment = field.comment ? ` ${field.comment}` : "";
+			lines.push(`  readonly ${field.name}${opt}: ${field.type};${comment}`);
+		}
 		lines.push(`}`);
 		lines.push(``);
 	}
@@ -6762,18 +8022,20 @@ export {};
 	return lines.join("\n");
 }
 function buildHandlerFactoryContent(evt, sub) {
-	const payloadMappingLines = getPayloadFields(evt.payloadSchema).map((f) => `          ${f.name}: event.payload.${f.name},`);
+	const fields = getPayloadFields(evt.payloadSchema);
+	const payloadTypeName = integrationPayloadTypeName(evt);
+	const payloadMappingLines = fields.map((f) => `          ${f.name}: event.payload.${f.name},`);
 	const commandType = `${pascalCase(sub.targetContext)}.${pascalCase(sub.action)}`;
 	return [
 		`// Auto-generated event handler factory — do not edit by hand`,
 		`import type { CommandBusPort } from "../../../../../core/ports/messaging/command-bus.port.ts";`,
 		`import type { IntegrationEvent, IntegrationEventHandler } from "../../../../../infrastructure/messaging/integration-event.ts";`,
-		`import type { ${evt.payloadTypeName} } from "../../../../shared-kernel/events/integration-events.types.ts";`,
+		`import type { ${payloadTypeName} } from "../../../../shared-kernel/events/integration-events.types.ts";`,
 		``,
 		`export function ${sub.handlerFactoryName}(deps: {`,
 		`  commandBus: CommandBusPort;`,
-		`}): IntegrationEventHandler<${evt.payloadTypeName}> {`,
-		`  return async (event: IntegrationEvent<${evt.payloadTypeName}>) => {`,
+		`}): IntegrationEventHandler<${payloadTypeName}> {`,
+		`  return async (event: IntegrationEvent<${payloadTypeName}>) => {`,
 		`    return deps.commandBus.execute(`,
 		`      {`,
 		`        type: "${commandType}",`,
@@ -6792,30 +8054,114 @@ function buildSubscriptionRegistryContent(compositionSpec) {
 	const allSubs = [];
 	for (const evt of compositionSpec.crossContextEvents) for (const sub of evt.subscriptions) allSubs.push({
 		eventType: evt.eventType,
+		payloadTypeName: integrationPayloadTypeName(evt),
 		sub
 	});
 	const importLines = [`// Auto-generated subscription registry — do not edit by hand`, `import type { EventSubscription, IntegrationEventHandler } from "./integration-event.ts";`];
+	const payloadTypeImports = [...new Set(allSubs.map(({ payloadTypeName }) => payloadTypeName))].sort((left, right) => left.localeCompare(right)).map((payloadTypeName) => `import type { ${payloadTypeName} } from "../../core/shared-kernel/events/integration-events.types.ts";`);
+	importLines.push(...payloadTypeImports);
 	for (const { sub } of allSubs) {
 		const fileName = `${kebabCase(sub.handlerName)}.handler.ts`;
 		importLines.push(`// Handler: ${sub.handlerFactoryName} from core/contexts/${sub.targetModulePath}/application/event-handlers/${fileName}`);
 	}
-	const depsEntries = allSubs.map(({ sub }) => `  ${camelCase(sub.handlerName)}: IntegrationEventHandler<any>;`);
+	const depsEntries = allSubs.map(({ payloadTypeName, sub }) => `  ${camelCase(sub.handlerName)}: IntegrationEventHandler<${payloadTypeName}>;`);
 	const registryEntries = allSubs.map(({ eventType, sub }) => `    { eventType: "${eventType}", handler: deps.${camelCase(sub.handlerName)} },`);
 	const lines = [...importLines, ``];
 	if (depsEntries.length > 0) lines.push(`export function buildSubscriptionRegistry(deps: {`, ...depsEntries, `}): EventSubscription[] {`, `  return [`, ...registryEntries, `  ];`, `}`, ``);
 	else lines.push(`export function buildSubscriptionRegistry(_deps: Record<string, never>): EventSubscription[] {`, `  return [];`, `}`, ``);
 	return lines.join("\n");
 }
+function integrationPayloadTypeName(evt) {
+	return `${pascalCase(evt.sourceContext)}${evt.payloadTypeName}`;
+}
+function renderPayloadSchemaType(schema, indent = 0) {
+	const raw = schema;
+	const def = raw?._zod?.def;
+	const typeName = typeof def?.type === "string" ? def.type : void 0;
+	if (typeName === "optional") return {
+		...renderPayloadSchemaType(def?.innerType, indent),
+		optional: true
+	};
+	if (typeName === "nullable" || typeName === "readonly" || typeName === "default" || typeName === "catch" || typeName === "nonoptional" || typeName === "success" || typeName === "prefault") return renderPayloadSchemaType(def?.innerType, indent);
+	if (typeName === "array") {
+		const element = renderPayloadSchemaType(def?.element, indent);
+		return {
+			type: `Array<${element.type}>`,
+			optional: false,
+			comment: element.comment
+		};
+	}
+	if (typeName === "object") {
+		const shape = typeof raw?.shape === "object" && raw?.shape !== null ? raw.shape : typeof def?.shape === "object" && def?.shape !== null ? def.shape : {};
+		return {
+			type: `{\n${Object.entries(shape).map(([fieldName, fieldSchema]) => {
+				const field = renderPayloadSchemaType(fieldSchema, indent + 1);
+				const opt = field.optional ? "?" : "";
+				const comment = field.comment ? ` ${field.comment}` : "";
+				return `${"  ".repeat(indent + 1)}readonly ${fieldName}${opt}: ${field.type};${comment}`;
+			}).join("\n")}\n${"  ".repeat(indent)}}`,
+			optional: false
+		};
+	}
+	if (typeName === "enum") {
+		const entries = def?.entries;
+		if (entries && typeof entries === "object") return {
+			type: Object.values(entries).map((value) => JSON.stringify(String(value))).join(" | "),
+			optional: false
+		};
+		return {
+			type: "string",
+			optional: false
+		};
+	}
+	if (typeName === "record") {
+		const valueShape = renderPayloadSchemaType(def?.valueType, indent);
+		return {
+			type: `Record<string, ${valueShape.type}>`,
+			optional: false,
+			comment: valueShape.comment
+		};
+	}
+	if (typeName === "tuple") return {
+		type: `[${(Array.isArray(def?.items) ? def.items : []).map((item) => renderPayloadSchemaType(item, indent).type).join(", ")}]`,
+		optional: false
+	};
+	if (typeName === "union") return {
+		type: (Array.isArray(def?.options) ? def.options : []).map((option) => renderPayloadSchemaType(option, indent).type).join(" | "),
+		optional: false
+	};
+	if (typeName === "date") return {
+		type: "string",
+		optional: false,
+		comment: "// ISO 8601"
+	};
+	if (typeName === "number" || typeName === "int" || typeName === "float") return {
+		type: "number",
+		optional: false
+	};
+	if (typeName === "boolean") return {
+		type: "boolean",
+		optional: false
+	};
+	if (typeName === "string") return {
+		type: "string",
+		optional: false
+	};
+	return {
+		type: "string",
+		optional: false
+	};
+}
 function getPayloadFields(payloadSchema) {
 	const shape = payloadSchema?.shape;
 	if (shape && typeof shape === "object") return Object.keys(shape).map((key) => {
-		const typeName = ((shape[key]?._zod)?.def)?.type;
-		let tsType = "string";
-		if (typeName === "number") tsType = "number";
-		else if (typeName === "boolean") tsType = "boolean";
+		const fieldSchema = shape[key];
+		const rendered = renderPayloadSchemaType(fieldSchema);
 		return {
 			name: key,
-			type: tsType
+			type: rendered.type,
+			optional: rendered.optional,
+			comment: rendered.comment
 		};
 	});
 	return [];
@@ -6840,7 +8186,7 @@ async function buildContextNormalizedSpecFromConfig(input) {
 	}))), config);
 }
 async function buildV5ContextArtifacts(input) {
-	return generateContextArtifacts(await buildContextNormalizedSpecFromConfig(input));
+	return generateContextArtifacts(await buildContextNormalizedSpecFromConfig(input), { infrastructureStrategy: input.infrastructureStrategy });
 }
 async function buildV5Artifacts(input) {
 	const spec = await buildNormalizedSpecFromConfig(input);
@@ -6865,8 +8211,9 @@ async function buildCompositionArtifacts(compositionConfigPath, contextSpecs) {
 	return mergeGeneratedArtifacts([
 		...buildCompositionTypeArtifacts(),
 		...buildCompositionBusArtifacts(),
-		...buildCompositionOutboxArtifacts(),
+		...buildCompositionOutboxArtifacts(compositionSpec.infrastructure),
 		...buildCompositionAclArtifacts(compositionSpec),
+		...buildCompositionDependencyManifestArtifacts(compositionSpec),
 		...buildReadModelCompositionArtifacts(composedContextSpecs),
 		...buildCompositionContainerArtifacts(compositionSpec, composedContextSpecs),
 		...buildCompositionRouterArtifacts(compositionSpec, composedContextSpecs),
@@ -6875,4 +8222,4 @@ async function buildCompositionArtifacts(compositionConfigPath, contextSpecs) {
 }
 
 //#endregion
-export { GENERATED_READ_SIDE_SCHEMA_LOGICAL_PATH, SPEC_ARTIFACT_SCHEMA_VERSION, SPEC_DIFF_SCHEMA_VERSION, VENDORED_FILE_MANIFEST, applyOwnershipIfMissing, buildArtifactPath, buildCollisionSafeModulePathNames, buildCompositionAclArtifacts, buildCompositionArtifacts, buildCompositionBusArtifacts, buildCompositionContainerArtifacts, buildCompositionOutboxArtifacts, buildCompositionRouterArtifacts, buildCompositionSpecDiff, buildCompositionSubscriptionArtifacts, buildCompositionTypeArtifacts, buildConsumerAclArtifacts, buildContextInputChecks, buildContextNormalizedSpec, buildContextNormalizedSpecFromConfig, buildContextSpecDiff, buildDrizzleConfig, buildFileArtifactTags, buildMaterializationManifestTags, buildMigrationResultTags, buildNormalizedCompositionSpec, buildNormalizedSpec, buildNormalizedSpecFromConfig, buildNormalizedSpecTags, buildProjectionArtifacts, buildReadModelCompositionArtifacts, buildSpecDiffTags, buildSummaryTags, buildV5ApplicationArtifacts, buildV5ApplicationContextArtifacts, buildV5Artifacts, buildV5ContextArtifacts, buildV5DomainArtifacts, buildV5InfrastructureArtifacts, buildV5InfrastructureContextArtifacts, buildV5LibArtifacts, buildV5PortArtifacts, buildV5PresentationArtifacts, buildV5RouteArtifacts, buildV5SharedKernelArtifacts, buildV5TestArtifacts, buildVendoredFileTags, camelCase, collectOwnedValueObjects, compositionSpecDiffDataName, contextArtifactOwnership, contextSpecDiffDataName, contractFileName, createGeneratedArtifact, discoverReferencedVos, ensureContextSupportFilesExist, filterPerContextArtifactsForComposition, flattenEntities, generateContextArtifacts, inferArtifactOwnership, inferCodegenSupportPathForContext, inferCodegenSupportPathFromSchemaFile, inferReconcileScopes, introspectObjectShape, introspectSchema, isRegisteredEntity, kebabCase, loadContextConfig, mergeGeneratedArtifacts, mergeSchemaReadResults, normalizeModulePath, parseConnectionString, parseDrizzleKitOutput, pascalCase, prepareAllVendoredFiles, prepareVendoredFile, readSchemaFile, repositoryPortFileName, repositoryPortTypeName, resolveAbsoluteContextInputs, resolveArtifactOwnership, resolveContextInputs, resolveFactoryPath, resolveGeneratedMigrationSchemaPath, resolveMethodContextInputsForCheck, resolveSchemaFilePathsForContext, resolveVoOwner, rewriteImports, runMigration, serializeCompositionSpec, serializeContextSpec, sharedArtifactOwnership, sliceArtifactOwnership, sliceContextIntoAggregateViews, snakeCase, snakeUpperCase, toImportURL, toUpperSnakeCase, unwrapFieldType, validateContextImports, walkEntityTree, withArtifactOwnership, wordsFromName };
+export { GENERATED_READ_SIDE_SCHEMA_LOGICAL_PATH, SPEC_ARTIFACT_SCHEMA_VERSION, SPEC_DIFF_SCHEMA_VERSION, VENDORED_FILE_MANIFEST, applyOwnershipIfMissing, buildArtifactPath, buildCollisionSafeModulePathNames, buildCompositionAclArtifacts, buildCompositionArtifacts, buildCompositionBusArtifacts, buildCompositionContainerArtifacts, buildCompositionDependencyManifestArtifacts, buildCompositionOutboxArtifacts, buildCompositionRouterArtifacts, buildCompositionSpecDiff, buildCompositionSubscriptionArtifacts, buildCompositionTypeArtifacts, buildConsumerAclArtifacts, buildContextInputChecks, buildContextNormalizedSpec, buildContextNormalizedSpecFromConfig, buildContextSpecDiff, buildDrizzleConfig, buildFileArtifactTags, buildMaterializationManifestTags, buildMigrationResultTags, buildNormalizedCompositionSpec, buildNormalizedSpec, buildNormalizedSpecFromConfig, buildNormalizedSpecTags, buildProjectionArtifacts, buildReadModelCompositionArtifacts, buildSpecDiffTags, buildSummaryTags, buildV5ApplicationArtifacts, buildV5ApplicationContextArtifacts, buildV5Artifacts, buildV5ContextArtifacts, buildV5DomainArtifacts, buildV5InfrastructureArtifacts, buildV5InfrastructureContextArtifacts, buildV5LibArtifacts, buildV5PortArtifacts, buildV5PresentationArtifacts, buildV5RouteArtifacts, buildV5SharedKernelArtifacts, buildV5TestArtifacts, buildVendoredFileTags, camelCase, collectOwnedValueObjects, compositionSpecDiffDataName, contextArtifactOwnership, contextSpecDiffDataName, contractFileName, createGeneratedArtifact, discoverReferencedVos, ensureContextSupportFilesExist, filterPerContextArtifactsForComposition, flattenEntities, generateContextArtifacts, inferArtifactOwnership, inferCodegenSupportPathForContext, inferCodegenSupportPathFromSchemaFile, inferReconcileScopes, introspectObjectShape, introspectSchema, isRegisteredEntity, kebabCase, loadContextConfig, mergeGeneratedArtifacts, mergeSchemaReadResults, normalizeModulePath, parseConnectionString, parseDrizzleKitOutput, pascalCase, prepareAllVendoredFiles, prepareVendoredFile, readSchemaFile, repositoryPortFileName, repositoryPortTypeName, resolveAbsoluteContextInputs, resolveArtifactOwnership, resolveContextInputs, resolveFactoryPath, resolveGeneratedMigrationSchemaPath, resolveMethodContextInputsForCheck, resolveSchemaFilePathsForContext, resolveVoOwner, rewriteImports, runMigration, serializeCompositionSpec, serializeContextSpec, sharedArtifactOwnership, sliceArtifactOwnership, sliceContextIntoAggregateViews, snakeCase, snakeUpperCase, toImportURL, toUpperSnakeCase, unwrapFieldType, validateContextImports, walkEntityTree, withArtifactOwnership, wordsFromName };