@zodmire/core 0.1.1 → 0.1.3

package/mod.mjs

@@ -1,4 +1,4 @@
-import { a as mergeGeneratedArtifacts, c as sliceArtifactOwnership, i as inferArtifactOwnership, l as withArtifactOwnership, n as contextArtifactOwnership, o as resolveArtifactOwnership, r as createGeneratedArtifact, s as sharedArtifactOwnership, t as applyOwnershipIfMissing } from "./artifacts-CUzHfc15.mjs";
+import { a as mergeGeneratedArtifacts, c as sliceArtifactOwnership, i as inferArtifactOwnership, l as userArtifactOwnership, n as contextArtifactOwnership, o as resolveArtifactOwnership, r as createGeneratedArtifact, s as sharedArtifactOwnership, t as applyOwnershipIfMissing, u as withArtifactOwnership } from "./artifacts-D0E751FX.mjs";
 import { zx } from "@traversable/zod";
 import { z } from "zod";
 import { isAbsolute, join, normalize, relative, resolve } from "node:path";
@@ -107,10 +107,83 @@ const ZOD_TYPE_MAP = {
 	nan: "number",
 	literal: "literal"
 };
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+function getZodDef(schema) {
+	if (!isRecord(schema)) return void 0;
+	const rawZod = schema["_zod"];
+	if (!isRecord(rawZod)) return void 0;
+	const def = rawZod["def"];
+	return isRecord(def) ? def : void 0;
+}
 function isZodSchemaLike(schema) {
-	if (!schema || typeof schema !== "object") return false;
-	if (!("_zod" in schema)) return false;
-	return typeof schema._zod?.def?.type === "string";
+	return typeof getZodDef(schema)?.type === "string";
+}
+function deriveLegacyQueryOutputMeta(meta) {
+	const metaRecord = meta;
+	const readModelName = typeof metaRecord["readModelName"] === "string" ? metaRecord["readModelName"] : void 0;
+	const targetAggregate = typeof metaRecord["targetAggregate"] === "string" ? metaRecord["targetAggregate"] : void 0;
+	const computedFields = metaRecord["computedFields"];
+	return {
+		...readModelName !== void 0 ? { readModelName } : {},
+		...targetAggregate !== void 0 ? { targetAggregate } : {},
+		...computedFields !== void 0 ? { computedFields } : {}
+	};
+}
+function deriveLegacyQueryInputMeta(meta) {
+	const metaRecord = meta;
+	const readSide = metaRecord["readSide"];
+	const readSideReadModelName = isRecord(readSide) && typeof readSide["readModelName"] === "string" ? readSide["readModelName"] : void 0;
+	const legacyReadModelName = typeof metaRecord["readModelName"] === "string" ? metaRecord["readModelName"] : void 0;
+	const computedFields = metaRecord["computedFields"];
+	return {
+		...readSideReadModelName !== void 0 ? { readModelName: readSideReadModelName } : legacyReadModelName !== void 0 ? { readModelName: legacyReadModelName } : {},
+		...computedFields !== void 0 ? { computedFields } : {}
+	};
+}
+const SCALAR_TYPE_MAP = {
+	string: {
+		kind: "scalar",
+		scalar: "string"
+	},
+	number: {
+		kind: "scalar",
+		scalar: "number"
+	},
+	boolean: {
+		kind: "scalar",
+		scalar: "boolean"
+	},
+	date: {
+		kind: "scalar",
+		scalar: "date"
+	},
+	bigint: {
+		kind: "scalar",
+		scalar: "bigint"
+	}
+};
+function deriveScalarDescriptor(mapped) {
+	return SCALAR_TYPE_MAP[mapped] ?? {
+		kind: "unknown",
+		rawType: mapped
+	};
+}
+function extractEnumValues(schema) {
+	const zodDef = getZodDef(schema);
+	if (!zodDef) return void 0;
+	const entries = zodDef.entries;
+	if (Array.isArray(entries)) return entries.filter((e) => typeof e === "string");
+	const values = zodDef.values;
+	if (Array.isArray(values)) return values.filter((v) => typeof v === "string");
+}
+function extractLiteralValue(schema) {
+	const zodDef = getZodDef(schema);
+	if (!zodDef) return null;
+	const value = zodDef.value;
+	if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") return value;
+	return null;
 }
 function unsupportedSchemaNodeError(exportName, nodeType) {
 	const target = exportName ?? "<unknown export>";
@@ -140,6 +213,7 @@ function createReadField(exportName) {
 				const inner = def.element;
 				return {
 					type: inner.type,
+					typeDescriptor: inner.typeDescriptor,
 					optional: false,
 					array: true,
 					sourceSchema: rawSchema,
@@ -149,17 +223,65 @@ function createReadField(exportName) {
 			}
 			case zx.tagged("enum")(rawSchema): return {
 				type: "enum",
+				typeDescriptor: {
+					kind: "enum",
+					values: extractEnumValues(rawSchema)
+				},
 				optional: false,
 				array: false,
 				sourceSchema: rawSchema
 			};
 			case zx.tagged("object")(rawSchema): return {
 				type: "object",
+				typeDescriptor: { kind: "object" },
 				optional: false,
 				array: false,
 				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",
+					typeDescriptor: { kind: "object" },
+					optional: false,
+					array: false,
+					sourceSchema: rawSchema,
+					objectShape: {
+						...left.objectShape,
+						...right.objectShape
+					}
+				};
+				return {
+					type: "intersection",
+					typeDescriptor: { kind: "intersection" },
+					optional: false,
+					array: false,
+					sourceSchema: rawSchema
+				};
+			}
+			case zx.tagged("union")(rawSchema): return {
+				type: "union",
+				typeDescriptor: { kind: "union" },
+				optional: false,
+				array: false,
+				sourceSchema: rawSchema
+			};
+			case zx.tagged("record")(rawSchema): return {
+				type: "record",
+				typeDescriptor: { kind: "record" },
+				optional: false,
+				array: false,
+				sourceSchema: rawSchema
+			};
+			case zx.tagged("tuple")(rawSchema): return {
+				type: "tuple",
+				typeDescriptor: { kind: "tuple" },
+				optional: false,
+				array: false,
+				sourceSchema: rawSchema
+			};
 			case zx.tagged("string")(rawSchema):
 			case zx.tagged("number")(rawSchema):
 			case zx.tagged("int")(rawSchema):
@@ -173,9 +295,22 @@ function createReadField(exportName) {
 			case zx.tagged("any")(rawSchema):
 			case zx.tagged("unknown")(rawSchema):
 			case zx.tagged("never")(rawSchema):
-			case zx.tagged("nan")(rawSchema):
+			case zx.tagged("nan")(rawSchema): {
+				const mapped = ZOD_TYPE_MAP[raw._zod.def.type] ?? raw._zod.def.type;
+				return {
+					type: mapped,
+					typeDescriptor: deriveScalarDescriptor(mapped),
+					optional: false,
+					array: false,
+					sourceSchema: rawSchema
+				};
+			}
 			case zx.tagged("literal")(rawSchema): return {
-				type: ZOD_TYPE_MAP[raw._zod.def.type] ?? raw._zod.def.type,
+				type: "literal",
+				typeDescriptor: {
+					kind: "literal",
+					value: extractLiteralValue(rawSchema)
+				},
 				optional: false,
 				array: false,
 				sourceSchema: rawSchema
@@ -200,8 +335,14 @@ function toIntrospectedField(name, read, registry) {
 		optional: read.optional,
 		array: read.array
 	};
+	if (read.typeDescriptor) field.typeDescriptor = read.typeDescriptor;
 	const fieldMeta = registry.get(read.sourceSchema);
 	if (fieldMeta?.kind === "field" && fieldMeta.columnType) field.columnType = fieldMeta.columnType;
+	if (fieldMeta?.kind === "field" && fieldMeta.idType) field.typeDescriptor = {
+		kind: "branded",
+		brand: fieldMeta.idType,
+		underlying: read.type === "number" ? "number" : "string"
+	};
 	if (read.objectShape) field.nestedFields = Object.entries(read.objectShape).map(([childName, childRead]) => toIntrospectedField(childName, childRead, registry));
 	return field;
 }
@@ -289,7 +430,7 @@ function introspectSchema(schema, registry, exportName) {
 	};
 }
 function deriveSchemaName(schema) {
-	const typeName = schema?.constructor?.name;
+	const typeName = isRecord(schema) && "constructor" in schema ? schema.constructor?.name : void 0;
 	if (typeName && typeName !== "Object" && typeName !== "ZodObject") return typeName.replace(/Schema$/, "");
 	return "UnnamedEntity";
 }
@@ -309,14 +450,12 @@ async function readSchemaFile(filePath, registry) {
 	const queryOutputs = /* @__PURE__ */ new Map();
 	const schemaExportNames = /* @__PURE__ */ new Map();
 	for (const [exportName, exported] of Object.entries(mod)) {
-		if (!exported || typeof exported !== "object") continue;
-		if (!("_zod" in exported)) continue;
+		if (!isZodSchemaLike(exported)) continue;
 		schemaExportNames.set(exported, exportName);
 	}
 	const childEntitySchemas = /* @__PURE__ */ new Set();
 	for (const [exportName, exported] of Object.entries(mod)) {
-		if (!exported || typeof exported !== "object") continue;
-		if (!("_zod" in exported)) continue;
+		if (!isZodSchemaLike(exported)) continue;
 		const meta = registry.get(exported);
 		if (!meta) continue;
 		switch (meta.kind) {
@@ -365,29 +504,27 @@ async function readSchemaFile(filePath, registry) {
 			}
 			case "query-input": {
 				const fields = introspectObjectShape(exported, registry, exportName);
-				const legacyMeta = meta;
+				const legacyMeta = deriveLegacyQueryInputMeta(meta);
 				queryInputs.set(meta.queryName, {
 					fields,
 					targetAggregate: meta.targetAggregate,
-					readModelName: meta.readSide?.readModelName ?? legacyMeta.readModelName,
-					queryKind: "queryKind" in meta ? meta.queryKind : "findById",
-					pagination: "pagination" in meta ? meta.pagination : void 0,
-					filters: "filters" in meta ? meta.filters : void 0,
-					sorting: "sorting" in meta ? meta.sorting : void 0,
-					computedFields: "computedFields" in meta ? meta.computedFields : legacyMeta.computedFields
+					readModelName: legacyMeta.readModelName,
+					queryKind: meta.queryKind,
+					pagination: meta.queryKind === "list" ? meta.pagination : void 0,
+					filters: meta.queryKind === "list" ? meta.filters : void 0,
+					sorting: meta.queryKind === "list" ? meta.sorting : void 0,
+					computedFields: legacyMeta.computedFields
 				});
 				break;
 			}
 			case "query-output": {
 				const fields = introspectObjectShape(exported, registry, exportName);
-				const legacyMeta = meta;
+				const legacyMeta = deriveLegacyQueryOutputMeta(meta);
 				queryOutputs.set(meta.queryName, {
 					fields,
 					outputSchemaPath: filePath,
 					outputSchemaExportName: exportName,
-					...legacyMeta.readModelName !== void 0 ? { readModelName: legacyMeta.readModelName } : {},
-					...legacyMeta.targetAggregate !== void 0 ? { targetAggregate: legacyMeta.targetAggregate } : {},
-					...legacyMeta.computedFields !== void 0 ? { computedFields: legacyMeta.computedFields } : {}
+					...legacyMeta
 				});
 				break;
 			}
@@ -422,8 +559,7 @@ async function readSchemaFile(filePath, registry) {
 		}
 	}
 	for (const [exportName, exported] of Object.entries(mod)) {
-		if (!exported || typeof exported !== "object") continue;
-		if (!("_zod" in exported)) continue;
+		if (!isZodSchemaLike(exported)) continue;
 		const meta = registry.get(exported);
 		if (meta?.kind !== "entity") continue;
 		if (childEntitySchemas.has(exported)) continue;
@@ -470,8 +606,75 @@ 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 resolveWriteModelStrategy(config) {
+	if (config.writeModelStrategy) return config.writeModelStrategy;
+	return config.adapters.some((adapter) => adapter.kind === "mikroorm-repository") ? "mikroorm" : "drizzle";
+}
+function resolveReadModelStrategy(config) {
+	return config.readModelStrategy ?? "drizzle";
+}
 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 writeModelStrategy = resolveWriteModelStrategy(config);
+	const readModelStrategy = resolveReadModelStrategy(config);
 	const aggregateNames = new Set(schemaResult.aggregates.map((a) => a.name));
 	for (const cmd of schemaResult.commands) if (!aggregateNames.has(cmd.targetAggregate)) throw new Error(`[normalizer] Command "${cmd.name}" targets aggregate "${cmd.targetAggregate}" which does not exist. Available aggregates: ${[...aggregateNames].join(", ")}`);
 	for (const q of schemaResult.queries) {
@@ -485,7 +688,6 @@ function buildContextNormalizedSpec(schemaResult, config) {
 	}
 	for (const q of schemaResult.queries) if (q.queryKind === "list") {
 		if (!q.pagination) throw new Error(`[normalizer] List query "${q.name}" is missing pagination config`);
-		if (q.pagination.style === "cursor") throw new Error(`[normalizer] List query "${q.name}" uses cursor pagination which is not supported in v12`);
 		if (!q.filters) throw new Error(`[normalizer] List query "${q.name}" is missing filters config`);
 		if (!q.sorting) throw new Error(`[normalizer] List query "${q.name}" is missing sorting config`);
 		if (!q.sorting.sortableFields.includes(q.sorting.defaultSort.field)) throw new Error(`[normalizer] List query "${q.name}": defaultSort.field "${q.sorting.defaultSort.field}" is not in sortableFields`);
@@ -653,7 +855,8 @@ function buildContextNormalizedSpec(schemaResult, config) {
 			sources: projection.sources.map((source) => ({
 				...source,
 				locality: source.contextName === config.name ? "local" : "external"
-			}))
+			})),
+			capabilities: deriveProjectionCapabilities(projection, readModelByName)
 		};
 	});
 	return {
@@ -685,13 +888,15 @@ 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: [],
-				pagination: q.pagination?.style === "offset" ? { style: "offset" } : void 0,
+				pagination: q.pagination,
 				filters: q.filters,
 				sorting: q.sorting?.sortableFields ? q.sorting : void 0
 			};
@@ -743,10 +948,11 @@ function buildContextNormalizedSpec(schemaResult, config) {
 					outputSchemaExportName: q.outputSchemaExportName,
 					readModelName: q.readModelName,
 					readSide,
-					pagination: { style: "offset" },
+					pagination: q.pagination ?? { style: "offset" },
 					filters: q.filters,
 					sorting: q.sorting,
-					computedFields: resolvedComputed
+					computedFields: resolvedComputed,
+					capability
 				};
 			}
 			return {
@@ -758,7 +964,8 @@ function buildContextNormalizedSpec(schemaResult, config) {
 				outputSchemaPath: q.outputSchemaPath,
 				outputSchemaExportName: q.outputSchemaExportName,
 				readModelName: q.readModelName,
-				readSide
+				readSide,
+				capability
 			};
 		}),
 		readModels: normalizedReadModels,
@@ -772,7 +979,9 @@ function buildContextNormalizedSpec(schemaResult, config) {
 		adapters: config.adapters,
 		acls: config.acls,
 		presentation: config.presentation,
-		materialization: config.materialization
+		materialization: config.materialization,
+		writeModelStrategy,
+		readModelStrategy
 	};
 }
 function buildNormalizedSpec(schemaResult, config) {
@@ -790,7 +999,9 @@ function buildNormalizedSpec(schemaResult, config) {
 		ports: contextSpec.ports,
 		adapters: contextSpec.adapters,
 		presentation: contextSpec.presentation,
-		materialization: contextSpec.materialization
+		materialization: contextSpec.materialization,
+		writeModelStrategy: contextSpec.writeModelStrategy,
+		readModelStrategy: contextSpec.readModelStrategy
 	};
 }
 
@@ -824,14 +1035,25 @@ function walkEntityTree(aggregate, visitor) {
 
 //#endregion
 //#region packages/core/composition_normalizer.ts
+function deriveContextRefFromConfigPath(contextConfigPath) {
+	const normalized = contextConfigPath.replace(/\\/g, "/");
+	return normalized.slice(normalized.lastIndexOf("/") + 1).replace(/\.context\.[cm]?ts$/i, "").replace(/\.[cm]?ts$/i, "");
+}
+function getConfiguredContextRefs(config) {
+	const contextConfigs = Array.isArray(config.contextConfigs) ? config.contextConfigs : [];
+	if (contextConfigs.length > 0) return contextConfigs.map((entry) => deriveContextRefFromConfigPath(entry.contextConfigPath));
+	return Array.isArray(config.contexts) ? config.contexts : [];
+}
 function buildNormalizedCompositionSpec(config, contextSpecs) {
 	assertUniqueCanonicalContextSpecs(contextSpecs);
+	const infrastructure = resolveInfrastructureStrategy(config.infrastructure);
 	const resolveProvidedContextRef = createContextRefResolver(contextSpecs);
+	const configuredContextRefs = getConfiguredContextRefs(config);
 	const resolvedContexts = [];
 	const resolvedContextSpecs = [];
 	const seenResolvedModulePaths = /* @__PURE__ */ new Set();
 	const seenResolvedDisplayNames = /* @__PURE__ */ new Map();
-	for (const ctxRef of config.contexts) {
+	for (const ctxRef of configuredContextRefs) {
 		const spec = resolveProvidedContextRef(ctxRef, "Context");
 		const canonicalModulePath = spec.context.modulePath.toLowerCase();
 		if (seenResolvedModulePaths.has(canonicalModulePath)) throw new Error(`[composition_normalizer] Context "${ctxRef}" resolves to duplicate composed context "${spec.context.name}" (${spec.context.modulePath})`);
@@ -851,11 +1073,11 @@ function buildNormalizedCompositionSpec(config, contextSpecs) {
 	validateExternalProjectionSources(resolvedContextSpecs, resolveCompositionContextRef, resolvedContexts.map((context) => context.modulePath));
 	const crossContextEvents = [];
 	for (const evt of config.crossContextEvents) {
-		const sourceSpec = resolveCompositionMemberContextRef(resolveCompositionContextRef, evt.sourceContext, `sourceContext`, `event "${evt.eventType}"`, config.contexts);
+		const sourceSpec = resolveCompositionMemberContextRef(resolveCompositionContextRef, evt.sourceContext, `sourceContext`, `event "${evt.eventType}"`, configuredContextRefs);
 		const [, eventNamePart] = evt.eventType.split(".");
 		const resolvedSubs = [];
 		for (const sub of evt.subscriptions) {
-			const targetSpec = resolveCompositionMemberContextRef(resolveCompositionContextRef, sub.targetContext, `targetContext`, `subscription for event "${evt.eventType}"`, config.contexts);
+			const targetSpec = resolveCompositionMemberContextRef(resolveCompositionContextRef, sub.targetContext, `targetContext`, `subscription for event "${evt.eventType}"`, configuredContextRefs);
 			if (sourceSpec.context.name.toLowerCase() === targetSpec.context.name.toLowerCase() && sourceSpec.context.modulePath.toLowerCase() === targetSpec.context.modulePath.toLowerCase()) throw new Error(`[composition_normalizer] sourceContext and targetContext are the same ("${evt.sourceContext}") in event "${evt.eventType}". Cross-context events must target a different context.`);
 			const commandNames = targetSpec.commands.map((c) => c.name);
 			if (!commandNames.includes(sub.action)) throw new Error(`[composition_normalizer] action "${sub.action}" in subscription for event "${evt.eventType}" does not match any command in target context "${sub.targetContext}". Available commands: ${commandNames.join(", ")}`);
@@ -884,9 +1106,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) {
@@ -1127,6 +1400,8 @@ function sliceContextIntoAggregateViews(contextSpec) {
 			adapters,
 			presentation: contextSpec.presentation,
 			materialization: contextSpec.materialization,
+			writeModelStrategy: contextSpec.writeModelStrategy,
+			readModelStrategy: contextSpec.readModelStrategy,
 			externalValueObjects: externalVos
 		};
 	});
@@ -1140,6 +1415,55 @@ function aggregateVariableName$1(spec) {
 function aggregateIdPropertyName$1(spec) {
 	return `${aggregateVariableName$1(spec)}Id`;
 }
+function defaultIdBrandName$1(name) {
+	const base = pascalCase(name);
+	return base.endsWith("Id") ? base : `${base}Id`;
+}
+/**
+* If targetField is a string-typed field whose name ends with "Id",
+* the source expression likely holds a BrandedId object — unwrap it.
+*/
+function maybeUnwrapBrandedId(expression, targetField, sourceOptional = false) {
+	if (targetField.type !== "string") return expression;
+	if (!camelCase(targetField.name).endsWith("Id")) return expression;
+	if (sourceOptional) return `(() => { const value = ${expression}; return value == null ? undefined : brandedIdToString(value); })()`;
+	return `brandedIdToString(${expression})`;
+}
+function metadataFieldFallback$1(field) {
+	const fieldName = camelCase(field.name);
+	if (fieldName === "recordedBy") return field.type === "string" ? "eventContext.recordedBy.value" : "eventContext.recordedBy";
+	if (fieldName === "correlationId") return "eventContext.correlationId";
+	if (fieldName === "causationId") return "eventContext.causationId";
+	if (fieldName === "occurredAt" || fieldName === "createdAt") return field.type === "date" ? "new Date()" : "new Date().toISOString()";
+}
+function placeholderValueForField$2(field) {
+	if (field.type === "object" && field.nestedFields && field.nestedFields.length > 0) {
+		const nestedEntries = field.nestedFields.map((nestedField) => `${camelCase(nestedField.name)}: ${placeholderValueForField$2(nestedField)}`);
+		const objectLiteral = nestedEntries.length > 0 ? `{ ${nestedEntries.join(", ")} }` : "{}";
+		return field.array ? "[]" : objectLiteral;
+	}
+	if (field.array) return "[]";
+	switch (field.type) {
+		case "number": return "0";
+		case "boolean": return "false";
+		case "date": return "new Date()";
+		default: return "\"\"";
+	}
+}
+function fieldNameTokens(name) {
+	return snakeCase(name).split("_").filter(Boolean);
+}
+function findSuffixMatchingField(targetFieldName, fields) {
+	const targetTokens = fieldNameTokens(targetFieldName);
+	return fields.filter((field) => {
+		const candidateTokens = fieldNameTokens(field.name);
+		if (candidateTokens.length < targetTokens.length) return false;
+		return targetTokens.every((token, index) => candidateTokens[candidateTokens.length - targetTokens.length + index] === token);
+	}).sort((left, right) => fieldNameTokens(left.name).length - fieldNameTokens(right.name).length)[0];
+}
+function aggregateBackingFieldName(name) {
+	return `_${camelCase(name)}`;
+}
 function formatFieldType$1(field, indent = 0) {
 	if (field.type === "object" && field.nestedFields && field.nestedFields.length > 0) {
 		const objectType = `{\n${field.nestedFields.map((nestedField) => {
@@ -1196,6 +1520,10 @@ function getRehydrationGuardName(shape) {
 function annotateCompiledPredicateParameters$1(source) {
 	return source.replace(/function check\s*\(\s*([A-Za-z_$][\w$]*)\s*\)/g, "function check ($1: any)").replace(/\(\s*([A-Za-z_$][\w$]*)\s*\)\s*=>/g, "($1: any) =>");
 }
+function pruneUnusedBrandedIdImport$1(content) {
+	if (content.includes("brandedIdToString(")) return content;
+	return content.replace(`import { brandedIdToString, type BrandedId } from "../../../../../../lib/branded-id.ts";`, `import type { BrandedId } from "../../../../../../lib/branded-id.ts";`);
+}
 function getRehydrationFieldSpecsName(shape) {
 	return `${pascalCase(shape.name)}RehydrationFieldSpecs`;
 }
@@ -1358,15 +1686,17 @@ function renderEffectValue(value, inputVar, selfRef = "this") {
 	if (value === "now" || value === "now()") return "new Date()";
 	if (value.startsWith("'") && value.endsWith("'")) return `"${value.slice(1, -1)}"`;
 	if (/^\d+$/.test(value)) return value;
-	return value.replaceAll(/\binput\.([A-Za-z0-9_]+)/g, (_match, fieldName) => `${inputVar}.${camelCase(fieldName)}`).replaceAll(/\baggregate\.([A-Za-z0-9_]+)/g, (_match, fieldName) => `${selfRef}.${camelCase(fieldName)}`);
+	return value.replace(/\binput\.([A-Za-z0-9_]+)/g, (_match, fieldName) => `${inputVar}.${camelCase(fieldName)}`).replace(/\baggregate\.([A-Za-z0-9_]+)/g, (_match, fieldName) => `${selfRef}.${camelCase(fieldName)}`);
 }
-function renderEffectLines(effects, inputVar, spec, indent, selfRef = "this", isCreate = false, availableInputFields = /* @__PURE__ */ new Set()) {
+function renderEffectLines(effects, inputVar, spec, indent, selfRef = "this", isCreate = false, availableInputFields = /* @__PURE__ */ new Set(), inputFieldOptionality = /* @__PURE__ */ new Map()) {
 	const contextName = spec.context.name;
 	const aggregateName = pascalCase(spec.aggregate.name);
 	const aggregateFieldNames = new Set(filterManagedAggregateFields$1(spec.aggregate.fields ?? []).map((f) => camelCase(f.name)));
 	const aggregateFieldsByName = new Map(filterManagedAggregateFields$1(spec.aggregate.fields ?? []).map((field) => [camelCase(field.name), field]));
 	let lastPushedEntityVar = null;
 	let lastPushedEntityIdField = null;
+	let lastPushedEntityTypeName = null;
+	let lastPushedEntityFields = null;
 	const idFieldName = spec.aggregate.idField ? camelCase(spec.aggregate.idField) : null;
 	const lines = [];
 	for (const effect of effects) switch (effect.kind) {
@@ -1375,7 +1705,11 @@ function renderEffectLines(effects, inputVar, spec, indent, selfRef = "this", is
 			if (RESERVED_AGGREGATE_FIELD_NAMES$2.has(camelCase(effect.target))) break;
 			const targetField = aggregateFieldsByName.get(camelCase(effect.target));
 			const renderedValue = (effect.value === "now" || effect.value === "now()") && targetField ? targetField.type === "date" || targetField.type === "Date" ? "new Date()" : "new Date().toISOString()" : renderEffectValue(effect.value, inputVar, selfRef);
-			lines.push(`${indent}${selfRef}.${camelCase(effect.target)} = ${renderedValue};`);
+			const targetAccessor = aggregateFieldNames.has(camelCase(effect.target)) ? `${selfRef}.${aggregateBackingFieldName(effect.target)}` : `${selfRef}.${camelCase(effect.target)}`;
+			if (effect.value?.startsWith("input.") && inputFieldOptionality.get(camelCase(effect.value.slice(6)))) {
+				const inputFieldName = camelCase(effect.value.slice(6));
+				lines.push(`${indent}if (${inputVar}.${inputFieldName} !== undefined) {`, `${indent}  ${targetAccessor} = ${renderedValue};`, `${indent}}`);
+			} else lines.push(`${indent}${targetAccessor} = ${renderedValue};`);
 			break;
 		case "raise-event": {
 			if (isCreate) break;
@@ -1388,29 +1722,42 @@ function renderEffectLines(effects, inputVar, spec, indent, selfRef = "this", is
 				if (lastPushedEntityIdField && fieldName === camelCase(lastPushedEntityIdField)) return `${fieldName}: ${lastPushedEntityVar}.id.value`;
 				if (aggregateFieldNames.has(fieldName)) {
 					const aggregateField = aggregateFieldsByName.get(fieldName);
-					const aggregateAccess = `${selfRef}.${fieldName}`;
-					const metadataFallback = fieldName === "occurredAt" || fieldName.endsWith("At") ? f.type === "date" ? "new Date()" : "new Date().toISOString()" : fieldName === "recordedBy" || fieldName.endsWith("By") ? f.type === "string" ? "eventContext.recordedBy.value" : "eventContext.recordedBy" : void 0;
+					const aggregateAccess = maybeUnwrapBrandedId(`${selfRef}.${fieldName}`, f, aggregateField?.optional ?? false);
+					const metadataFallback = metadataFieldFallback$1(f);
 					if (aggregateField?.optional) {
-						if (availableInputFields.has(fieldName)) return `${fieldName}: ${aggregateAccess} ?? ${inputVar}.${fieldName}`;
-						if (metadataFallback) return `${fieldName}: ${aggregateAccess} ?? ${metadataFallback}`;
+						if (availableInputFields.has(fieldName)) return `${fieldName}: (${aggregateAccess} ?? ${maybeUnwrapBrandedId(`${inputVar}.${fieldName}`, f, inputFieldOptionality.get(fieldName) ?? false)}) as ${eventName}Payload["${fieldName}"]`;
+						if (metadataFallback) return `${fieldName}: (${aggregateAccess} ?? ${metadataFallback}) as ${eventName}Payload["${fieldName}"]`;
 						return `${fieldName}: ${aggregateAccess} as ${eventName}Payload["${fieldName}"]`;
 					}
 					return `${fieldName}: ${aggregateAccess}`;
 				}
-				if (lastPushedEntityVar && !aggregateFieldNames.has(fieldName)) return `${fieldName}: (${lastPushedEntityVar} as any).${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}"]`;
+				if (lastPushedEntityVar && !aggregateFieldNames.has(fieldName)) {
+					const entityType = lastPushedEntityTypeName ?? "Record<string, unknown>";
+					const matchedEntityField = lastPushedEntityFields ? findSuffixMatchingField(fieldName, lastPushedEntityFields) : void 0;
+					if (matchedEntityField) return `${fieldName}: ${maybeUnwrapBrandedId(`(${lastPushedEntityVar} as ${entityType}).${camelCase(matchedEntityField.name)}`, f, matchedEntityField.optional)}${matchedEntityField.optional ? ` as ${eventName}Payload["${fieldName}"]` : ""}`;
+					if (fieldName.endsWith("Id")) return `${fieldName}: ${lastPushedEntityVar}.id.value`;
+				}
+				if (availableInputFields.has(fieldName)) return `${fieldName}: ${maybeUnwrapBrandedId(`${inputVar}.${fieldName}`, f, inputFieldOptionality.get(fieldName) ?? false)} as ${eventName}Payload["${fieldName}"]`;
+				const matchingEffect = effects.find((candidateEffect) => candidateEffect.kind === "set-field" && camelCase(candidateEffect.target) === fieldName);
+				if (matchingEffect?.value) return `${fieldName}: ${renderEffectValue(matchingEffect.value, inputVar, selfRef)}`;
+				const metadataFallback = metadataFieldFallback$1(f);
+				if (metadataFallback) return `${fieldName}: ${metadataFallback}`;
+				return `${fieldName}: undefined as unknown as ${eventName}Payload["${fieldName}"] /* TODO: unmapped ${eventName} payload field "${fieldName}" */`;
 			}).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;
 		}
 		case "increment":
-			lines.push(`${indent}${selfRef}.${camelCase(effect.target)} += ${effect.value ?? "1"};`);
+			{
+				const targetAccessor = aggregateFieldNames.has(camelCase(effect.target)) ? `${selfRef}.${aggregateBackingFieldName(effect.target)}` : `${selfRef}.${camelCase(effect.target)}`;
+				lines.push(`${indent}${targetAccessor} += ${effect.value ?? "1"};`);
+			}
 			break;
 		case "decrement":
-			lines.push(`${indent}${selfRef}.${camelCase(effect.target)} -= ${effect.value ?? "1"};`);
+			{
+				const targetAccessor = aggregateFieldNames.has(camelCase(effect.target)) ? `${selfRef}.${aggregateBackingFieldName(effect.target)}` : `${selfRef}.${camelCase(effect.target)}`;
+				lines.push(`${indent}${targetAccessor} -= ${effect.value ?? "1"};`);
+			}
 			break;
 		case "push-to-collection": {
 			const targetChild = spec.aggregate.children?.find((c) => c.collectionFieldName === effect.target);
@@ -1418,9 +1765,19 @@ function renderEffectLines(effects, inputVar, spec, indent, selfRef = "this", is
 				const entityName = pascalCase(targetChild.name);
 				const createIdFn = `create${entityName}Id`;
 				const entityVar = camelCase(targetChild.name);
+				const childAssignmentLines = targetChild.fields.filter((field) => field.name !== targetChild.idField).flatMap((field) => {
+					const childFieldName = camelCase(field.name);
+					if (availableInputFields.has(childFieldName)) return [`${indent}  ${childFieldName}: ${(inputFieldOptionality.get(childFieldName) ?? false) && !field.optional ? `${inputVar}.${childFieldName} ?? ${placeholderValueForField$2(field)}` : `${inputVar}.${childFieldName}`},`];
+					const metadataFallback = metadataFieldFallback$1(field);
+					if (metadataFallback) return [`${indent}  ${childFieldName}: ${metadataFallback},`];
+					if (field.optional) return [];
+					return [`${indent}  ${childFieldName}: undefined as unknown as ${formatFieldType$1(field)} /* TODO: unmapped ${entityName} field "${childFieldName}" */,`];
+				});
 				lastPushedEntityVar = entityVar;
 				lastPushedEntityIdField = targetChild.idField;
-				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});`);
+				lastPushedEntityTypeName = entityName;
+				lastPushedEntityFields = targetChild.fields;
+				lines.push(`${indent}const ${entityVar} = ${entityName}.create({`, `${indent}  ${camelCase(targetChild.idField)}: ${createIdFn}(crypto.randomUUID()),`, ...childAssignmentLines, `${indent}});`, `${indent}${selfRef}.${camelCase(effect.target)}.push(${entityVar});`);
 			} else lines.push(`${indent}${selfRef}.${camelCase(effect.target)}.push(${renderEffectValue(effect.value, inputVar, selfRef)});`);
 			break;
 		}
@@ -1435,11 +1792,16 @@ function createAggregateStub(spec) {
 	const idField = spec.aggregate.idField;
 	const idType = spec.aggregate.idType;
 	const nonIdFields = fields.filter((f) => f.name !== idField);
+	const aggregatePropFieldNames = new Set(nonIdFields.map((field) => camelCase(field.name)));
 	const commands = spec.commands.filter((c) => c.targetAggregate === spec.aggregate.name);
 	const createCmd = commands.find((c) => c.commandKind === "create" && c.effects?.length);
 	const mutationCmds = commands.filter((c) => c.commandKind !== "create" && c.effects?.length);
 	const mutatedFieldNames = /* @__PURE__ */ new Set();
-	for (const cmd of commands) if (cmd.effects) {
+	const createMutationEffects = createCmd ? createCmd.effects.filter((effect) => effect.kind !== "set-field" || effect.value !== `input.${effect.target}`) : [];
+	for (const cmd of [...mutationCmds, ...createMutationEffects.length > 0 ? [{
+		...createCmd,
+		effects: createMutationEffects
+	}] : []]) if (cmd.effects) {
 		for (const eff of cmd.effects) if (eff.kind === "set-field" || eff.kind === "increment" || eff.kind === "decrement") mutatedFieldNames.add(camelCase(eff.target));
 	}
 	const domainImports = [
@@ -1467,20 +1829,23 @@ function createAggregateStub(spec) {
 	const eventImports = [];
 	if (mutationRaisedEvents.size > 0) eventImports.push(`import { createDomainEvent } from "../../../../../../lib/domain-event.base.ts";`);
 	if (needsEventContextImport) eventImports.push(`import type { EventContext } from "../../../../../shared-kernel/events/event-context.ts";`);
+	let needsBrandedIdToString = false;
 	for (const evtName of mutationRaisedEvents) {
 		const payloadName = `${pascalCase(evtName)}Payload`;
 		const eventFileName = kebabCase(evtName);
 		eventImports.push(`import type { ${payloadName} } from "../../events/${eventFileName}.event.ts";`);
+		if (spec.domainEvents.find((e) => pascalCase(e.name) === pascalCase(evtName))?.fields.some((f) => f.type === "string" && camelCase(f.name).endsWith("Id"))) needsBrandedIdToString = true;
 	}
+	if (needsBrandedIdToString) domainImports[1] = `import { brandedIdToString, type BrandedId } from "../../../../../../lib/branded-id.ts";`;
 	const invariantMap = /* @__PURE__ */ new Map();
 	for (const inv of spec.aggregate.invariants ?? []) invariantMap.set(inv.name, inv);
 	const domainErrorByInvariant = /* @__PURE__ */ new Map();
 	for (const errDef of spec.aggregate.domainErrors ?? []) domainErrorByInvariant.set(errDef.invariantName, errDef);
 	const referencedFactoryNames = /* @__PURE__ */ new Set();
 	const referencedErrorTypeNames = /* @__PURE__ */ new Set();
-	let needsResultImport = false;
+	let needsErrImport = false;
 	for (const cmd of mutationCmds) if (cmd.preconditions?.length) {
-		needsResultImport = true;
+		needsErrImport = true;
 		for (const pre of cmd.preconditions) {
 			const errDef = domainErrorByInvariant.get(pre);
 			if (errDef) {
@@ -1490,7 +1855,8 @@ function createAggregateStub(spec) {
 		}
 	}
 	const invariantImports = [];
-	if (needsResultImport) invariantImports.push(`import { type Result, ok, err } from "../../../../../shared-kernel/result.ts";`);
+	invariantImports.push(`import { type Result, ok${needsErrImport ? ", err" : ""} } from "../../../../../shared-kernel/result.ts";`);
+	invariantImports.push(`import type { DomainError } from "../../../../../../lib/domain-error.ts";`);
 	if (referencedFactoryNames.size > 0) {
 		const aggregateDir = kebabCase(spec.aggregate.name);
 		const imports = [...referencedFactoryNames, ...referencedErrorTypeNames].sort();
@@ -1513,21 +1879,41 @@ function createAggregateStub(spec) {
 	const classFields = nonIdFields.map((f) => {
 		const opt = f.optional ? "?" : "";
 		const fieldName = camelCase(f.name);
-		return `  ${mutatedFieldNames.has(fieldName) ? "" : "readonly "}${fieldName}${opt}: ${formatFieldType$1(f)};`;
+		return `  private ${mutatedFieldNames.has(fieldName) ? "" : "readonly "}${aggregateBackingFieldName(fieldName)}${opt}: ${formatFieldType$1(f)};`;
 	}).join("\n");
+	const scalarGetters = nonIdFields.map((f) => {
+		const opt = f.optional ? " | undefined" : "";
+		const fieldName = camelCase(f.name);
+		return `
+  get ${fieldName}(): ${formatFieldType$1(f)}${opt} {
+    return this.${aggregateBackingFieldName(fieldName)};
+  }`;
+	}).join("");
 	const collectionFields = (spec.aggregate.children ?? []).map((child) => {
 		const entityName = pascalCase(child.name);
 		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 constructorAssignments = nonIdFields.map((f) => `    this.${aggregateBackingFieldName(f.name)} = props.${camelCase(f.name)};`).join("\n");
+	const idTypeStr = `BrandedId<"${idType && idType !== "string" ? pascalCase(idType) : defaultIdBrandName$1(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")}
-    return instance;`;
-	else createBody = `    return new ${aggregateClassName}(id, 0, props);`;
+	if (createCmd?.effects?.length) {
+		const filteredCreateEffects = createCmd.effects.filter((effect) => effect.kind !== "set-field" || effect.value !== `input.${effect.target}`);
+		const createInputFields = /* @__PURE__ */ new Set();
+		for (const field of nonIdFields) createInputFields.add(camelCase(field.name));
+		for (const eff of createCmd.effects) if (eff.value?.startsWith("input.")) {
+			const inputFieldName = camelCase(eff.value.slice(6));
+			if (aggregatePropFieldNames.has(inputFieldName)) createInputFields.add(inputFieldName);
+		}
+		createBody = `    const instance = new ${aggregateClassName}(id, 0, props);
+${renderEffectLines(filteredCreateEffects, "props", spec, "    ", "instance", true, createInputFields, new Map(nonIdFields.map((field) => [camelCase(field.name), field.optional]))).join("\n")}
+    return ok(instance);`;
+	} else createBody = `    return ok(new ${aggregateClassName}(id, 0, props));`;
 	const fieldTypeMap = /* @__PURE__ */ new Map();
-	for (const f of fields ?? []) fieldTypeMap.set(camelCase(f.name), formatFieldType$1(f));
+	const fieldOptionalMap = /* @__PURE__ */ new Map();
+	for (const f of fields ?? []) {
+		fieldTypeMap.set(camelCase(f.name), formatFieldType$1(f));
+		fieldOptionalMap.set(camelCase(f.name), f.optional);
+	}
 	const mutationMethods = [];
 	for (const cmd of mutationCmds) {
 		const methodName = commandDomainMethodName$1(spec, cmd.name);
@@ -1548,24 +1934,22 @@ ${renderEffectLines(createCmd.effects, "props", spec, "    ", "instance", true).
 		if (cmd.lifecycle === "mutate") methodLines.push(`    this.incrementVersion();`);
 		const cmdEmitsEvents = (cmd.effects ?? []).some((e) => e.kind === "raise-event");
 		const inputFields = /* @__PURE__ */ new Map();
-		for (const field of cmd.inputFields ?? []) inputFields.set(camelCase(field.name), formatFieldType$1(field));
-		for (const eff of cmd.effects ?? []) {
-			if (eff.value?.startsWith("input.")) {
-				const inputFieldName = camelCase(eff.value.slice(6));
-				const targetFieldName = camelCase(eff.target);
-				const fieldType = fieldTypeMap.get(targetFieldName) ?? "unknown";
-				inputFields.set(inputFieldName, fieldType);
-			}
-			if (eff.kind === "push-to-collection") {
-				const targetChild = spec.aggregate.children?.find((c) => c.collectionFieldName === eff.target);
-				if (targetChild) {
-					for (const f of targetChild.fields) if (f.name !== targetChild.idField) inputFields.set(camelCase(f.name), formatFieldType$1(f));
-				}
-			}
+		for (const field of cmd.inputFields ?? []) inputFields.set(camelCase(field.name), {
+			type: formatFieldType$1(field),
+			optional: field.optional
+		});
+		for (const eff of cmd.effects ?? []) if (eff.value?.startsWith("input.")) {
+			const inputFieldName = camelCase(eff.value.slice(6));
+			const targetFieldName = camelCase(eff.target);
+			const fieldType = fieldTypeMap.get(targetFieldName) ?? "unknown";
+			if (!inputFields.has(inputFieldName)) inputFields.set(inputFieldName, {
+				type: fieldType,
+				optional: fieldOptionalMap.get(targetFieldName) ?? false
+			});
 		}
-		const inputType = inputFields.size > 0 ? `{ ${[...inputFields.entries()].map(([k, t]) => `${k}: ${t}`).join("; ")} }` : "Record<string, unknown>";
+		const inputType = inputFields.size > 0 ? `{ ${[...inputFields.entries()].map(([k, value]) => `${k}${value.optional ? "?" : ""}: ${value.type}`).join("; ")} }` : "Record<string, unknown>";
 		const extraParams = cmdEmitsEvents ? `, eventContext: EventContext` : "";
-		methodLines.push(...renderEffectLines(cmd.effects, "input", spec, "    ", "this", false, new Set(inputFields.keys())));
+		methodLines.push(...renderEffectLines(cmd.effects, "input", spec, "    ", "this", false, new Set(inputFields.keys()), new Map([...inputFields.entries()].map(([name, meta]) => [name, meta.optional]))));
 		const inputParamName = methodLines.some((line) => /\binput\b/.test(line)) ? "input" : "_input";
 		if (resolvedInvariants.length > 0) {
 			const errorUnion = resolvedInvariants.map((inv) => `${pascalCase(inv.name)}Error`).join(" | ");
@@ -1601,10 +1985,9 @@ ${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    });` : "";
-	return `${imports}
+	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 pruneUnusedBrandedIdImport$1(`${imports}
 
 export interface ${aggregateClassName}Props {
 ${propsLines}
@@ -1630,9 +2013,9 @@ ${classFields}${collectionFields.length > 0 ? "\n" + collectionFields.join("\n")
 ${constructorAssignments}
   }
 
-  static create(id: ${idTypeStr}, props: ${aggregateClassName}Props): ${aggregateClassName} {
+  static create(id: ${idTypeStr}, props: ${aggregateClassName}Props): Result<${aggregateClassName}, DomainError> {
 ${createBody}
-  }
+  }${scalarGetters}
 
   static fromPersistence(state: ${rehydrationStateName}): ${aggregateClassName} {
     ${getRehydrationGuardName({
@@ -1644,20 +2027,23 @@ ${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("")}
 }
-`;
+`);
 }
-function createEntityStub(entity, depthFromDomain = 1) {
+function createEntityStub(entity, _depthFromDomain = 1) {
 	const entityName = `${pascalCase(entity.name)}Entity`;
 	const fields = entity.fields;
 	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$1(entity.name)}">`;
 	const libRelPath = "../../../../../lib";
 	const imports = [
 		`import { Entity } from "${libRelPath}/entity.base.ts";`,
@@ -1703,9 +2089,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 +2131,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;
   }
 }
@@ -1932,10 +2320,10 @@ function aggregateIdPropertyName(spec) {
 }
 function metadataFieldFallback(field) {
 	const fieldName = camelCase(field.name);
-	if (fieldName === "recordedBy" || fieldName.endsWith("By")) return field.type === "string" ? "eventContext.recordedBy.value" : "eventContext.recordedBy";
+	if (fieldName === "recordedBy") return field.type === "string" ? "eventContext.recordedBy.value" : "eventContext.recordedBy";
 	if (fieldName === "correlationId") return "eventContext.correlationId";
 	if (fieldName === "causationId") return "eventContext.causationId";
-	if (fieldName === "occurredAt" || fieldName.endsWith("At")) return field.type === "date" ? "new Date()" : "new Date().toISOString()";
+	if (fieldName === "occurredAt" || fieldName === "createdAt") return field.type === "date" ? "new Date()" : "new Date().toISOString()";
 }
 function findRepositoryPort(spec, targetAggregate) {
 	const aggregateName = targetAggregate ?? ("aggregate" in spec ? spec.aggregate.name : void 0);
@@ -1972,7 +2360,7 @@ function formatFieldType(field, indent = 0) {
 function maybeUnwrapBrandedIdExpression(expression, targetField) {
 	if (targetField.type !== "string") return expression;
 	if (!camelCase(targetField.name).endsWith("Id")) return expression;
-	const unwrap = `typeof ${expression} === "object" && ${expression} !== null && "value" in (${expression} as Record<string, unknown>) ? String((${expression} as { value: unknown }).value) : String(${expression})`;
+	const unwrap = `brandedIdToString(${expression})`;
 	return targetField.optional ? `${expression} === undefined ? undefined : (${unwrap})` : unwrap;
 }
 function projectValueToTargetField(expression, targetField, sourceField, depth = 0) {
@@ -1980,11 +2368,13 @@ function projectValueToTargetField(expression, targetField, sourceField, depth =
 		const sourceNestedFields = new Map((sourceField?.nestedFields ?? []).map((nestedField) => [camelCase(nestedField.name), nestedField]));
 		if (targetField.array) {
 			const itemVar = `item${depth}`;
-			return `${expression}.map((${itemVar}: any) => ({ ${targetField.nestedFields.map((nestedField) => {
+			const objectFields = targetField.nestedFields.map((nestedField) => {
 				const nestedName = camelCase(nestedField.name);
 				const nestedSourceField = sourceNestedFields.get(nestedName);
 				return `${nestedName}: ${projectValueToTargetField(`${itemVar}.${nestedName}`, nestedField, nestedSourceField, depth + 1)}`;
-			}).join(", ")} }))`;
+			});
+			sourceField?.nestedFields ?? targetField.nestedFields;
+			return `${expression}.map((${itemVar}) => ({ ${objectFields.join(", ")} }))`;
 		}
 		return `{ ${targetField.nestedFields.map((nestedField) => {
 			const nestedName = camelCase(nestedField.name);
@@ -2037,7 +2427,11 @@ function coerceExpressionToFieldType(expression, targetField, sourceField) {
 	return expression;
 }
 function renderInputExpression(value, inputRoot) {
-	return value.replaceAll(/\binput\.([A-Za-z0-9_]+)/g, (_match, fieldName) => `${inputRoot}.${camelCase(fieldName)}`);
+	return value.replace(/\binput\.([A-Za-z0-9_]+)/g, (_match, fieldName) => `${inputRoot}.${camelCase(fieldName)}`);
+}
+function pruneUnusedBrandedIdImport(content) {
+	if (content.includes("brandedIdToString(")) return content;
+	return content.replace(`import { brandedIdToString, createBrandedId } from "../../../../../lib/branded-id.ts";`, `import { createBrandedId } from "../../../../../lib/branded-id.ts";`).replace(`import { brandedIdToString } from "../../../../../lib/branded-id.ts";\n`, "");
 }
 function inferFilterFieldType(query, fieldName) {
 	switch (query.outputFields.find((f) => camelCase(f.name) === camelCase(fieldName))?.type ?? "string") {
@@ -2059,7 +2453,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`;
 }
@@ -2073,7 +2467,7 @@ 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`;
@@ -2137,7 +2531,7 @@ function createListQueryHandlerStub(_spec, 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)}";
@@ -2160,17 +2554,17 @@ function createHandlerDepsStub(spec) {
 	const contextPascal = pascalCase(spec.context.name);
 	const aggregateVar = camelCase(spec.aggregate.name);
 	const aggregatePascal = pascalCase(spec.aggregate.name);
-	const idType = spec.aggregate.idType;
-	idType && idType !== "string" && `${pascalCase(idType)}`;
 	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};
   };
@@ -2207,9 +2601,9 @@ ${query.outputFields.map((f) => {
 function queryOutputContractName$1(query) {
 	const outputExportName = queryOutputExportName$1(query);
 	if (outputExportName) return pascalCase(outputExportName);
-	return readModelContractName$3(resolvedReadModelName$2(query));
+	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$/, "");
@@ -2260,7 +2654,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)));
@@ -2287,18 +2682,20 @@ function buildCreateHandlerBody(spec, command) {
 		imports.push(`import type { BrandedId } from "../../../../../lib/branded-id.ts";`);
 	}
 	if (creationEvent) {
+		if (hasCustomIdType) imports.push(`import { brandedIdToString } from "../../../../../lib/branded-id.ts";`);
+		else imports[imports.findIndex((entry) => entry === `import { createBrandedId } from "../../../../../lib/branded-id.ts";`)] = `import { brandedIdToString, createBrandedId } from "../../../../../lib/branded-id.ts";`;
 		imports.push(`import { createDomainEvent } from "../../../../../lib/domain-event.base.ts";`);
 		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`;
 		const payloadFields = [];
 		for (const f of creationEvent.fields) {
 			const fieldName = camelCase(f.name);
-			if (fieldName === camelCase(idField)) payloadFields.push(`      ${fieldName}: id.value,`);
+			if (fieldName === camelCase(idField) || fieldName.endsWith("Id") && camelCase(idField).toLowerCase().endsWith(fieldName.toLowerCase())) payloadFields.push(`      ${fieldName}: id.value,`);
 			else if (aggregateChildCollections.has(fieldName)) {
 				const aggregateCollectionField = aggregateChildCollections.get(fieldName);
 				payloadFields.push(`      ${fieldName}: ${projectValueToTargetField(`${aggregateVar}.${fieldName}`, f, aggregateCollectionField)},`);
@@ -2307,10 +2704,11 @@ function buildCreateHandlerBody(spec, command) {
 				const aggregateExpr = fieldName === "version" && (f.type === "string" || f.type === "enum") ? `String(${aggregateVar}.version)` : `${aggregateVar}.${fieldName}`;
 				payloadFields.push(`      ${fieldName}: ${projectValueToTargetField(aggregateExpr, f, aggregateField)},`);
 			} else if (commandInputFieldNames.has(fieldName)) payloadFields.push(`      ${fieldName}: ${projectValueToTargetField(`command.payload.${fieldName}`, f, commandInputFields.get(fieldName))},`);
-			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 {
+				const metadataExpr = metadataFieldFallback(f);
+				if (metadataExpr) payloadFields.push(`      ${fieldName}: ${metadataExpr},`);
+				else payloadFields.push(`      ${fieldName}: undefined /* TODO: unmapped ${payloadName} field "${fieldName}" */,`);
+			}
 		}
 		creationEventLines = `
   deps.eventCollector.collect([
@@ -2331,9 +2729,10 @@ ${payloadFields.join("\n")}
 	}
 	const handlerErrorType = `${pascalCase(command.name)}HandlerError`;
 	const eventContextParamName = [...propsLines, creationEventLines].some((line) => line.includes("eventContext")) ? "eventContext" : "_eventContext";
-	return `${imports.join("\n")}
+	imports.push(`import type { DomainError } from "../../../../../lib/domain-error.ts";`);
+	return pruneUnusedBrandedIdImport(`${imports.join("\n")}
 
-export type ${handlerErrorType} = never;
+export type ${handlerErrorType} = DomainError;
 
 export async function ${handlerFnName}(
   command: ${commandTypeName},
@@ -2341,16 +2740,18 @@ export async function ${handlerFnName}(
   ${eventContextParamName}: EventContext,
 ): Promise<Result<{ ${idField}: ${idTypeName} }, ${handlerErrorType}>> {
   const id = ${idExpr};
-  const ${aggregateVar} = ${aggregateClassName}.create(
+  const created = ${aggregateClassName}.create(
     id,
     {
 ${propsLines.join("\n")}
     },
   );
+  if (!created.ok) return created;
+  const ${aggregateVar} = created.value;
   await deps.repos.${camelCase(spec.aggregate.name)}s.create(${aggregateVar}, deps.tx);${creationEventLines}
   return ok({ ${idField}: ${aggregateVar}.id });
 }
-`;
+`);
 }
 function buildMutationHandlerBody(spec, command) {
 	const commandTypeName = `${pascalCase(command.name)}Command`;
@@ -2387,7 +2788,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;
@@ -2399,7 +2800,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 = [
@@ -2409,7 +2810,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`;
@@ -2431,23 +2832,49 @@ function createCommandHandlerStub(spec, command) {
 		if (command.commandKind === "create") return buildCreateHandlerBody(spec, command);
 		if (command.loadBy) return buildMutationHandlerBody(spec, command);
 	}
+	`${pascalCase(command.name)}`;
+	`${pascalCase(command.name)}`;
+	`${pascalCase(spec.context.name)}`;
+	const capabilityReasons = command.capability?.reasons ?? [];
+	const diagnosticSuffix = capabilityReasons.length > 0 ? ` Reasons: ${capabilityReasons.join("; ")}.` : "";
+	`${spec.context.name}${command.name}${diagnosticSuffix}`;
+	return null;
+}
+function createUnsupportedCommandContract(spec, command) {
 	const commandTypeName = `${pascalCase(command.name)}Command`;
-	const handlerFnName = `handle${pascalCase(command.name)}`;
 	const depsTypeName = `${pascalCase(spec.context.name)}CommandHandlerDeps`;
+	const contractName = `${pascalCase(command.name)}HandlerContract`;
 	return `import type { ${commandTypeName} } from "../commands/${kebabCase(command.name)}.command.ts";
 import type { ${depsTypeName} } from "../handler-deps.ts";
 import type { EventContext } from "../../../../shared-kernel/events/event-context.ts";
 
-export async function ${handlerFnName}(
-  command: ${commandTypeName},
-  deps: ${depsTypeName},
-  eventContext: EventContext,
-): Promise<void> {
-  void command;
-  void deps;
-  void eventContext;
-  // TODO: load aggregate, execute domain operation, save, pull events
+export interface ${contractName} {
+  execute(
+    command: ${commandTypeName},
+    deps: ${depsTypeName},
+    eventContext: EventContext,
+  ): Promise<void>;
+}
+`;
 }
+function createUnsupportedCommandStub(spec, command) {
+	const commandTypeName = `${pascalCase(command.name)}Command`;
+	const depsTypeName = `${pascalCase(spec.context.name)}CommandHandlerDeps`;
+	const contractName = `${pascalCase(command.name)}HandlerContract`;
+	const handlerVarName = `${camelCase(command.name)}Handler`;
+	return `import type { ${contractName} } from "../contracts/${kebabCase(command.name)}.handler.contract.ts";
+import type { ${commandTypeName} } from "../commands/${kebabCase(command.name)}.command.ts";
+import type { ${depsTypeName} } from "../handler-deps.ts";
+import type { EventContext } from "../../../../shared-kernel/events/event-context.ts";
+
+export const ${handlerVarName}: ${contractName} = {
+  async execute(command, deps, eventContext) {
+    void command;
+    void deps;
+    void eventContext;
+    throw new Error("TODO: implement ${pascalCase(command.name)} handler");
+  },
+};
 `;
 }
 function createQueryStub(spec, query) {
@@ -2468,7 +2895,7 @@ function buildQueryHandlerBody(_spec, 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)}";
@@ -2494,7 +2921,7 @@ function createQueryHandlerStub(_spec, 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)}";
@@ -2557,46 +2984,80 @@ 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$1(query);
-		const viewFileBase = queryViewFileBase$2(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(trimProjectionSourceEventName$1(source.eventName))}Payload`;
+}
+function projectionSourcePayloadImportPath$1(currentModulePath, source) {
+	const sourceModulePath = projectionSourceModulePath$2(source.contextName);
+	const eventFile = `${kebabCase(trimProjectionSourceEventName$1(source.eventName))}.event.ts`;
+	if (sourceModulePath === currentModulePath) return `../../../domain/events/${eventFile}`;
+	return `../../../../${sourceModulePath}/domain/events/${eventFile}`;
+}
+function trimProjectionSourceEventName$1(eventName) {
+	return eventName.endsWith("Event") ? eventName.slice(0, -5) : eventName;
+}
+function projectionSourceModulePath$2(contextName) {
+	return normalizeModulePath(contextName.replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2"));
+}
+function projectionSourceEventType$1(source) {
+	const payloadType = projectionSourcePayloadTypeName$1(source);
+	return `EventEnvelope<${payloadType}> | ${payloadType}`;
+}
+function createProjectionWritePortStub(currentModulePath, projection) {
+	const payloadImports = projection.sources.slice().sort((left, right) => left.eventName.localeCompare(right.eventName)).map((source) => `import type { ${projectionSourcePayloadTypeName$1(source)} } from "${projectionSourcePayloadImportPath$1(currentModulePath, 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 `${queryViewFileBase$2(query)}.view`;
+	return `${queryViewFileBase$1(query)}.view`;
 }
 function createHandlerMapStub(spec) {
 	const contextPascal = pascalCase(spec.context.name);
@@ -2619,7 +3080,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) {
@@ -2645,6 +3110,7 @@ ${aclEntries.join("\n")}
 export type ${contextPascal}CommandHandlerDeps = {
   tx: Transaction;
   eventCollector: EventCollector;
+  aggregateEventTracker: AggregateEventTracker;
   repos: {
 ${repoEntries.join("\n")}
   };
@@ -2690,7 +3156,7 @@ function createPublishedReadBoundaryStub(contextSpec) {
 		const queryTypeName = `${pascalCase(query.name)}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";`);
@@ -2756,7 +3222,14 @@ function buildV5ApplicationArtifacts(spec, options) {
 	for (const { readModelName, queries } of groupQueriesByReadModel$1(spec.queries)) artifacts.push(createGeneratedArtifact(buildArtifactPath("core/contexts", modulePath, `application/ports/${`read-models/${readModelPortBaseFileName(readModelName)}.repository.port.ts`}`), createReadModelRepositoryPortStub(readModelName, queries)));
 	for (const command of spec.commands) {
 		artifacts.push(createGeneratedArtifact(buildArtifactPath("core/contexts", modulePath, `application/commands/${kebabCase(command.name)}.command.ts`), createCommandStub(spec, command)));
-		if (findRepositoryPort(spec, command.targetAggregate)) artifacts.push(createGeneratedArtifact(buildArtifactPath("core/contexts", modulePath, `application/handlers/${kebabCase(command.name)}.handler.ts`), createCommandHandlerStub(spec, command)));
+		if (findRepositoryPort(spec, command.targetAggregate)) {
+			const handlerBody = createCommandHandlerStub(spec, command);
+			if (handlerBody !== null) artifacts.push(createGeneratedArtifact(buildArtifactPath("core/contexts", modulePath, `application/handlers/${kebabCase(command.name)}.handler.ts`), handlerBody));
+			else {
+				artifacts.push(createGeneratedArtifact(buildArtifactPath("core/contexts", modulePath, `application/contracts/${kebabCase(command.name)}.handler.contract.ts`), createUnsupportedCommandContract(spec, command)));
+				artifacts.push(createGeneratedArtifact(buildArtifactPath("core/contexts", modulePath, `application/handlers/${kebabCase(command.name)}.handler.ts`), createUnsupportedCommandStub(spec, command), userArtifactOwnership(`${spec.context.name}:${command.name}`)));
+			}
+		}
 	}
 	for (const query of spec.queries) if (query.queryKind === "list") {
 		const listQuery = query;
@@ -2772,16 +3245,29 @@ 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(modulePath, projection)));
+	}
+	return artifacts;
 }
 
 //#endregion
 //#region packages/core/generators/infrastructure.ts
+function defaultIdBrandName(name) {
+	const base = pascalCase(name);
+	return base.endsWith("Id") ? base : `${base}Id`;
+}
+function resolveDrizzlePersistence(infrastructureStrategy) {
+	return infrastructureStrategy?.persistence === "mysql" ? "mysql" : "postgres";
+}
 function isDecimalNumberField(field) {
 	if (field.type !== "number") return false;
 	const explicitColumnType = field.columnType?.toLowerCase();
@@ -2796,10 +3282,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;
@@ -2906,12 +3394,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$/, "");
@@ -2919,6 +3407,15 @@ 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;
 }
@@ -2928,9 +3425,9 @@ function queryOutputExportName(query) {
 function queryOutputContractName(query) {
 	const outputExportName = queryOutputExportName(query);
 	if (outputExportName) return pascalCase(outputExportName);
-	return readModelContractName$2(resolvedReadModelName$1(query));
+	return readModelContractName$1(resolvedReadModelName$1(query));
 }
-function queryViewFileBase$1(query) {
+function queryViewFileBase(query) {
 	const outputExportName = queryOutputExportName(query);
 	if (outputExportName) return kebabCase(outputExportName).replace(/-view$/, "");
 	return readModelRepositoryFileBase$1(resolvedReadModelName$1(query));
@@ -2960,13 +3457,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);
 	}
@@ -2975,16 +3472,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,
@@ -3001,13 +3498,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 = [
@@ -3015,12 +3512,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 (spec.aggregate !== void 0 || 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);
@@ -3091,48 +3588,343 @@ 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 childTableVar(spec, tableName) {
-	const child = (spec.aggregate.children ?? []).find((c) => c.tableName === tableName);
-	return child ? `${camelCase(child.name)}Table` : `${camelCase(tableName)}Table`;
+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 listQueryTypeBaseName(listQuery) {
-	return pascalCase(listQuery.name);
+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 listQueryFiltersTypeName(listQuery) {
-	return `${listQueryTypeBaseName(listQuery)}Filters`;
+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 listQuerySortFieldTypeName(listQuery) {
-	return `${listQueryTypeBaseName(listQuery)}SortField`;
+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 listQueryRowTypeName(listQuery) {
-	return `${listQueryTypeBaseName(listQuery)}Row`;
+function createMikroOrmEntitySchemaArtifactContent(spec) {
+	const nodes = flattenMikroOrmNodes(buildMikroOrmRootNode(spec));
+	const contextPrefix = pascalCase(spec.context.name);
+	const needsCascade = nodes.some((node) => node.children.length > 0);
+	const needsCollection = nodes.some((node) => node.children.length > 0);
+	const mikroOrmImports = ["EntitySchema"];
+	if (needsCascade) mikroOrmImports.unshift("Cascade");
+	if (needsCollection) mikroOrmImports.push("Collection");
+	const imports = [`import { ${mikroOrmImports.join(", ")} } 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 listQueryRepositoryMethodName(listQuery) {
-	return camelCase(listQuery.name);
+function serializeDomainFieldValue(field, sourceExpr) {
+	if (field.type === "date" || field.type === "Date") return `${sourceExpr} instanceof Date ? ${sourceExpr}.toISOString() : String(${sourceExpr})`;
+	return sourceExpr;
 }
-function buildListMethod(spec, listQuery) {
-	const filtersTypeName = listQueryFiltersTypeName(listQuery);
-	const sortFieldTypeName = listQuerySortFieldTypeName(listQuery);
-	const rowTypeName = listQueryRowTypeName(listQuery);
-	const methodName = listQueryRepositoryMethodName(listQuery);
-	const tableVar = `${camelCase(spec.aggregate.name)}Table`;
-	const idField = spec.aggregate.idField;
-	const idColRef = `${tableVar}.${snakeCase(idField)}`;
-	const aggregateFieldNames = new Set([camelCase(idField), ...filterManagedAggregateFields(spec.aggregate.fields).map((f) => camelCase(f.name))]);
-	const aggregateFieldsByName = new Map(filterManagedAggregateFields(spec.aggregate.fields).map((field) => [camelCase(field.name), field]));
-	const filterLines = [];
-	for (const [field, operators] of Object.entries(listQuery.filters)) {
-		if (!aggregateFieldNames.has(camelCase(field))) continue;
-		const columnRef = `${tableVar}.${snakeCase(field)}`;
-		for (const op of operators) switch (op) {
-			case "eq":
-				filterLines.push(`    if (filters?.${camelCase(field)}?.eq != null) conditions.push(eq(${columnRef}, filters.${camelCase(field)}.eq));`);
-				break;
-			case "in":
-				filterLines.push(`    if (filters?.${camelCase(field)}?.in) conditions.push(inArray(${columnRef}, filters.${camelCase(field)}.in));`);
-				break;
-			case "gt":
-				filterLines.push(`    if (filters?.${camelCase(field)}?.gt != null) conditions.push(gt(${columnRef}, filters.${camelCase(field)}.gt));`);
+function deserializePersistenceFieldValue(field, sourceExpr) {
+	if (field.type === "date" || field.type === "Date") return `${sourceExpr} ? new Date(${sourceExpr}) : ${sourceExpr}`;
+	return sourceExpr;
+}
+function rehydrateIdExpression(node, sourceExpr) {
+	return `create${pascalCase(node.idType && node.idType !== "string" ? node.idType : defaultIdBrandName(node.name))}(${sourceExpr})`;
+}
+function buildMikroOrmNodeHelperBlock(spec, node, domainTypeNameOverride) {
+	const domainTypeName = domainTypeNameOverride ?? (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<string, ${child.className}>(${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 ? `  ${recordVar}.${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 ${recordVar} = new ${node.className}();
+${parentAssignment}${scalarAssignmentLines.join("\n")}
+${createChildLines.join("\n")}
+  return ${recordVar};
+}
+
+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 customIdImports = /* @__PURE__ */ new Map();
+	for (const node of nodes) {
+		const idFactoryBase = node.idType && node.idType !== "string" ? node.idType : defaultIdBrandName(node.name);
+		customIdImports.set(idFactoryBase, `import { create${pascalCase(idFactoryBase)} } from "${relativePrefix}/core/shared-kernel/entity-ids/${kebabCase(idFactoryBase)}";`);
+	}
+	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));
+			const parentClassName = current.parent?.className;
+			current = parentClassName ? nodes.find((candidate) => candidate.className === parentClassName) : void 0;
+		}
+		return segments.join(".");
+	}).filter((value, index, array) => value.length > 0 && array.indexOf(value) === index).sort();
+	const domainEntityImports = nodes.filter((node) => !node.isAggregateRoot).map((node) => {
+		const domainAlias = `${pascalCase(node.name)}DomainEntity`;
+		return `import { ${pascalCase(node.name)}Entity as ${domainAlias} } from "${relativePrefix}/core/contexts/${modulePath}/domain/entities/${kebabCase(node.name)}.entity";`;
+	}).join("\n");
+	const helperBlocks = nodes.slice().reverse().map((node) => {
+		return buildMikroOrmNodeHelperBlock(spec, node, node.isAggregateRoot ? `${pascalCase(spec.aggregate.name)}Aggregate` : `${pascalCase(node.name)}DomainEntity`);
+	}).join("\n\n");
+	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";
+${[...customIdImports.values()].join("\n")}${customIdImports.size > 0 ? "\n" : ""}${notFoundImports}import { ${aggregateName}Aggregate } from "${relativePrefix}/core/contexts/${modulePath}/domain/aggregates/${aggregateDir}/${aggregateDir}.aggregate";
+${domainEntityImports}${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";
+
+type MikroOrmEntityManager = {
+  findOne<TRecord>(
+    entity: new () => TRecord,
+    where: Record<string, unknown>,
+    options: { populate: string[] },
+  ): Promise<TRecord | null>;
+  persist(record: unknown): void | Promise<void>;
+};
+
+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);
+}
+
+${helperBlocks}
+
+export class ${repositoryClassName} implements ${repositoryPortType} {
+  async findById(${rootIdParamName}: ${rootIdTypeName}, tx: Transaction): Promise<Result<${aggregateName}Aggregate, ${notFoundTypeName}>> {
+    const em = tx as unknown as MikroOrmEntityManager;
+    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 unknown as MikroOrmEntityManager;
+    const rootRecord = create${rootNode.className}FromDomain(${camelCase(spec.aggregate.name)});
+    markTouchedAggregate(tx, "${aggregateName}", String(${camelCase(spec.aggregate.name)}.id.value));
+    await em.persist(rootRecord);
+  }
+
+  async save(${camelCase(spec.aggregate.name)}: ${aggregateName}Aggregate, expectedVersion: number, tx: Transaction): Promise<void> {
+    const em = tx as unknown as MikroOrmEntityManager;
+    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));
+    await em.persist(current);
+  }
+}
+`;
+}
+function childTableVar(spec, tableName) {
+	const child = (spec.aggregate.children ?? []).find((c) => c.tableName === tableName);
+	return child ? `${camelCase(child.name)}Table` : `${camelCase(tableName)}Table`;
+}
+function listQueryTypeBaseName(listQuery) {
+	return pascalCase(listQuery.name);
+}
+function listQueryFiltersTypeName(listQuery) {
+	return `${listQueryTypeBaseName(listQuery)}Filters`;
+}
+function listQuerySortFieldTypeName(listQuery) {
+	return `${listQueryTypeBaseName(listQuery)}SortField`;
+}
+function listQueryRowTypeName(listQuery) {
+	return `${listQueryTypeBaseName(listQuery)}Row`;
+}
+function listQueryRepositoryMethodName(listQuery) {
+	return camelCase(listQuery.name);
+}
+function buildListMethod(spec, listQuery) {
+	const filtersTypeName = listQueryFiltersTypeName(listQuery);
+	const sortFieldTypeName = listQuerySortFieldTypeName(listQuery);
+	const rowTypeName = listQueryRowTypeName(listQuery);
+	const methodName = listQueryRepositoryMethodName(listQuery);
+	const tableVar = `${camelCase(spec.aggregate.name)}Table`;
+	const idField = spec.aggregate.idField;
+	const idColRef = `${tableVar}.${snakeCase(idField)}`;
+	const aggregateFieldNames = new Set([camelCase(idField), ...filterManagedAggregateFields(spec.aggregate.fields).map((f) => camelCase(f.name))]);
+	const aggregateFieldsByName = new Map(filterManagedAggregateFields(spec.aggregate.fields).map((field) => [camelCase(field.name), field]));
+	const filterLines = [];
+	for (const [field, operators] of Object.entries(listQuery.filters)) {
+		if (!aggregateFieldNames.has(camelCase(field))) continue;
+		const columnRef = `${tableVar}.${snakeCase(field)}`;
+		for (const op of operators) switch (op) {
+			case "eq":
+				filterLines.push(`    if (filters?.${camelCase(field)}?.eq != null) conditions.push(eq(${columnRef}, filters.${camelCase(field)}.eq));`);
+				break;
+			case "in":
+				filterLines.push(`    if (filters?.${camelCase(field)}?.in) conditions.push(inArray(${columnRef}, filters.${camelCase(field)}.in));`);
+				break;
+			case "gt":
+				filterLines.push(`    if (filters?.${camelCase(field)}?.gt != null) conditions.push(gt(${columnRef}, filters.${camelCase(field)}.gt));`);
 				break;
 			case "gte":
 				filterLines.push(`    if (filters?.${camelCase(field)}?.gte != null) conditions.push(gte(${columnRef}, filters.${camelCase(field)}.gte));`);
@@ -3353,7 +4145,6 @@ function buildNestedPersistenceEqualityHelpers(allEntities) {
 	lines.push(``);
 	for (const entity of allEntities) {
 		const entityName = pascalCase(entity.name);
-		camelCase(entity.name);
 		const entityIdSnake = snakeCase(entity.idField);
 		lines.push(`function equal${entityName}PersistenceRows(currentRows: any[], expectedRows: any[]): boolean {`);
 		lines.push(`  return equalPersistenceRowSet(currentRows, expectedRows, (row: any) => String(row.${entityIdSnake}), equal${entityName}Persistence);`);
@@ -3528,7 +4319,6 @@ function buildBottomUpAssembly(spec, _allEntities) {
 		camelCase(parent.name);
 		const parentIdField = parent.idField;
 		const fkCol = snakeCase(parentIdField);
-		entity.collectionFieldName;
 		if (entity.children.length === 0) {
 			lines.push(`    const ${entityVar}ByParent = new Map<string, any[]>();`);
 			lines.push(`    for (const r of ${entityVar}Rows) {`);
@@ -3712,7 +4502,7 @@ function buildExpectedChildRowCollectionLines(lines, children, parentAccessor, p
 		const childItemVar = `${childVar}Item`;
 		const fkCol = snakeCase(parentIdField);
 		lines.push(`${indent}for (const ${childItemVar} of ${parentAccessor}.${child.collectionFieldName}) {`);
-		lines.push(`${indent}  ${childRowsVar}.push({ ...${childVar}Codec.encode(${childItemVar} as any), ${fkCol}: String(${parentAccessor}.id.value) });`);
+		lines.push(`${indent}  ${childRowsVar}.push({ ...${childVar}Codec.encode(${childItemVar}), ${fkCol}: String(${parentAccessor}.id.value) });`);
 		if (child.children.length > 0) buildExpectedChildRowCollectionLines(lines, child.children, childItemVar, child.idField, indent + "  ");
 		lines.push(`${indent}}`);
 	}
@@ -3725,7 +4515,6 @@ function buildChildSaveBlock(lines, children, parentAccessor, parentIdField, ind
 		const childIdField = child.idField;
 		const childIdSnake = snakeCase(childIdField);
 		const fkCol = snakeCase(parentIdField);
-		parentAccessor.includes(".") ? `${parentAccessor}${childIdField}` : `${parentAccessor}`;
 		const parentIdValue = parentAccessor.includes(".") ? `${parentAccessor}.${getSimpleIdAccessor(parentIdField)}` : `String(${parentAccessor}.id.value)`;
 		const iterVar = `${childVar}Item`;
 		lines.push(`${indent}// Upsert ${child.name} children + delete orphans`);
@@ -3734,7 +4523,7 @@ function buildChildSaveBlock(lines, children, parentAccessor, parentIdField, ind
 		lines.push(`${indent}  and(eq(${childTableVar}.${fkCol}, ${parentIdValue}), notInArray(${childTableVar}.${childIdSnake}, current${pascalCase(child.name)}Ids))`);
 		lines.push(`${indent});`);
 		lines.push(`${indent}for (const ${iterVar} of ${parentAccessor}.${collectionField}) {`);
-		lines.push(`${indent}  const ${childVar}Row = { ...${childVar}Codec.encode(${iterVar} as any), ${fkCol}: ${parentIdValue} };`);
+		lines.push(`${indent}  const ${childVar}Row = { ...${childVar}Codec.encode(${iterVar}), ${fkCol}: ${parentIdValue} };`);
 		lines.push(`${indent}  await tx.insert(${childTableVar}).values(${childVar}Row).onConflictDoUpdate({ target: ${childTableVar}.${childIdSnake}, set: ${childVar}Row });`);
 		if (child.children.length > 0) buildChildSaveBlock(lines, child.children, iterVar, childIdField, indent + "  ");
 		lines.push(`${indent}}`);
@@ -3748,39 +4537,51 @@ function buildV5InfrastructureArtifacts(spec, options) {
 	const modulePath = normalizeModulePath(spec.context.modulePath);
 	const scopeKey = sliceArtifactOwnership(modulePath);
 	const artifacts = [];
-	if (!options?.skipContextWideArtifacts) {
-		const tableContent = createDrizzleTableDefinition(spec);
+	const forceMikroOrmRepositories = options?.infrastructureStrategy?.orm === "mikroorm";
+	const hasDrizzleRepositoryAdapter = spec.adapters.some((adapter) => adapter.kind === "drizzle-repository");
+	const shouldGenerateDrizzleTables = !forceMikroOrmRepositories && hasDrizzleRepositoryAdapter;
+	if (!options?.skipContextWideArtifacts && shouldGenerateDrizzleTables) {
+		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 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)];
+	const repoArtifacts = spec.ports.filter((port) => port.kind === "repository" && port.target === spec.aggregate.name).flatMap((port) => {
+		const adapter = spec.adapters.find((candidate) => candidate.port === port.name && (candidate.kind === "drizzle-repository" || candidate.kind === "mikroorm-repository"));
+		const repositoryAdapterKind = forceMikroOrmRepositories ? "mikroorm-repository" : adapter?.kind;
+		if (repositoryAdapterKind === "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 (repositoryAdapterKind === "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;
 		const children = agg.children ?? [];
 		const aggScalarFields = scalarFields(fields, children);
+		usesInteger = true;
 		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,
@@ -3795,12 +4596,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);
 		});
 	}
@@ -3810,21 +4611,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"
 	]);
@@ -3832,8 +4634,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");
@@ -3842,9 +4644,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")}
@@ -3889,22 +4691,200 @@ 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(trimEventNameSuffix(source.eventName))}Payload`;
+}
+function projectionWriterPayloadImportPath(source) {
+	return `../../../../../core/contexts/${projectionSourceModulePath$1(source.contextName)}/domain/events/${kebabCase(trimEventNameSuffix(source.eventName))}.event.ts`;
+}
+function trimEventNameSuffix(eventName) {
+	return eventName.endsWith("Event") ? eventName.slice(0, -5) : eventName;
+}
+function projectionSourceModulePath$1(contextName) {
+	return normalizeModulePath(contextName.replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2"));
+}
+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 = extractProjectionPayload(event);`;
+	const executorLine = `    const ${executorVariable} = ${executorExpression};`;
+	const mutation = source.mutation;
+	if (mutation.kind === "delete") {
+		const whereClause = mutation.matchOn.map((field) => `${snakeCase(field)} = ?`).join(" and ");
+		const deleteParams = 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}],
+    );
+  }`;
+	}
+	if (mutation.kind === "custom") return `  async ${mutation.handlerName}(event: ${eventType}, tx: Transaction): Promise<void> {
+${payloadLine}
+${executorLine}
+    // TODO: implement custom projection mutation
+    throw new Error("Custom projection mutation not implemented");
+  }`;
+	const writeEntries = [...Object.entries(mutation.set ?? {})];
+	for (const field of mutation.matchOn) if (!writeEntries.some(([fieldName]) => fieldName === field)) writeEntries.push([field, {
+		kind: "event-field",
+		field
+	}]);
+	const insertColumns = writeEntries.map(([fieldName]) => snakeCase(fieldName));
+	const insertParams = writeEntries.map(([, mapping]) => buildProjectionMutationValueExpression(mapping));
+	const conflictColumns = mutation.matchOn.map((field) => snakeCase(field));
+	const updateAssignments = persistence === "mysql" ? insertColumns.map((column) => `${column} = values(${column})`) : insertColumns.map((column) => `${column} = excluded.${column}`);
+	if (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 _exhaustive = mutation;
+	throw new Error(`Unsupported projection mutation kind: ${_exhaustive.kind}`);
+}
+function buildProjectionWriterCapabilityStubMethod(projection, source) {
+	const methodName = `on${pascalCase(source.eventName)}`;
+	const eventType = projectionWriterEventType(source);
+	const reasons = projection.capabilities.writeModel.reasons.length > 0 ? ` Reasons: ${projection.capabilities.writeModel.reasons.join("; ")}.` : "";
+	const diagnosticMessage = `[infrastructure_generator] Projection "${projection.name}" cannot be fully generated for read-model "${projection.readModelName}".${reasons}`;
+	return `  async ${methodName}(event: ${eventType}, tx: Transaction): Promise<void> {
+    void event;
+    void tx;
+    throw new Error(${JSON.stringify(diagnosticMessage)});
+  }`;
+}
+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 writeCapability = projection.capabilities?.writeModel;
+	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) => writeCapability?.status !== "runtime-throw" ? buildProjectionWriterMethod(readModel, source, "connection", "getMikroOrmConnection(tx)", persistence) : buildProjectionWriterCapabilityStubMethod(projection, source)).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")}
+
+type SqlExecutor = {
+  execute(sql: string, params: unknown[]): Promise<unknown>;
+};
+
+function extractProjectionPayload<TPayload>(event: EventEnvelope<TPayload> | TPayload): Record<string, unknown> {
+  if (typeof event === "object" && event !== null && "payload" in event) {
+    return event.payload as Record<string, unknown>;
+  }
+  return (event ?? {}) as Record<string, unknown>;
+}
+
+function getMikroOrmConnection(tx: Transaction): SqlExecutor {
+  if (typeof tx === "object" && tx !== null) {
+    const candidate = tx as { getConnection?: unknown };
+    if (typeof candidate.getConnection === "function") {
+      const connection = candidate.getConnection.call(tx);
+      if (typeof connection === "object" && connection !== null) {
+        const executor = connection as { execute?: unknown };
+        if (typeof executor.execute === "function") {
+          return connection as SqlExecutor;
+        }
+      }
+    }
+  }
+  throw new Error("MikroORM projection writer requires a transaction with getConnection().");
+}
+
+// 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 writeCapability = projection.capabilities?.writeModel;
+	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) => writeCapability?.status !== "runtime-throw" ? buildProjectionWriterMethod(readModel, source, "executor", "tx as DrizzleSqlExecutor", persistence) : buildProjectionWriterCapabilityStubMethod(projection, source)).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")}
+
+type DrizzleSqlExecutor = {
+  execute(sql: string, params: unknown[]): Promise<unknown>;
+};
+
+function extractProjectionPayload<TPayload>(event: EventEnvelope<TPayload> | TPayload): Record<string, unknown> {
+  if (typeof event === "object" && event !== null && "payload" in event) {
+    return event.payload as Record<string, unknown>;
+  }
+  return (event ?? {}) as Record<string, unknown>;
+}
+
+// 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);
-	if (tableContent !== null) artifacts.push(createGeneratedArtifact(`infrastructure/persistence/${modulePath}/tables.ts`, tableContent, scopeKey));
+	if (options.infrastructureStrategy?.orm !== "mikroorm") {
+		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) {
@@ -3919,49 +4899,41 @@ 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(`    suggestedTableName: "${snakeCase(modulePath).replace(/\//g, "_")}_${snakeCase(readModelRepositoryFileBase$1(readModelName))}",`);
 		lines.push(`  },`);
 	}
 	lines.push(`} as const;`);
 	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);
 		const queryTypeName = `${pascalCase(query.name)}Query`;
 		const outputTypeName = queryOutputContractName(query);
-		const viewFileBase = queryViewFileBase$1(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")}
@@ -3974,18 +4946,232 @@ ${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")}
+
+// Generated read-model repository for the supported infrastructure strategy.
+export class ${className} implements ${portTypeName} {
+  constructor(private readonly db: unknown) {}
+
+${methodBlocks.join("\n\n")}
+}
+`;
+}
+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 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);
+	const capabilityReasons = query.capability?.reasons ?? [];
+	const diagnosticReasons = capabilityReasons.length > 0 ? ` Reasons: ${capabilityReasons.join("; ")}.` : "";
+	if (query.queryKind === "list") return `  async ${methodName}(query: ${queryTypeName}, tx: Transaction): Promise<PaginatedResult<${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 list-query metadata is fully declared." + ${JSON.stringify(diagnosticReasons)},
+    );
+  }`;
+	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." + ${JSON.stringify(diagnosticReasons)},
+    );
+  }`;
+}
 
 //#endregion
 //#region packages/core/generators/projections.ts
-function readModelContractName$1(readModelName) {
-	const baseName = pascalCase(readModelName);
-	return baseName.endsWith("View") ? baseName : `${baseName}View`;
+function projectionWritePortName(projectionName) {
+	return `${pascalCase(projectionName)}WritePort`;
 }
-function readModelRepositoryPortName(readModelName) {
-	return `${readModelContractName$1(readModelName)}RepositoryPort`;
-}
-function readModelRepositoryPortFileBase(readModelName) {
-	return kebabCase(readModelName).replace(/-view$/, "");
+function projectionWritePortVariableName(projectionName) {
+	return camelCase(projectionWritePortName(projectionName));
 }
 function projectionFileBase(projectionName) {
 	return kebabCase(projectionName);
@@ -3993,57 +5179,52 @@ function projectionFileBase(projectionName) {
 function projectionVariableName(projectionName) {
 	return camelCase(projectionName);
 }
-function readModelRepositoryVariableName(readModelName) {
-	return camelCase(readModelRepositoryPortName(readModelName));
-}
 function projectionSourceHandlerName(eventName) {
 	return `on${pascalCase(eventName)}`;
 }
+function projectionSourcePayloadTypeName(source) {
+	return `${pascalCase(trimProjectionSourceEventName(source.eventName))}Payload`;
+}
+function projectionSourcePayloadImportPath(currentModulePath, source) {
+	const sourceModulePath = projectionSourceModulePath(source.contextName);
+	const eventFile = `${kebabCase(trimProjectionSourceEventName(source.eventName))}.event.ts`;
+	if (sourceModulePath === currentModulePath) return `../../domain/events/${eventFile}`;
+	return `../../../${sourceModulePath}/domain/events/${eventFile}`;
+}
+function trimProjectionSourceEventName(eventName) {
+	return eventName.endsWith("Event") ? eventName.slice(0, -5) : eventName;
+}
+function projectionSourceModulePath(contextName) {
+	return normalizeModulePath(contextName.replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2"));
+}
+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}
@@ -4056,20 +5237,58 @@ 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";
+	const payloadImports = projection.sources.slice().sort((left, right) => left.eventName.localeCompare(right.eventName)).map((source) => `import type { ${projectionSourcePayloadTypeName(source)} } from "${projectionSourcePayloadImportPath(modulePath, source)}";`);
+	return createGeneratedArtifact(`core/contexts/${modulePath}/application/projections/${fileBase}.rebuild.ts`, `import type { Transaction } from "../../../../../lib/transaction.ts";
 import type { ${projectorClassName} } from "./${fileBase}.projector.ts";
+${payloadImports.join("\n")}
+
+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.payload as ${projectionSourcePayloadTypeName(source)},
+            deps.transaction,
+          );
+          break;`).join("\n")}
+        default:
+          break;
+      }
+    }
+  }
 }
 `, contextArtifactOwnership(modulePath));
 }
@@ -4087,7 +5306,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/${projectionSourceModulePath(source.contextName)}/domain/events/${kebabCase(trimProjectionSourceEventName(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;
@@ -4097,11 +5317,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, tx) => deps.${projectionVariableName(projection.name)}.${projectionSourceHandlerName(source.eventName)}(event as ${projectionSourceEventType(source)}, 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;
@@ -4109,7 +5331,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} = {
@@ -4186,23 +5408,24 @@ function buildV5TestArtifacts(spec) {
 			const failSupply = violating ? `{ ${violating.field}: "${violating.value}" }` : `{}`;
 			const passSupply = passing ? `{ ${passing.field}: "${passing.value}" }` : violating ? `{ ${violating.field}: "active" }` : `{}`;
 			const eventContextSetup = cmdHasEvents ? `\n      const eventContext = createTestEventContext();` : "";
+			const inputSetup = `\n      const input = {} as Parameters<${aggPascal}Aggregate["${methodName}"]>[0];`;
 			describes.push(`
   describe("${cmd.name} - ${inv.name} invariant", () => {
     it("rejects ${methodName} when ${inv.name} is violated", () => {
       const aggregate = ${aggPascal}Aggregate.fromPersistence(
         sampleValid(${aggPascal}RehydrationSchema, ${failSupply}),
-      );${eventContextSetup}
+      );${inputSetup}${eventContextSetup}
       const result = aggregate.${methodName}(${methodCallArgs});
-      assert(!result.ok);
-      assert(result.error.type === "${errorTypeDiscriminator}");
+      expect(result.ok).toBe(false);
+      expect(result.error.type).toBe("${errorTypeDiscriminator}");
     });
 
     it("allows ${methodName} when ${inv.name} is satisfied", () => {
       const aggregate = ${aggPascal}Aggregate.fromPersistence(
         sampleValid(${aggPascal}RehydrationSchema, ${passSupply}),
-      );${eventContextSetup}
+      );${inputSetup}${eventContextSetup}
       const result = aggregate.${methodName}(${methodCallArgs});
-      assert(result.ok);
+      expect(result.ok).toBe(true);
     });
   });`);
 		}
@@ -4212,20 +5435,21 @@ function buildV5TestArtifacts(spec) {
 	const hasCustomIdType = idType && idType !== "string";
 	if (createCommand) {
 		let createIdExpr;
-		if (hasCustomIdType) {
-			const idTypePascal = pascalCase(idType);
-			extraImports.push(`import { create${idTypePascal} } from "../../../../../../shared-kernel/entity-ids/${kebabCase(idType)}.ts";`);
-			createIdExpr = `create${idTypePascal}(crypto.randomUUID())`;
-		} else {
-			extraImports.push(`import { createBrandedId } from "../../../../../../../lib/branded-id.ts";`);
-			createIdExpr = `createBrandedId("string", crypto.randomUUID())`;
-		}
+		const idFactoryBase = hasCustomIdType ? idType : `${aggPascal}Id`;
+		const idFactoryName = `create${pascalCase(idFactoryBase)}`;
+		extraImports.push(`import { ${idFactoryName} } from "../../../../../../shared-kernel/entity-ids/${kebabCase(idFactoryBase)}.ts";`);
+		createIdExpr = `${idFactoryName}(crypto.randomUUID())`;
 		describes.push(`
   describe("version semantics", () => {
     it("should create with version 0", () => {
       const id = ${createIdExpr};
-      const aggregate = ${aggPascal}Aggregate.create(id, { ...input });
-      expect(aggregate.version).toBe(0);
+      const props = {} as Parameters<typeof ${aggPascal}Aggregate.create>[1];
+      const created = ${aggPascal}Aggregate.create(id, props);
+      expect(created.ok).toBe(true);
+      if (!created.ok) {
+        throw new Error("expected aggregate creation to succeed");
+      }
+      expect(created.value.version).toBe(0);
     });
   });`);
 	}
@@ -4246,13 +5470,14 @@ function buildV5TestArtifacts(spec) {
 			break;
 		}
 		const eventContextSetup = cmdHasEvents ? `\n      const eventContext = createTestEventContext();` : "";
+		const inputSetup = `\n      const input = {} as Parameters<${aggPascal}Aggregate["${methodName}"]>[0];`;
 		describes.push(`
   describe("${cmd.name} - version semantics", () => {
     it("should increment version on successful ${methodName}", () => {
       const aggregate = ${aggPascal}Aggregate.fromPersistence(
         sampleValid(${aggPascal}RehydrationSchema, ${passSupply}),
       );
-      const initialVersion = aggregate.version;${eventContextSetup}
+      const initialVersion = aggregate.version;${inputSetup}${eventContextSetup}
       const result = aggregate.${methodName}(${methodCallArgs});
       expect(result.ok).toBe(true);
       expect(aggregate.version).toBe(initialVersion + 1);
@@ -4262,7 +5487,7 @@ function buildV5TestArtifacts(spec) {
       const aggregate = ${aggPascal}Aggregate.fromPersistence(
         sampleValid(${aggPascal}RehydrationSchema, ${failSupply}),
       );
-      const initialVersion = aggregate.version;${eventContextSetup}
+      const initialVersion = aggregate.version;${inputSetup}${eventContextSetup}
       const result = aggregate.${methodName}(${methodCallArgs});
       expect(result.ok).toBe(false);
       expect(aggregate.version).toBe(initialVersion);
@@ -4270,15 +5495,14 @@ function buildV5TestArtifacts(spec) {
   });`);
 	}
 	if (describes.length === 0) return artifacts;
-	const usesAssert = mutationCommandsWithPreconditions.length > 0;
 	const usesSampleValid = mutationCommandsWithPreconditions.length > 0;
-	const usesInput = Boolean(createCommand);
 	const testPath = `core/contexts/${modulePath}/domain/aggregates/${aggName}/__tests__/${aggName}.test.ts`;
-	const vitestImports = ["describe", "it"];
-	if (usesAssert) vitestImports.push("assert");
-	vitestImports.push("expect");
 	const imports = [
-		`import { ${vitestImports.join(", ")} } from "vitest";`,
+		`import { ${[
+			"describe",
+			"it",
+			"expect"
+		].join(", ")} } from "vitest";`,
 		...usesSampleValid ? [`import type { z } from "zod";`] : [],
 		...usesSampleValid ? [`import { ${aggPascal}RehydrationSchema } from "../${aggName}.schema.ts";`] : [],
 		`import { ${aggPascal}Aggregate } from "../${aggName}.aggregate.ts";`,
@@ -4290,11 +5514,7 @@ function sampleValid<T>(schema: z.ZodType<T>, overrides: Partial<T> = {}): T {
   void schema;
   return overrides as T;
 }` : "";
-	const inputStub = usesInput ? `
-
-// TODO: Provide a valid input object matching the command's input type
-const input = {} as any;` : "";
-	const content = `${imports.join("\n")}${sampleValidHelper}${inputStub}
+	const content = `${imports.join("\n")}${sampleValidHelper}
 
 describe("${aggPascal}Aggregate", () => {${describes.join("\n")}
 });
@@ -4320,7 +5540,7 @@ export class TestCommandBus implements CommandBusPort {
     type: TCommand["type"],
     handler: (command: TCommand, eventContext: EventContext) => Promise<Result<unknown, unknown>>,
   ): void {
-    this.handlers.set(type, handler as any);
+    this.handlers.set(type, (command, eventContext) => handler(command as TCommand, eventContext));
   }
 
   async execute<TResult, TCommand extends CommandEnvelope>(
@@ -4385,6 +5605,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';
@@ -4465,6 +5713,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),
@@ -4559,6 +5808,21 @@ function buildCommandPayloadCanonicalDefinition(command) {
 		runtimeSchema: z.object(Object.fromEntries(fields.map((field) => [field.name, field.runtimeSchema])))
 	};
 }
+function getQueryPayloadSchemaName(query) {
+	return `${pascalCase(query.name)}QueryPayloadSchema`;
+}
+function getQueryPayloadFieldSpecsName(query) {
+	return `${pascalCase(query.name)}QueryPayloadFieldSpecs`;
+}
+function buildQueryPayloadCanonicalDefinition(query) {
+	const fields = query.inputFields.map((field) => buildCommandPayloadField(field));
+	return {
+		schemaName: getQueryPayloadSchemaName(query),
+		fieldSpecsName: getQueryPayloadFieldSpecsName(query),
+		fields,
+		runtimeSchema: z.object(Object.fromEntries(fields.map((field) => [field.name, field.runtimeSchema])))
+	};
+}
 function createCommandPayloadSchemaArtifactContent(definition) {
 	const fieldSpecsLiteral = JSON.stringify(definition.fields.map((field) => ({
 		name: field.name,
@@ -4594,28 +5858,36 @@ function createCommandProcedure(spec, procedure, command) {
 	const commandTypeName = `${pascalCase(command.name)}Command`;
 	const commandType = `${contextName}.${pascalCase(command.name)}`;
 	const guardName = getCommandPayloadGuardName(command);
-	return `    async ${procedure.name}(input: any, ctx: any) {
+	const payloadSchemaName = getCommandPayloadSchemaName(command);
+	return `    ${procedure.name}: publicProcedure
+      .input(${payloadSchemaName})
+      .mutation(async ({ input, ctx }) => {
       ${guardName}(input);
       const command: ${commandTypeName} = { type: "${commandType}", payload: input };
       return await dispatchCommand(deps.commandBus, command, ctx);
-    }`;
+    })`;
 }
 function createQueryProcedure(spec, procedure, query) {
 	const queryTypeName = `${pascalCase(query.name)}Query`;
-	if (query.queryKind === "list") return `    async ${procedure.name}(input: any) {
+	const payloadSchemaName = getQueryPayloadSchemaName(query);
+	if (query.queryKind === "list") return `    ${procedure.name}: publicProcedure
+      .input(${payloadSchemaName})
+      .query(async ({ input }) => {
       const queryRequest: ${queryTypeName} = {
         type: "${pascalCase(spec.context.name)}.${pascalCase(query.name)}",
         payload: input,
       };
       return await deps.queryBus.execute(queryRequest);
-    }`;
-	return `    async ${procedure.name}(input: any) {
+    })`;
+	return `    ${procedure.name}: publicProcedure
+      .input(${payloadSchemaName})
+      .query(async ({ input }) => {
       const queryRequest: ${queryTypeName} = {
         type: "${pascalCase(spec.context.name)}.${pascalCase(query.name)}",
         payload: input,
       };
       return await deps.queryBus.execute(queryRequest);
-    }`;
+    })`;
 }
 function buildProcedureBody(spec, procedure) {
 	if (procedure.kind === "command") {
@@ -4632,7 +5904,8 @@ function collectImports(spec) {
 	const imports = new Set([
 		"import type { CommandBusPort } from \"../../../core/ports/messaging/command-bus.port.ts\";",
 		"import type { QueryBusPort } from \"../../../core/ports/messaging/query-bus.port.ts\";",
-		"import { dispatchCommand } from \"../dispatch-command.ts\";"
+		"import { dispatchCommand } from \"../dispatch-command.ts\";",
+		"import { publicProcedure, router } from \"../trpc-init.ts\";"
 	]);
 	for (const procedure of spec.presentation.procedures) {
 		if (procedure.kind === "command") {
@@ -4642,12 +5915,14 @@ function collectImports(spec) {
 			const commandFileName = kebabCase(command.name);
 			imports.add(`import type { ${commandTypeName} } from "../../../core/contexts/${modulePath}/application/commands/${commandFileName}.command.ts";`);
 			imports.add(`import { ${getCommandPayloadGuardName(command)} } from "../../../core/contexts/${modulePath}/application/commands/${commandFileName}.guards.ts";`);
+			imports.add(`import { ${getCommandPayloadSchemaName(command)} } from "../../../core/contexts/${modulePath}/application/commands/${commandFileName}.schema.ts";`);
 			continue;
 		}
 		const query = spec.queries.find((q) => q.name === procedure.operation);
 		if (!query) continue;
 		const queryFileName = kebabCase(query.name);
 		imports.add(`import type { ${pascalCase(query.name)}Query } from "../../../core/contexts/${modulePath}/application/queries/${queryFileName}.query.ts";`);
+		imports.add(`import { ${getQueryPayloadSchemaName(query)} } from "../../../core/contexts/${modulePath}/application/queries/${queryFileName}.schema.ts";`);
 	}
 	return [...imports].sort().join("\n");
 }
@@ -4660,9 +5935,9 @@ export function ${routerFactoryName}(deps: {
   commandBus: CommandBusPort;
   queryBus: QueryBusPort;
 }) {
-  return {
+  return router({
 ${procedureBodies}
-  };
+  });
 }
 `;
 }
@@ -4722,6 +5997,16 @@ export type TrpcContextRequirements = {
 };
 `, sharedArtifactOwnership("shared"));
 }
+function buildTrpcInitArtifact() {
+	return createGeneratedArtifact("presentation/trpc/trpc-init.ts", `import { initTRPC } from "@trpc/server";
+import type { TrpcContextRequirements } from "./context-requirements.ts";
+
+const t = initTRPC.context<TrpcContextRequirements>().create();
+
+export const router = t.router;
+export const publicProcedure = t.procedure;
+`, sharedArtifactOwnership("shared"));
+}
 function buildV5PresentationArtifacts(spec) {
 	if (spec.presentation.procedures.length === 0) return [];
 	const logicalPath = buildArtifactPath("presentation/trpc/routers", "", `${kebabCase(spec.presentation.trpcRouter)}.router.ts`);
@@ -4730,11 +6015,17 @@ function buildV5PresentationArtifacts(spec) {
 		const definition = buildCommandPayloadCanonicalDefinition(command);
 		return [createGeneratedArtifact(buildArtifactPath("core/contexts", scopeKey, `application/commands/${kebabCase(command.name)}.schema.ts`), createCommandPayloadSchemaArtifactContent(definition), sliceArtifactOwnership(scopeKey)), createGeneratedArtifact(buildArtifactPath("core/contexts", scopeKey, `application/commands/${kebabCase(command.name)}.guards.ts`), createCommandPayloadGuardArtifactContent(command, definition), sliceArtifactOwnership(scopeKey))];
 	});
+	const querySupportArtifacts = spec.queries.map((query) => {
+		const definition = buildQueryPayloadCanonicalDefinition(query);
+		return createGeneratedArtifact(buildArtifactPath("core/contexts", scopeKey, `application/queries/${kebabCase(query.name)}.schema.ts`), createCommandPayloadSchemaArtifactContent(definition), sliceArtifactOwnership(scopeKey));
+	});
 	return [
 		createGeneratedArtifact(logicalPath, createRouterStub(spec), sliceArtifactOwnership(scopeKey)),
 		...commandSupportArtifacts,
+		...querySupportArtifacts,
 		buildDispatchCommandArtifact(),
-		buildContextRequirementsArtifact()
+		buildContextRequirementsArtifact(),
+		buildTrpcInitArtifact()
 	];
 }
 
@@ -4797,6 +6088,14 @@ export function fromPersistence<TBrand extends string>(
 ): BrandedId<TBrand> {
   return { value, _brand: brand } as BrandedId<TBrand>;
 }
+
+export function brandedIdToString(
+  value: BrandedId<string> | string,
+): string {
+  return typeof value === "object" && value !== null && "value" in value
+    ? String(value.value)
+    : String(value);
+}
 `;
 }
 function createEventEnvelope() {
@@ -4923,7 +6222,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>;
@@ -5017,7 +6320,7 @@ export type ListResult<T> = {
 };
 `;
 }
-function buildV5LibArtifacts() {
+function buildV5LibArtifacts(infrastructureStrategy) {
 	const ownership = sharedArtifactOwnership("lib");
 	return [
 		createGeneratedArtifact("lib/branded-id.ts", createBrandedId(), ownership),
@@ -5029,7 +6332,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)
 	];
@@ -5139,29 +6442,110 @@ function buildConsumerAclArtifacts(contextSpec) {
 
 //#endregion
 //#region packages/core/orchestrator.ts
-function generateContextArtifacts(contextSpec) {
-	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 }),
-			...applyOwnershipIfMissing(buildV5TestArtifacts(view), ownership)
-		];
-	});
-	const ctxOwnership = contextArtifactOwnership(contextSpec.context.modulePath);
-	const infraOwnership = sliceArtifactOwnership(contextSpec.context.modulePath);
-	const perContextArtifacts = [
-		...buildV5LibArtifacts(),
-		...buildV5SharedKernelArtifacts(contextSpec),
-		...buildV5PortArtifacts(),
-		...applyOwnershipIfMissing(buildV5ApplicationContextArtifacts(contextSpec), ctxOwnership),
-		...applyOwnershipIfMissing(buildConsumerAclArtifacts(contextSpec), ctxOwnership),
-		...applyOwnershipIfMissing(buildProjectionArtifacts(contextSpec), ctxOwnership),
-		...applyOwnershipIfMissing(buildV5InfrastructureContextArtifacts(contextSpec), infraOwnership),
-		...applyOwnershipIfMissing(buildV5PresentationArtifacts(contextSpec), ctxOwnership),
-		...applyOwnershipIfMissing(buildV5RouteArtifacts(contextSpec), ctxOwnership)
-	];
+function createContextGeneratorTarget(target) {
+	return [target.id, target];
+}
+function aggregateSliceOwnership(view) {
+	return sliceArtifactOwnership(`${view.context.modulePath}/${kebabCase(view.aggregate.name)}`);
+}
+function contextInfrastructureOwnership(contextSpec) {
+	return sliceArtifactOwnership(contextSpec.context.modulePath);
+}
+function orderedTargets(registry, phase) {
+	return [...registry.values()].filter((target) => target.phases.includes(phase)).sort((left, right) => left.order - right.order || left.id.localeCompare(right.id));
+}
+const DEFAULT_CONTEXT_GENERATOR_TARGET_REGISTRY = new Map([
+	createContextGeneratorTarget({
+		id: "domain",
+		order: 10,
+		phases: ["per-aggregate"],
+		generateAggregate: (view) => applyOwnershipIfMissing(buildV5DomainArtifacts(view), aggregateSliceOwnership(view))
+	}),
+	createContextGeneratorTarget({
+		id: "application",
+		order: 20,
+		phases: ["per-aggregate", "per-context"],
+		generateAggregate: (view) => applyOwnershipIfMissing(buildV5ApplicationArtifacts(view, { skipContextWideArtifacts: true }), aggregateSliceOwnership(view)),
+		generateContext: (contextSpec) => applyOwnershipIfMissing(buildV5ApplicationContextArtifacts(contextSpec), contextArtifactOwnership(contextSpec.context.modulePath))
+	}),
+	createContextGeneratorTarget({
+		id: "infrastructure",
+		order: 30,
+		phases: ["per-aggregate", "per-context"],
+		generateAggregate: (view, options) => buildV5InfrastructureArtifacts(view, {
+			skipContextWideArtifacts: true,
+			infrastructureStrategy: options.infrastructureStrategy
+		}),
+		generateContext: (contextSpec, options) => applyOwnershipIfMissing(buildV5InfrastructureContextArtifacts(contextSpec, { infrastructureStrategy: options.infrastructureStrategy }), contextInfrastructureOwnership(contextSpec))
+	}),
+	createContextGeneratorTarget({
+		id: "tests",
+		order: 40,
+		phases: ["per-aggregate"],
+		generateAggregate: (view) => applyOwnershipIfMissing(buildV5TestArtifacts(view), aggregateSliceOwnership(view))
+	}),
+	createContextGeneratorTarget({
+		id: "lib",
+		order: 50,
+		phases: ["per-context"],
+		generateContext: (_contextSpec, options) => buildV5LibArtifacts(options.infrastructureStrategy)
+	}),
+	createContextGeneratorTarget({
+		id: "shared-kernel",
+		order: 60,
+		phases: ["per-context"],
+		generateContext: (contextSpec) => buildV5SharedKernelArtifacts(contextSpec)
+	}),
+	createContextGeneratorTarget({
+		id: "ports",
+		order: 70,
+		phases: ["per-context"],
+		generateContext: () => buildV5PortArtifacts()
+	}),
+	createContextGeneratorTarget({
+		id: "consumer-acls",
+		order: 80,
+		phases: ["per-context"],
+		generateContext: (contextSpec) => applyOwnershipIfMissing(buildConsumerAclArtifacts(contextSpec), contextArtifactOwnership(contextSpec.context.modulePath))
+	}),
+	createContextGeneratorTarget({
+		id: "projections",
+		order: 90,
+		phases: ["per-context"],
+		generateContext: (contextSpec) => applyOwnershipIfMissing(buildProjectionArtifacts(contextSpec), contextArtifactOwnership(contextSpec.context.modulePath))
+	}),
+	createContextGeneratorTarget({
+		id: "presentation",
+		order: 100,
+		phases: ["per-context"],
+		generateContext: (contextSpec) => applyOwnershipIfMissing(buildV5PresentationArtifacts(contextSpec), contextArtifactOwnership(contextSpec.context.modulePath))
+	}),
+	createContextGeneratorTarget({
+		id: "routes",
+		order: 110,
+		phases: ["per-context"],
+		generateContext: (contextSpec) => applyOwnershipIfMissing(buildV5RouteArtifacts(contextSpec), contextArtifactOwnership(contextSpec.context.modulePath))
+	})
+]);
+function generateContextArtifacts(contextSpec, options = {}) {
+	const generation = options.generation;
+	let views = sliceContextIntoAggregateViews(contextSpec);
+	if (generation?.include) {
+		const includeSet = new Set(generation.include);
+		views = views.filter((v) => includeSet.has(v.aggregate.name) || includeSet.has(kebabCase(v.aggregate.name)));
+	}
+	if (generation?.exclude) {
+		const excludeSet = new Set(generation.exclude);
+		views = views.filter((v) => !excludeSet.has(v.aggregate.name) && !excludeSet.has(kebabCase(v.aggregate.name)));
+	}
+	let registry = options.targetRegistry ?? DEFAULT_CONTEXT_GENERATOR_TARGET_REGISTRY;
+	if (generation?.tests === false) {
+		const filtered = new Map(registry);
+		filtered.delete("tests");
+		registry = filtered;
+	}
+	const perAggregateArtifacts = views.flatMap((view) => orderedTargets(registry, "per-aggregate").flatMap((target) => target.generateAggregate?.(view, options) ?? []));
+	const perContextArtifacts = orderedTargets(registry, "per-context").flatMap((target) => target.generateContext?.(contextSpec, options) ?? []);
 	return mergeGeneratedArtifacts([...perAggregateArtifacts, ...perContextArtifacts]).sort((a, b) => a.logicalPath.localeCompare(b.logicalPath));
 }
 
@@ -5765,6 +7149,7 @@ function createIntegrationEvent() {
 
 export interface IntegrationEvent<TPayload> {
   readonly type: string;
+  readonly version: number;
   readonly payload: TPayload;
   readonly eventContext: EventContext;
 }
@@ -5775,28 +7160,66 @@ export type IntegrationEventHandler<TPayload> = (
 
 export type EventSubscription = {
   readonly eventType: string;
-  readonly handler: IntegrationEventHandler<unknown>;
+  readonly handler: IntegrationEventHandler<any>;
 };
 `;
 }
 function createTransactionManager() {
 	return `export interface TransactionManager {
-  withTransaction<T>(work: (tx: unknown) => Promise<T>): Promise<T>;
+  withTransaction<TTx, T>(work: (tx: TTx) => Promise<T>): Promise<T>;
+  flush(tx: unknown): Promise<void>;
 }
 `;
 }
 function createDrizzleTransactionManager() {
 	return `import type { TransactionManager } from "./transaction-manager.ts";
 
+type DrizzleTransactionalDatabase = {
+  transaction<T>(work: (tx: unknown) => Promise<T>): Promise<T>;
+};
+
 export class DrizzleTransactionManager implements TransactionManager {
-  constructor(private readonly db: unknown) {}
+  constructor(private readonly db: DrizzleTransactionalDatabase) {}
 
-  async withTransaction<T>(work: (tx: unknown) => Promise<T>): Promise<T> {
+  async withTransaction<TTx, T>(work: (tx: TTx) => Promise<T>): Promise<T> {
     // Drizzle transaction wrapper
-    return (this.db as any).transaction(async (tx: unknown) => {
-      return work(tx);
+    return this.db.transaction(async (tx: unknown) => {
+      return work(tx as TTx);
+    });
+  }
+
+  async flush(_tx: unknown): Promise<void> {
+    // Drizzle executes statements eagerly inside the transaction callback.
+  }
+}
+`;
+}
+function createMikroOrmTransactionManager() {
+	return `import type { TransactionManager } from "./transaction-manager.ts";
+
+type MikroOrmTransactionalEntityManager = {
+  transactional<T>(work: (tx: unknown) => Promise<T>): Promise<T>;
+};
+
+export class MikroOrmTransactionManager implements TransactionManager {
+  constructor(private readonly em: unknown) {}
+
+  async withTransaction<TTx, T>(work: (tx: TTx) => Promise<T>): Promise<T> {
+    const transactionalEm = this.em as MikroOrmTransactionalEntityManager;
+    return transactionalEm.transactional(async (tx: unknown) => {
+      return work(tx as TTx);
     });
   }
+
+  async flush(tx: unknown): Promise<void> {
+    const transactionalEm = tx as { flush?: () => Promise<void> };
+    if (typeof transactionalEm.flush !== "function") {
+      throw new Error(
+        "[composition_types] MikroORM transaction context is missing flush()",
+      );
+    }
+    await transactionalEm.flush();
+  }
 }
 `;
 }
@@ -5810,11 +7233,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>;
 };
@@ -5826,6 +7251,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));
@@ -5838,6 +7264,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";
@@ -5849,6 +7276,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>;
 };
@@ -5868,6 +7298,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,
@@ -5875,6 +7307,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
@@ -5882,9 +7318,9 @@ export class CommandBusImpl implements CommandBusPort {
   // register() is NOT on CommandBusPort — it is implementation-specific.
   private handlers = new Map<string, RegisteredHandler>();
 
-  register<TCommand extends CommandEnvelope>(
+  register<TCommand extends CommandEnvelope, TDeps extends HandlerDeps = HandlerDeps>(
     type: TCommand["type"],
-    handler: (command: TCommand, deps: HandlerDeps, eventContext: EventContext) => Promise<Result<unknown, unknown>>,
+    handler: (command: TCommand, deps: TDeps, eventContext: EventContext) => Promise<Result<unknown, unknown>>,
     contextKey = this.resolveCommandContext(type),
   ): void {
     this.handlers.set(type, {
@@ -5902,9 +7338,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.
@@ -5935,16 +7373,25 @@ 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);
       }
 
+      await this.txManager.flush(tx);
+      aggregateEventTracker.releaseInto(eventCollector);
       const events = eventCollector.drain();
 
       if (events.length > 0) {
@@ -5989,38 +7436,70 @@ 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 { index, 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"),
+}, (table) => ({
+  statusOccurredAtIdx: index("outbox_status_occurred_at_idx").on(table.status, table.occurredAt),
+}));
+`;
+	return `import { index, 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"),
+}, (table) => ({
+  statusOccurredAtIdx: index("outbox_status_occurred_at_idx").on(table.status, table.occurredAt),
+}));
 `;
 }
 function createOutboxWriter() {
 	return `import { outboxEvents } from "./outbox.table.ts";
 import type { EventEnvelope } from "../../lib/event-envelope.ts";
 
+type OutboxInsertExecutor = {
+  insert(table: typeof outboxEvents): {
+    values(row: Record<string, unknown>): Promise<unknown>;
+  };
+};
+
 export class OutboxWriter {
-  async append(tx: unknown, events: EventEnvelope<unknown>[]): Promise<void> {
+  async append(tx: OutboxInsertExecutor, events: EventEnvelope<unknown>[]): Promise<void> {
     if (events.length === 0) return;
 
-    const db = tx as any;
     for (const event of events) {
-      await db.insert(outboxEvents).values({
+      await tx.insert(outboxEvents).values({
         eventType: event.eventType,
-        payload: event.payload,
-        metadata: {
+        eventVersion: event.eventVersion,
+        payload: JSON.stringify(event.payload),
+        metadata: JSON.stringify({
           correlationId: event.correlationId,
           causationId: event.causationId,
           recordedBy: event.recordedBy,
           occurredAt: event.occurredAt,
-        },
+        }),
         occurredAt: event.occurredAt,
       });
     }
@@ -6028,9 +7507,473 @@ export class OutboxWriter {
 }
 `;
 }
-function buildCompositionOutboxArtifacts() {
+function createMikroOrmOutboxWriter(infrastructureStrategy) {
+	return `import type { EventEnvelope } from "../../lib/event-envelope.ts";
+
+type SqlConnection = {
+  execute(sql: string, params?: unknown[]): Promise<unknown>;
+};
+
+type MikroOrmOutboxExecutor = {
+  getConnection(): SqlConnection;
+};
+
+export class OutboxWriter {
+  async append(tx: MikroOrmOutboxExecutor, events: EventEnvelope<unknown>[]): Promise<void> {
+    if (events.length === 0) return;
+
+    const connection = tx.getConnection();
+
+    for (const event of events) {
+      await connection.execute(
+        "insert into outbox_events (id, event_type, event_version, payload, metadata, occurred_at, status, attempts) values (${infrastructureStrategy?.persistence === "mysql" ? "uuid()" : "gen_random_uuid()"}, ?, ?, ?, ?, ?, ?, ?)",
+        [
+          event.eventType,
+          event.eventVersion,
+          JSON.stringify(event.payload),
+          JSON.stringify({
+            correlationId: event.correlationId,
+            causationId: event.causationId,
+            recordedBy: event.recordedBy,
+            occurredAt: event.occurredAt,
+          }),
+          event.occurredAt,
+          "pending",
+          0,
+        ],
+      );
+    }
+  }
+}
+`;
+}
+function createOutboxDispatcher() {
+	return `import { asc, eq } from "drizzle-orm";
+import { outboxEvents } from "./outbox.table.ts";
+import { createPersonnelId } from "../../core/shared-kernel/entity-ids/personnel-id.ts";
+import { createCorrelationId } from "../../core/shared-kernel/ids/correlation-id.ts";
+import { createEventId } from "../../core/shared-kernel/ids/event-id.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;
+};
+
+type OutboxQueryExecutor = {
+  select(): {
+    from(table: typeof outboxEvents): {
+      where(condition: unknown): {
+        orderBy(ordering: unknown): {
+          limit(count: number): Promise<OutboxRow[]>;
+        };
+      };
+    };
+  };
+  update(table: typeof outboxEvents): {
+    set(values: Record<string, unknown>): {
+      where(condition: unknown): Promise<unknown>;
+    };
+  };
+};
+
+function requiredMetadataValue(
+  metadata: Partial<OutboxMetadata>,
+  key: keyof OutboxMetadata,
+  eventType: string,
+): string {
+  const value = metadata[key];
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(\`Outbox event \${eventType} is missing metadata field: \${key}\`);
+  }
+  return value;
+}
+
+export class OutboxDispatcher {
+  private readonly maxAttempts: number;
+  private readonly batchSize: number;
+  private readonly handlersByEventType: Map<string, EventSubscription[]>;
+
+  constructor(
+    private readonly db: OutboxQueryExecutor,
+    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 }> {
+    let processed = 0;
+    let failed = 0;
+
+    const rows: OutboxRow[] = await this.db
+      .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: createCorrelationId(requiredMetadataValue(metadata, "correlationId", row.eventType)),
+        causationId: createEventId(requiredMetadataValue(metadata, "causationId", row.eventType)),
+        recordedBy: createPersonnelId(requiredMetadataValue(metadata, "recordedBy", row.eventType)),
+      },
+    };
+
+    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> {
+    await this.db
+      .update(outboxEvents)
+      .set({ status, ...fields })
+      .where(eq(outboxEvents.id, id));
+  }
+}
+`;
+}
+function createMikroOrmOutboxDispatcher() {
+	return `import { createPersonnelId } from "../../core/shared-kernel/entity-ids/personnel-id.ts";
+import { createCorrelationId } from "../../core/shared-kernel/ids/correlation-id.ts";
+import { createEventId } from "../../core/shared-kernel/ids/event-id.ts";
+import type {
+  EventSubscription,
+  IntegrationEvent,
+} from "../messaging/integration-event.ts";
+
+export type OutboxDispatcherConfig = {
+  readonly maxAttempts?: number;
+  readonly batchSize?: number;
+};
+
+type OutboxRow = {
+  id: string;
+  event_type: string;
+  event_version: number;
+  payload: unknown;
+  metadata: unknown;
+  occurred_at: string | Date;
+  status: string;
+  attempts: number | null;
+  processed_at: string | Date | null;
+  failed_at: string | Date | null;
+  error: unknown;
+};
+
+type OutboxMetadata = {
+  correlationId: string;
+  causationId: string;
+  recordedBy: string;
+  occurredAt: string;
+};
+
+type HandlerError = {
+  handler: string;
+  error: string;
+};
+
+type SqlConnection = {
+  execute<T = unknown>(sql: string, params?: unknown[]): Promise<T>;
+};
+
+type MikroOrmOutboxExecutor = {
+  getConnection(): SqlConnection;
+};
+
+function requiredMetadataValue(
+  metadata: Partial<OutboxMetadata>,
+  key: keyof OutboxMetadata,
+  eventType: string,
+): string {
+  const value = metadata[key];
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(\`Outbox event \${eventType} is missing metadata field: \${key}\`);
+  }
+  return value;
+}
+
+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 }> {
+    let processed = 0;
+    let failed = 0;
+
+    const connection = (this.db as MikroOrmOutboxExecutor).getConnection();
+    const rows = await connection.execute<OutboxRow[]>(
+      "select id, event_type, event_version, payload, metadata, occurred_at, status, attempts, processed_at, failed_at, error from outbox_events where status = ? order by occurred_at asc limit ?",
+      ["pending", 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.event_type);
+    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.event_type,
+      version: row.event_version,
+      payload: row.payload,
+      eventContext: {
+        correlationId: createCorrelationId(requiredMetadataValue(metadata, "correlationId", row.event_type)),
+        causationId: createEventId(requiredMetadataValue(metadata, "causationId", row.event_type)),
+        recordedBy: createPersonnelId(requiredMetadataValue(metadata, "recordedBy", row.event_type)),
+      },
+    };
+
+    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 connection = (this.db as MikroOrmOutboxExecutor).getConnection();
+    await connection.execute(
+      "update outbox_events set status = ?, attempts = ?, processed_at = ?, failed_at = ?, error = ? where id = ?",
+      [
+        status,
+        fields.attempts ?? 0,
+        fields.processedAt ?? null,
+        fields.failedAt ?? null,
+        fields.error ?? null,
+        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));
+	const usesMikroOrm = infrastructureStrategy?.orm === "mikroorm";
+	return [
+		createGeneratedArtifact("infrastructure/outbox/outbox-dispatcher.ts", usesMikroOrm ? createMikroOrmOutboxDispatcher() : 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", usesMikroOrm ? createMikroOrmOutboxWriter(infrastructureStrategy) : createOutboxWriter(), ownership)
+	].sort((left, right) => left.logicalPath.localeCompare(right.logicalPath));
 }
 
 //#endregion
@@ -6118,38 +8061,53 @@ function renderMappedType(fields) {
 ${Object.entries(fields).map(([fieldName, expr]) => `  readonly ${camelCase(fieldName)}: ${mappingValueType(expr)};`).join("\n")}
 }`;
 }
-function sourceQueryViewTypeName(acl) {
-	const outputExportName = acl.sourceQuery.outputSchemaExportName?.trim();
-	if (outputExportName) return pascalCase(outputExportName);
-	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) {
-	const outputExportName = acl.sourceQuery.outputSchemaExportName?.trim();
-	if (outputExportName) return `${kebabCase(outputExportName).replace(/-view$/, "")}.view.ts`;
-	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 }])))};
 
@@ -6194,20 +8152,51 @@ function buildAclContractContent(acl) {
 }
 function buildReadRequestAssignmentLines(acl) {
 	const sourceInputFields = acl.sourceQuery.inputFields ?? [];
-	return acl.requestMappings.map((mapping) => {
+	const directAssignments = [];
+	const filterAssignments = [];
+	for (const mapping of acl.requestMappings) {
 		const valueExpr = mapping.kind === "from" ? `input.${mapping.sourcePath.replace(/^input\./, "")}` : JSON.stringify(mapping.value);
 		const exactField = sourceInputFields.find((field) => camelCase(field.name) === camelCase(mapping.targetPath));
-		return `      ${exactField ? camelCase(exactField.name) : sourceInputFields.length === 1 ? camelCase(sourceInputFields[0].name) : camelCase(mapping.targetPath)}: ${valueExpr},`;
-	});
+		if (exactField) {
+			directAssignments.push(`      ${camelCase(exactField.name)}: ${valueExpr},`);
+			continue;
+		}
+		if (acl.sourceQuery.queryKind === "list" && acl.sourceQuery.filters[camelCase(mapping.targetPath)]?.includes("eq")) {
+			filterAssignments.push(`        ${camelCase(mapping.targetPath)}: { eq: ${valueExpr} },`);
+			continue;
+		}
+		const targetKey = sourceInputFields.length === 1 ? camelCase(sourceInputFields[0].name) : camelCase(mapping.targetPath);
+		directAssignments.push(`      ${targetKey}: ${valueExpr},`);
+	}
+	if (filterAssignments.length > 0) directAssignments.push(`      filters: {`, ...filterAssignments, `      },`);
+	return directAssignments;
 }
 function buildReadResponseAssignmentLines(acl, responseTypeName) {
 	return acl.responseMappings.map((mapping) => {
 		if (mapping.kind === "const") return `      ${camelCase(mapping.targetPath)}: ${JSON.stringify(mapping.value)},`;
 		if (mapping.sourcePath === "result.items" || mapping.sourcePath === "result.total" || mapping.sourcePath === "result.page" || mapping.sourcePath === "result.pageSize") return `      ${camelCase(mapping.targetPath)}: ${mapping.sourcePath.replace(/^result\./, "result.")} as ${responseTypeName}[${JSON.stringify(camelCase(mapping.targetPath))}],`;
+		if (acl.sourceQuery.queryKind === "list") {
+			const sourceFieldName = mapping.sourcePath.replace(/^result\./, "");
+			const sourceField = acl.sourceQuery.outputFields.find((field) => camelCase(field.name) === camelCase(sourceFieldName));
+			if (sourceField) return `      ${camelCase(mapping.targetPath)}: result.items[0]?.${camelCase(sourceField.name)} as ${responseTypeName}[${JSON.stringify(camelCase(mapping.targetPath))}],`;
+		}
 		const sourceFieldName = mapping.sourcePath.replace(/^result\./, "");
-		return `      ${camelCase(mapping.targetPath)}: resultRecord[${JSON.stringify(sourceFieldName)}] as ${responseTypeName}[${JSON.stringify(camelCase(mapping.targetPath))}],`;
+		return `      ${camelCase(mapping.targetPath)}: (result as unknown as Record<string, unknown>)[${JSON.stringify(sourceFieldName)}] as ${responseTypeName}[${JSON.stringify(camelCase(mapping.targetPath))}],`;
 	});
 }
+function unsupportedReadAclReasons(acl) {
+	const sourceInputFields = acl.sourceQuery.inputFields ?? [];
+	const reasons = [];
+	for (const mapping of acl.requestMappings) {
+		if (mapping.kind === "const") continue;
+		const targetField = camelCase(mapping.targetPath);
+		const matchesInput = sourceInputFields.some((field) => camelCase(field.name) === targetField);
+		const matchesEqFilter = acl.sourceQuery.queryKind === "list" && acl.sourceQuery.filters[targetField]?.includes("eq");
+		const supportsNonListFallback = acl.sourceQuery.queryKind !== "list";
+		if (!matchesInput && !matchesEqFilter && !supportsNonListFallback) reasons.push(`request field "${mapping.targetPath}" does not map to source query input or eq-filter shape`);
+	}
+	return reasons;
+}
 function buildReadAdapterContent(acl, sourceContextNames) {
 	const consumerModulePath = normalizeModulePath(acl.consumerContext.modulePath);
 	const sourceModulePath = normalizeModulePath(acl.sourceContext.modulePath);
@@ -6223,7 +8212,36 @@ function buildReadAdapterContent(acl, sourceContextNames) {
 	const queryFileName = `${kebabCase(acl.sourceQuery.name)}.query.ts`;
 	const queryTypeLiteral = `${pascalCase(acl.sourceContext.name)}.${pascalCase(acl.sourceQuery.name)}`;
 	const usesInput = acl.requestMappings.some((mapping) => mapping.kind === "from" && mapping.sourcePath.startsWith("input."));
-	const needsResultRecord = acl.responseMappings.some((mapping) => mapping.kind === "from" && mapping.sourcePath !== "result.items" && mapping.sourcePath !== "result.total" && mapping.sourcePath !== "result.page" && mapping.sourcePath !== "result.pageSize");
+	const unsupportedReasons = unsupportedReadAclReasons(acl);
+	const diagnosticReasonSuffix = unsupportedReasons.length > 0 ? ` Reasons: ${unsupportedReasons.join("; ")}.` : "";
+	if (unsupportedReasons.length > 0) return `// Auto-generated composition ACL adapter — do not edit by hand
+import type { Transaction } from "../../../lib/transaction.ts";
+import type { TransactionManager } from "../../unit-of-work/transaction-manager.ts";
+import type {
+  ${portTypeName},
+  ${requestTypeName},
+  ${responseTypeName},
+} from "../../../core/contexts/${consumerModulePath}/application/acls/${kebabCase(stripAclPortSuffix(acl.port))}.acl.ts";
+import type { ${boundaryTypeName} } from "../../../core/contexts/${sourceModulePath}/application/read-boundary.ts";
+
+export class ${adapterClassName} implements ${portTypeName} {
+  constructor(
+    private readonly ${boundaryVarName}: ${boundaryTypeName},
+    private readonly transactionManager: TransactionManager,
+  ) {}
+
+  async execute(
+    input: ${requestTypeName},
+    tx?: Transaction,
+  ): Promise<${responseTypeName}> {
+    void input;
+    void tx;
+    void this.${boundaryVarName};
+    void this.transactionManager;
+    throw new Error(${JSON.stringify(`${acl.name} ACL cannot be fully generated.${diagnosticReasonSuffix}`)});
+  }
+}
+`;
 	return `// Auto-generated composition ACL adapter — do not edit by hand
 import type { Transaction } from "../../../lib/transaction.ts";
 import type { TransactionManager } from "../../unit-of-work/transaction-manager.ts";
@@ -6248,16 +8266,13 @@ export class ${adapterClassName} implements ${portTypeName} {
     ${usesInput ? "" : "void input;"}
     try {
       const executeWithTransaction = async (currentTx: Transaction) => {
-        const result = await this.${boundaryVarName}.${boundaryMethodName}(
-          {
-            type: "${queryTypeLiteral}",
-            payload: {
+        const query: ${queryEnvelopeTypeName} = {
+          type: "${queryTypeLiteral}",
+          payload: {
 ${buildReadRequestAssignmentLines(acl).join("\n")}
-            },
-          } as unknown as ${queryEnvelopeTypeName},
-          currentTx,
-        );
-        ${needsResultRecord ? `const resultRecord = result as unknown as Record<string, unknown>;` : ""}
+          },
+        };
+        const result = await this.${boundaryVarName}.${boundaryMethodName}(query, currentTx);
 
         return {
 ${buildReadResponseAssignmentLines(acl, responseTypeName).join("\n")}
@@ -6268,8 +8283,9 @@ ${buildReadResponseAssignmentLines(acl, responseTypeName).join("\n")}
         return await executeWithTransaction(tx);
       }
 
-      return await this.transactionManager.withTransaction(async (runtimeTx) =>
-        executeWithTransaction(runtimeTx as Transaction)
+      return await this.transactionManager.withTransaction<Transaction, ${responseTypeName}>(
+        async (runtimeTx) =>
+          executeWithTransaction(runtimeTx)
       );
     } catch (_error) {
       throw new Error("${acl.name} ACL failed", { cause: _error });
@@ -6291,6 +8307,7 @@ function buildWriteAdapterContent(acl) {
 	const commandTypeLiteral = `${pascalCase(acl.targetContext.name)}.${pascalCase(acl.targetCommand.name)}`;
 	const responseMappings = acl.kind === "ack" ? acl.acknowledgeMappings : acl.responseMappings;
 	const responseBody = acl.kind === "ack" ? `      return;\n` : `      return {\n${toTargetAssignmentLines(responseMappings, "result").join("\n")}\n      };\n`;
+	const resultValueLine = acl.kind === "ack" ? "" : `\n      const result = executionResult.value;`;
 	return `// Auto-generated composition ACL adapter — do not edit by hand
 import type { EventContext } from "../../../core/shared-kernel/events/event-context.ts";
 import type { Result } from "../../../core/shared-kernel/result.ts";
@@ -6313,7 +8330,7 @@ export class ${adapterClassName} implements ${portTypeName} {
   ): Promise<${responseTypeName}> {
     try {
       const executionResult = await this.commandBus.execute<
-        Result<Record<string, unknown>, unknown>,
+        Result<${responseTypeName}, unknown>,
         ${commandEnvelopeTypeName}
       >(
         {
@@ -6328,8 +8345,7 @@ ${toTargetAssignmentLines(acl.requestMappings, "input").join("\n")}
       if (!executionResult.ok) {
         throw executionResult.error;
       }
-
-      const result = executionResult.value as Record<string, unknown>;
+${resultValueLine}
 ${responseBody}
     } catch (_error) {
       throw new Error("${acl.name} ACL failed", { cause: _error });
@@ -6438,6 +8454,25 @@ 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 dependencyArrayLiteral = `[${resolveRuntimeDependencies(compositionSpec).map((dependency) => JSON.stringify(dependency)).join(", ")}]`;
+	return [createGeneratedArtifact("codegen/dependency-manifest.json", `{
+  "kind": "zodmire-dependency-manifest",
+  "infrastructure": ${JSON.stringify(compositionSpec.infrastructure, null, 2).replace(/\n/g, "\n  ")},
+  "dependencies": ${dependencyArrayLiteral}
+}
+`, sharedArtifactOwnership("composition"))];
+}
+
 //#endregion
 //#region packages/core/generators/composition_container.ts
 /**
@@ -6446,9 +8481,11 @@ function buildCompositionAclArtifacts(compositionSpec) {
 */
 function buildCompositionContainerArtifacts(compositionSpec, contextSpecs) {
 	const ownership = sharedArtifactOwnership("composition");
-	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));
+	return [createGeneratedArtifact("infrastructure/di/container.ts", buildContainerContent(compositionSpec, contextSpecs), ownership), createGeneratedArtifact("infrastructure/di/repo-factory.ts", buildRepoFactoryContent(compositionSpec, 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));
@@ -6458,7 +8495,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";`,
@@ -6477,7 +8517,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) {
@@ -6501,15 +8542,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());
@@ -6517,7 +8559,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);`, `    },`, `  };`);
@@ -6529,7 +8571,7 @@ function buildContainerContent(compositionSpec, contextSpecs) {
 		for (const command of spec.commands) {
 			const commandType = `${ctxName}.${pascalCase(command.name)}`;
 			const handlerAlias = `${contextPlan.symbolStem}${pascalCase(command.name)}Handler`;
-			createContainerLines.push(`  commandBus.register("${commandType}", ${handlerAlias} as any, "${contextPlan.pathSegment}");`);
+			createContainerLines.push(`  commandBus.register("${commandType}", ${handlerAlias}, "${contextPlan.pathSegment}");`);
 		}
 	}
 	createContainerLines.push(``);
@@ -6548,7 +8590,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 [
@@ -6557,11 +8601,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;
 }
@@ -6580,11 +8663,6 @@ function uniqueQueriesByReadModel(queries) {
 	}
 	return [...queriesByReadModel.values()].sort((left, right) => resolvedReadModelName(left).localeCompare(resolvedReadModelName(right)));
 }
-function queryViewFileBase(query) {
-	const outputExportName = query.outputSchemaExportName?.trim();
-	if (outputExportName) return kebabCase(outputExportName).replace(/-view$/, "");
-	return readModelRepositoryFileBase(resolvedReadModelName(query));
-}
 function queryReadModelPortTypeName(query) {
 	return `${readModelContractName(resolvedReadModelName(query))}RepositoryPort`;
 }
@@ -6609,25 +8687,34 @@ 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`
-	})));
+function buildRepoFactoryContent(compositionSpec, contextSpecs) {
+	const forceMikroOrmRepositories = compositionSpec.infrastructure.orm === "mikroorm";
+	const repositoryDefs = contextSpecs.flatMap((spec) => spec.aggregates.map((aggregate) => {
+		const repositoryPort = spec.ports.find((port) => port.kind === "repository" && port.target === aggregate.name);
+		const adapter = repositoryPort ? spec.adapters.find((candidate) => candidate.port === repositoryPort.name && (candidate.kind === "drizzle-repository" || candidate.kind === "mikroorm-repository")) : void 0;
+		const isMikroOrm = forceMikroOrmRepositories || adapter?.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 {`);
@@ -6712,7 +8799,8 @@ function buildRootRouterContent(contextSpecs) {
 	const lines = [
 		`// Auto-generated root tRPC router — do not edit by hand`,
 		``,
-		`import type { Container } from "../../infrastructure/di/container.ts";`
+		`import type { Container } from "../../infrastructure/di/container.ts";`,
+		`import { router } from "./trpc-init.ts";`
 	];
 	for (const spec of contextSpecs) {
 		const routerName = spec.presentation.trpcRouter;
@@ -6722,7 +8810,7 @@ function buildRootRouterContent(contextSpecs) {
 	}
 	lines.push(``);
 	lines.push(`export function createRootRouter(container: Container) {`);
-	lines.push(`  return {`);
+	lines.push(`  return router({`);
 	for (const spec of contextSpecs) {
 		const routerName = spec.presentation.trpcRouter;
 		const key = camelCase(routerName);
@@ -6732,7 +8820,7 @@ function buildRootRouterContent(contextSpecs) {
 		lines.push(`      queryBus: container.queryBus,`);
 		lines.push(`    }),`);
 	}
-	lines.push(`  };`);
+	lines.push(`  });`);
 	lines.push(`}`);
 	lines.push(``);
 	return lines.join("\n");
@@ -6765,9 +8853,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(``);
 	}
@@ -6778,18 +8871,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}",`,
@@ -6808,30 +8903,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 [];
@@ -6856,7 +9035,10 @@ async function buildContextNormalizedSpecFromConfig(input) {
 	}))), config);
 }
 async function buildV5ContextArtifacts(input) {
-	return generateContextArtifacts(await buildContextNormalizedSpecFromConfig(input));
+	return generateContextArtifacts(await buildContextNormalizedSpecFromConfig(input), {
+		infrastructureStrategy: input.infrastructureStrategy,
+		generation: input.generation
+	});
 }
 async function buildV5Artifacts(input) {
 	const spec = await buildNormalizedSpecFromConfig(input);
@@ -6881,8 +9063,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),
@@ -6891,4 +9074,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 { DEFAULT_CONTEXT_GENERATOR_TARGET_REGISTRY, 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, userArtifactOwnership, validateContextImports, walkEntityTree, withArtifactOwnership, wordsFromName };