@zodmire/core 0.1.2 → 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,12 +223,17 @@ 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,
@@ -165,6 +244,7 @@ function createReadField(exportName) {
 				const right = def.right;
 				if (left?.objectShape && right?.objectShape) return {
 					type: "object",
+					typeDescriptor: { kind: "object" },
 					optional: false,
 					array: false,
 					sourceSchema: rawSchema,
@@ -175,6 +255,7 @@ function createReadField(exportName) {
 				};
 				return {
 					type: "intersection",
+					typeDescriptor: { kind: "intersection" },
 					optional: false,
 					array: false,
 					sourceSchema: rawSchema
@@ -182,18 +263,21 @@ function createReadField(exportName) {
 			}
 			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
@@ -211,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
@@ -238,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;
 }
@@ -327,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";
 }
@@ -347,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) {
@@ -403,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;
 			}
@@ -460,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;
@@ -566,8 +664,17 @@ function deriveProjectionCapabilities(projection, readModelByName) {
 		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) {
@@ -581,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`);
@@ -790,7 +896,7 @@ function buildContextNormalizedSpec(schemaResult, config) {
 			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
 			};
@@ -842,7 +948,7 @@ 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,
@@ -873,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) {
@@ -891,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
 	};
 }
 
@@ -925,15 +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})`);
@@ -953,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(", ")}`);
@@ -1280,6 +1400,8 @@ function sliceContextIntoAggregateViews(contextSpec) {
 			adapters,
 			presentation: contextSpec.presentation,
 			materialization: contextSpec.materialization,
+			writeModelStrategy: contextSpec.writeModelStrategy,
+			readModelStrategy: contextSpec.readModelStrategy,
 			externalValueObjects: externalVos
 		};
 	});
@@ -1293,10 +1415,55 @@ function aggregateVariableName$1(spec) {
 function aggregateIdPropertyName$1(spec) {
 	return `${aggregateVariableName$1(spec)}Id`;
 }
-function defaultIdBrandName(name) {
+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) => {
@@ -1353,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`;
 }
@@ -1515,9 +1686,9 @@ 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)));
@@ -1525,6 +1696,7 @@ function renderEffectLines(effects, inputVar, spec, indent, selfRef = "this", is
 	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) {
@@ -1533,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;
@@ -1546,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 ${lastPushedEntityTypeName ?? "Record<string, unknown>"}).${fieldName}`;
-				if (availableInputFields.has(fieldName)) return `${fieldName}: ${inputVar}.${fieldName}`;
-				if (fieldName === "occurredAt" || fieldName.endsWith("At")) return `${fieldName}: ${f.type === "date" ? "new Date()" : "new Date().toISOString()"}`;
-				if (fieldName === "recordedBy" || fieldName.endsWith("By")) return `${fieldName}: ${f.type === "string" ? "eventContext.recordedBy.value" : "eventContext.recordedBy"}`;
-				return `${fieldName}: /* TODO: unmapped ${eventName} payload field "${fieldName}" */ undefined as never`;
+				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);
@@ -1576,10 +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;
 				lastPushedEntityTypeName = entityName;
-				lines.push(`${indent}const ${entityVar} = ${entityName}.create({`, `${indent}  ${camelCase(targetChild.idField)}: ${createIdFn}(crypto.randomUUID()),`, `${indent}  ...${inputVar} as any,`, `${indent}});`, `${indent}${selfRef}.${camelCase(effect.target)}.push(${entityVar});`);
+				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;
 		}
@@ -1594,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 = [
@@ -1626,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) {
@@ -1649,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();
@@ -1672,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 = `BrandedId<"${idType && idType !== "string" ? pascalCase(idType) : defaultIdBrandName(spec.aggregate.name)}">`;
+	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.filter((effect) => effect.kind !== "set-field" || effect.value !== `input.${effect.target}`), "props", spec, "    ", "instance", true).join("\n")}
-    return instance;`;
-	else createBody = `    return new ${aggregateClassName}(id, 0, props);`;
+	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);
@@ -1707,24 +1934,22 @@ ${renderEffectLines(createCmd.effects.filter((effect) => effect.kind !== "set-fi
 		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(" | ");
@@ -1762,7 +1987,7 @@ ${methodLines.join("\n")}
 	}
 	const fromPersistenceProps = nonIdFields.map((f) => `      ${camelCase(f.name)}: state.${camelCase(f.name)},`).join("\n");
 	const collectionAssignments = (spec.aggregate.children ?? []).map((child) => `    instance.${camelCase(child.collectionFieldName)}.push(...state.${camelCase(child.collectionFieldName)});`).join("\n");
-	return `${imports}
+	return pruneUnusedBrandedIdImport$1(`${imports}
 
 export interface ${aggregateClassName}Props {
 ${propsLines}
@@ -1788,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({
@@ -1810,15 +2035,15 @@ ${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 = `BrandedId<"${idType && idType !== "string" ? pascalCase(idType) : defaultIdBrandName(entity.name)}">`;
+	const idTypeStr = `BrandedId<"${idType && idType !== "string" ? pascalCase(idType) : defaultIdBrandName$1(entity.name)}">`;
 	const libRelPath = "../../../../../lib";
 	const imports = [
 		`import { Entity } from "${libRelPath}/entity.base.ts";`,
@@ -2095,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);
@@ -2135,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) {
@@ -2143,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);
@@ -2200,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") {
@@ -2323,8 +2554,6 @@ 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";
@@ -2453,6 +2682,8 @@ 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";`);
@@ -2464,7 +2695,7 @@ function buildCreateHandlerBody(spec, command) {
 		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)},`);
@@ -2473,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}: /* TODO: unmapped ${payloadName} field "${fieldName}" */ undefined as never,`);
+			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([
@@ -2497,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},
@@ -2507,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`;
@@ -2597,28 +2832,51 @@ 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<never> {
-  void command;
-  void deps;
-  void eventContext;
-  throw new Error(
-    "[application_generator] Command \\"${spec.context.name}.${command.name}\\" cannot be fully generated. " +
-      "Expected a create command with effects or a mutation command with both effects and loadBy.",
-  );
+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) {
 	const queryName = `${pascalCase(query.name)}Query`;
 	const inputContractName = `${pascalCase(query.name)}Input`;
@@ -2761,17 +3019,26 @@ function projectionWritePortFileName(projectionName) {
 	return `${kebabCase(projectionName)}.projection-write.port.ts`;
 }
 function projectionSourcePayloadTypeName$1(source) {
-	return `${pascalCase(source.eventName)}Payload`;
+	return `${pascalCase(trimProjectionSourceEventName$1(source.eventName))}Payload`;
 }
-function projectionSourcePayloadImportPath$1(source) {
-	return `../../../${normalizeModulePath(source.contextName)}/domain/events/${kebabCase(source.eventName)}.event.ts`;
+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(projection) {
-	const payloadImports = projection.sources.slice().sort((left, right) => left.eventName.localeCompare(right.eventName)).map((source) => `import type { ${projectionSourcePayloadTypeName$1(source)} } from "${projectionSourcePayloadImportPath$1(source)}";`);
+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";
@@ -2955,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;
@@ -2980,13 +3254,17 @@ function buildV5ApplicationContextArtifacts(contextSpec) {
 	const projections = contextSpec.projections ?? [];
 	if (projections.length > 0) {
 		artifacts.push(createGeneratedArtifact(buildArtifactPath("core/contexts", modulePath, "application/ports/projections/index.ts"), createProjectionWritePortsIndexStub(projections)));
-		for (const projection of projections) artifacts.push(createGeneratedArtifact(buildArtifactPath("core/contexts", modulePath, `application/ports/projections/${projectionWritePortFileName(projection.name)}`), createProjectionWritePortStub(projection)));
+		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";
 }
@@ -3235,7 +3513,7 @@ function createDrizzleTableDefinition(spec, persistence = "postgres") {
 		...(spec.entities ?? []).map((entity) => scalarFields(entity.fields, entity.children ?? []))
 	].flat();
 	const coreImportTokens = [persistence === "mysql" ? "mysqlTable" : "pgTable", "text"];
-	if (flatScalarFields.some((field) => field.type === "number" && !isDecimalNumberField(field))) coreImportTokens.push("integer");
+	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");
@@ -3377,7 +3655,12 @@ function mikroOrmPropertyType(field) {
 function createMikroOrmEntitySchemaArtifactContent(spec) {
 	const nodes = flattenMikroOrmNodes(buildMikroOrmRootNode(spec));
 	const contextPrefix = pascalCase(spec.context.name);
-	const imports = [`import { Cascade, EntitySchema${nodes.some((node) => node.children.length > 0) ? ", Collection" : ""} } from "@mikro-orm/core";`];
+	const 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)};`);
@@ -3431,11 +3714,10 @@ function deserializePersistenceFieldValue(field, sourceExpr) {
 	return sourceExpr;
 }
 function rehydrateIdExpression(node, sourceExpr) {
-	if (node.idType && node.idType !== "string") return `create${pascalCase(node.idType)}(${sourceExpr})`;
-	return `createBrandedId("string", ${sourceExpr})`;
+	return `create${pascalCase(node.idType && node.idType !== "string" ? node.idType : defaultIdBrandName(node.name))}(${sourceExpr})`;
 }
-function buildMikroOrmNodeHelperBlock(spec, node) {
-	const domainTypeName = node.isAggregateRoot ? `${pascalCase(spec.aggregate.name)}Aggregate` : pascalCase(node.name);
+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) => {
@@ -3451,7 +3733,7 @@ function buildMikroOrmNodeHelperBlock(spec, node) {
 		const collectionName = camelCase(child.collectionFieldName ?? `${child.name}s`);
 		const childIdField = camelCase(child.idField);
 		return `  {
-    const currentById = new Map(${recordVar}.${collectionName}.getItems().map((item: ${child.className}) => [String(item.${childIdField}), item] as const));
+    const 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) {
@@ -3464,7 +3746,7 @@ function buildMikroOrmNodeHelperBlock(spec, node) {
   }`;
 	});
 	const parentParam = node.parent ? `, parent: ${node.parent.className}` : "";
-	const parentAssignment = node.parent ? `  record.${node.parent.propertyName} = parent;\n` : "";
+	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) => {
@@ -3477,10 +3759,10 @@ function buildMikroOrmNodeHelperBlock(spec, node) {
 		domainScalarLines.push(`    ${collectionName}: ${recordVar}.${collectionName}.getItems().map((item: ${child.className}) => map${child.className}ToDomain(item)),`);
 	}
 	return `function create${node.className}FromDomain(source: ${domainTypeName}${parentParam}): ${node.className} {
-  const record = new ${node.className}();
+  const ${recordVar} = new ${node.className}();
 ${parentAssignment}${scalarAssignmentLines.join("\n")}
 ${createChildLines.join("\n")}
-  return record;
+  return ${recordVar};
 }
 
 function sync${node.className}FromDomain(target: ${node.className}, source: ${domainTypeName}${parentSyncParam}): void {
@@ -3503,9 +3785,11 @@ function createMikroOrmRepository(spec, portName) {
 	const repositoryClassName = mikroOrmRepositoryClassName(spec.aggregate.name);
 	const rootNode = buildMikroOrmRootNode(spec);
 	const nodes = flattenMikroOrmNodes(rootNode);
-	const needsBrandedIdHelper = nodes.some((node) => !node.idType || node.idType === "string");
 	const customIdImports = /* @__PURE__ */ new Map();
-	for (const node of nodes) if (node.idType && node.idType !== "string") customIdImports.set(node.idType, `import { create${pascalCase(node.idType)} } from "${relativePrefix}/core/shared-kernel/entity-ids/${kebabCase(node.idType)}";`);
+	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`;
@@ -3520,20 +3804,37 @@ function createMikroOrmRepository(spec, portName) {
 		let current = node;
 		while (current && !current.isAggregateRoot) {
 			segments.unshift(camelCase(current.collectionFieldName ?? current.name));
-			current = current.parent ? nodes.find((candidate) => candidate.className === current.parent?.className) : void 0;
+			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";
-${needsBrandedIdHelper ? `import { createBrandedId } from "${relativePrefix}/lib/branded-id";\n` : ""}${[...customIdImports.values()].join("\n")}${customIdImports.size > 0 ? "\n" : ""}${notFoundImports}import { ${aggregateName}Aggregate } from "${relativePrefix}/core/contexts/${modulePath}/domain/aggregates/${aggregateDir}/${aggregateDir}.aggregate";
-${nodes.filter((node) => !node.isAggregateRoot).map((node) => `import { ${pascalCase(node.name)}Entity as ${pascalCase(node.name)} } from "${relativePrefix}/core/contexts/${modulePath}/domain/entities/${kebabCase(node.name)}.entity";`).join("\n")}${nodes.some((node) => !node.isAggregateRoot) ? "\n" : ""}import { ${nodes.map((node) => node.className).join(", ")} } from "../../entities/${modulePath}/${kebabCase(spec.aggregate.name)}.entity-schema.ts";
+${[...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>>;
@@ -3542,11 +3843,11 @@ function markTouchedAggregate(tx: unknown, aggregateType: string, aggregateId: s
   touched.set(aggregateType, ids);
 }
 
-${nodes.slice().reverse().map((node) => buildMikroOrmNodeHelperBlock(spec, node)).join("\n\n")}
+${helperBlocks}
 
 export class ${repositoryClassName} implements ${repositoryPortType} {
   async findById(${rootIdParamName}: ${rootIdTypeName}, tx: Transaction): Promise<Result<${aggregateName}Aggregate, ${notFoundTypeName}>> {
-    const em = tx as any;
+    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})));
@@ -3556,15 +3857,14 @@ export class ${repositoryClassName} implements ${repositoryPortType} {
   }
 
   async create(${camelCase(spec.aggregate.name)}: ${aggregateName}Aggregate, tx: Transaction): Promise<void> {
-    const em = tx as any;
+    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));
-    em.persist(rootRecord);
-    await em.flush();
+    await em.persist(rootRecord);
   }
 
   async save(${camelCase(spec.aggregate.name)}: ${aggregateName}Aggregate, expectedVersion: number, tx: Transaction): Promise<void> {
-    const em = tx as any;
+    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) {
@@ -3578,8 +3878,7 @@ export class ${repositoryClassName} implements ${repositoryPortType} {
 
     sync${rootNode.className}FromDomain(current, ${camelCase(spec.aggregate.name)});
     markTouchedAggregate(tx, "${aggregateName}", String(${camelCase(spec.aggregate.name)}.id.value));
-    em.persist(current);
-    await em.flush();
+    await em.persist(current);
   }
 }
 `;
@@ -3846,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);`);
@@ -4021,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) {`);
@@ -4205,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}}`);
 	}
@@ -4218,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`);
@@ -4227,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}}`);
@@ -4241,23 +4537,24 @@ function buildV5InfrastructureArtifacts(spec, options) {
 	const modulePath = normalizeModulePath(spec.context.modulePath);
 	const scopeKey = sliceArtifactOwnership(modulePath);
 	const artifacts = [];
+	const forceMikroOrmRepositories = options?.infrastructureStrategy?.orm === "mikroorm";
 	const hasDrizzleRepositoryAdapter = spec.adapters.some((adapter) => adapter.kind === "drizzle-repository");
-	spec.adapters.some((adapter) => adapter.kind === "mikroorm-repository");
-	if (!options?.skipContextWideArtifacts && hasDrizzleRepositoryAdapter) {
+	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.flatMap((adapter) => {
-		const port = spec.ports.find((p) => p.name === adapter.port);
-		if (port === void 0) return [];
-		if (adapter.kind === "drizzle-repository") {
+	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 (adapter.kind === "mikroorm-repository") {
+		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)];
@@ -4279,6 +4576,7 @@ function createContextDrizzleTableDefinition(contextSpec, persistence = "postgre
 		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;
@@ -4408,10 +4706,16 @@ function projectionWritePortImportPath(modulePath, projectionName) {
 	return `../../../../../core/contexts/${modulePath}/application/ports/projections/${kebabCase(projectionName)}.projection-write.port.ts`;
 }
 function projectionWriterPayloadTypeName(source) {
-	return `${pascalCase(source.eventName)}Payload`;
+	return `${pascalCase(trimEventNameSuffix(source.eventName))}Payload`;
 }
 function projectionWriterPayloadImportPath(source) {
-	return `../../../../../core/contexts/${normalizeModulePath(source.contextName)}/domain/events/${kebabCase(source.eventName)}.event.ts`;
+	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);
@@ -4420,11 +4724,12 @@ function projectionWriterEventType(source) {
 function buildProjectionWriterMethod(readModel, source, executorVariable, executorExpression, persistence = "postgres") {
 	const methodName = `on${pascalCase(source.eventName)}`;
 	const eventType = projectionWriterEventType(source);
-	const payloadLine = `    const payload = (((event as any)?.payload ?? event) ?? {}) as Record<string, unknown>;`;
+	const payloadLine = `    const payload = extractProjectionPayload(event);`;
 	const executorLine = `    const ${executorVariable} = ${executorExpression};`;
-	if (source.mutation.kind === "delete") {
-		const whereClause = source.mutation.matchOn.map((field) => `${snakeCase(field)} = ?`).join(" and ");
-		const deleteParams = source.mutation.matchOn.map((field) => `payload.${field}`).join(", ");
+	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}
@@ -4434,12 +4739,22 @@ ${executorLine}
     );
   }`;
 	}
-	const setEntries = Object.entries(source.mutation.set ?? {});
-	const insertColumns = setEntries.map(([fieldName]) => snakeCase(fieldName));
-	const insertParams = setEntries.map(([, mapping]) => buildProjectionMutationValueExpression(mapping));
-	const conflictColumns = source.mutation.matchOn.map((field) => snakeCase(field));
+	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 (source.mutation.kind === "upsert") {
+	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}
@@ -4450,16 +4765,18 @@ ${executorLine}
     );
   }`;
 	}
-	const updateAssignmentsSql = insertColumns.map((column) => `${column} = ?`).join(", ");
-	const whereClause = source.mutation.matchOn.map((field) => `${snakeCase(field)} = ?`).join(" and ");
-	const whereParams = source.mutation.matchOn.map((field) => `payload.${field}`);
+	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> {
-${payloadLine}
-${executorLine}
-    await ${executorVariable}.execute(
-      ${JSON.stringify(`update ${readModel.tableName} set ${updateAssignmentsSql} where ${whereClause}`)},
-      [${[...insertParams, ...whereParams].join(", ")}],
-    );
+    void event;
+    void tx;
+    throw new Error(${JSON.stringify(diagnosticMessage)});
   }`;
 }
 function buildProjectionMutationValueExpression(mapping) {
@@ -4470,13 +4787,41 @@ function buildProjectionMutationValueExpression(mapping) {
 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) => buildProjectionWriterMethod(readModel, source, "connection", "(tx as any).getConnection()", persistence)).join("\n\n");
+	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}
@@ -4486,13 +4831,25 @@ ${methodBlocks}
 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) => buildProjectionWriterMethod(readModel, source, "executor", "tx as any", persistence)).join("\n\n");
+	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}
@@ -4504,8 +4861,10 @@ function buildV5InfrastructureContextArtifacts(contextSpec, options = {}) {
 	const scopeKey = sliceArtifactOwnership(modulePath);
 	const artifacts = [];
 	const readModels = contextSpec.readModels ?? [];
-	const tableContent = createContextDrizzleTableDefinition(contextSpec, resolveDrizzlePersistence(options.infrastructureStrategy));
-	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, resolveDrizzlePersistence(options.infrastructureStrategy)), scopeKey));
 		artifacts.push(createGeneratedArtifact(`infrastructure/view-models/${modulePath}/drizzle/schema.ts`, createReadModelContextSchemaBarrel({
@@ -4542,7 +4901,7 @@ function createViewModelTablesSkeleton(contextSpec) {
 		lines.push(`    readModel: "${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;`);
@@ -4568,7 +4927,6 @@ function createReadModelRepositorySkeleton(modulePath, readModelName, queries) {
 	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) => {
-		queryReadModelMethodName(query);
 		const queryTypeName = `${pascalCase(query.name)}Query`;
 		const outputTypeName = queryOutputContractName(query);
 		const viewFileBase = queryViewFileBase(query);
@@ -4785,12 +5143,15 @@ function createSingleReadModelMethodSkeleton(query, readModelName) {
 	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.",
+        "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}> {
@@ -4799,7 +5160,7 @@ function createSingleReadModelMethodSkeleton(query, readModelName) {
     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.",
+        "Ensure output fields map directly to read-model fields and findById queries resolve a stable lookup field." + ${JSON.stringify(diagnosticReasons)},
     );
   }`;
 }
@@ -4822,10 +5183,19 @@ function projectionSourceHandlerName(eventName) {
 	return `on${pascalCase(eventName)}`;
 }
 function projectionSourcePayloadTypeName(source) {
-	return `${pascalCase(source.eventName)}Payload`;
+	return `${pascalCase(trimProjectionSourceEventName(source.eventName))}Payload`;
 }
 function projectionSourcePayloadImportPath(currentModulePath, source) {
-	return `../../${normalizeModulePath(source.contextName)}/domain/events/${kebabCase(source.eventName)}.event.ts`;
+	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);
@@ -4867,8 +5237,10 @@ function buildProjectionRebuildArtifact(modulePath, projection) {
 	const projectorClassName = projection.name;
 	const rebuildFunctionName = `rebuild${pascalCase(projection.name)}`;
 	const batchSize = projection.rebuild.batchSize ?? 500;
+	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<{
@@ -4907,7 +5279,10 @@ export async function ${rebuildFunctionName}(deps: ${pascalCase(projection.name)
     for (const event of batch.events) {
       switch (event.type) {
 ${projection.sources.slice().sort((left, right) => left.eventName.localeCompare(right.eventName)).map((source) => `        case "${source.contextName}.${source.aggregateName}.${source.eventName}":
-          await deps.projector.${projectionSourceHandlerName(source.eventName)}(event, deps.transaction);
+          await deps.projector.${projectionSourceHandlerName(source.eventName)}(
+            event.payload as ${projectionSourcePayloadTypeName(source)},
+            deps.transaction,
+          );
           break;`).join("\n")}
         default:
           break;
@@ -4932,7 +5307,7 @@ function buildProjectionSubscriptionsArtifact(contextSpec) {
 	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 eventImports = contextSpec.projections.flatMap((projection) => projection.sources.map((source) => `import type { ${projectionSourcePayloadTypeName(source)} } from "../../../core/contexts/${normalizeModulePath(source.contextName)}/domain/events/${kebabCase(source.eventName)}.event.ts";`));
+	const 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;
@@ -4942,7 +5317,7 @@ function buildProjectionSubscriptionsArtifact(contextSpec) {
       subscriptionName: "${subscriptionName}",
       eventName: "${source.contextName}.${source.aggregateName}.${source.eventName}",
       role: "${source.role}",${consumerGroupLine}
-      handle: (event: ${projectionSourceEventType(source)}, 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 { EventEnvelope } from "../../../lib/event-envelope.ts";
@@ -5033,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);
     });
   });`);
 		}
@@ -5059,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);
     });
   });`);
 	}
@@ -5093,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);
@@ -5109,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);
@@ -5117,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";`,
@@ -5137,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")}
 });
@@ -5167,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>(
@@ -5435,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,
@@ -5470,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") {
@@ -5508,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") {
@@ -5518,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");
 }
@@ -5536,9 +5935,9 @@ export function ${routerFactoryName}(deps: {
   commandBus: CommandBusPort;
   queryBus: QueryBusPort;
 }) {
-  return {
+  return router({
 ${procedureBodies}
-  };
+  });
 }
 `;
 }
@@ -5598,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`);
@@ -5606,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()
 	];
 }
 
@@ -5673,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() {
@@ -6019,32 +6442,110 @@ function buildConsumerAclArtifacts(contextSpec) {
 
 //#endregion
 //#region packages/core/orchestrator.ts
+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 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,
-				infrastructureStrategy: options.infrastructureStrategy
-			}),
-			...applyOwnershipIfMissing(buildV5TestArtifacts(view), ownership)
-		];
-	});
-	const ctxOwnership = contextArtifactOwnership(contextSpec.context.modulePath);
-	const infraOwnership = sliceArtifactOwnership(contextSpec.context.modulePath);
-	const perContextArtifacts = [
-		...buildV5LibArtifacts(options.infrastructureStrategy),
-		...buildV5SharedKernelArtifacts(contextSpec),
-		...buildV5PortArtifacts(),
-		...applyOwnershipIfMissing(buildV5ApplicationContextArtifacts(contextSpec), ctxOwnership),
-		...applyOwnershipIfMissing(buildConsumerAclArtifacts(contextSpec), ctxOwnership),
-		...applyOwnershipIfMissing(buildProjectionArtifacts(contextSpec), ctxOwnership),
-		...applyOwnershipIfMissing(buildV5InfrastructureContextArtifacts(contextSpec, { infrastructureStrategy: options.infrastructureStrategy }), infraOwnership),
-		...applyOwnershipIfMissing(buildV5PresentationArtifacts(contextSpec), ctxOwnership),
-		...applyOwnershipIfMissing(buildV5RouteArtifacts(contextSpec), ctxOwnership)
-	];
+	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));
 }
 
@@ -6659,42 +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<T>(work: (tx: unknown) => Promise<T>): Promise<T> {
-    return (this.em as any).transactional(async (tx: unknown) => {
-      return work(tx);
+  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();
+  }
 }
 `;
 }
@@ -6793,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, {
@@ -6865,6 +7390,7 @@ export class CommandBusImpl implements CommandBusPort {
         throw new TransactionAbortError(result.error);
       }
 
+      await this.txManager.flush(tx);
       aggregateEventTracker.releaseInto(eventCollector);
       const events = eventCollector.drain();
 
@@ -6912,7 +7438,7 @@ function buildCompositionBusArtifacts() {
 //#region packages/core/generators/composition_outbox.ts
 function createOutboxTable(infrastructureStrategy) {
 	if (infrastructureStrategy?.persistence === "mysql") return `import { sql } from "drizzle-orm";
-import { int, json, mysqlTable, timestamp, varchar } from "drizzle-orm/mysql-core";
+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())\`),
@@ -6926,9 +7452,11 @@ export const outboxEvents = mysqlTable("outbox_events", {
   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 { pgTable, uuid, varchar, jsonb, timestamp, integer } from "drizzle-orm/pg-core";
+	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(),
@@ -6942,29 +7470,36 @@ export const outboxEvents = pgTable("outbox_events", {
   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,
         eventVersion: event.eventVersion,
-        payload: event.payload,
-        metadata: {
+        payload: JSON.stringify(event.payload),
+        metadata: JSON.stringify({
           correlationId: event.correlationId,
           causationId: event.causationId,
           recordedBy: event.recordedBy,
           occurredAt: event.occurredAt,
-        },
+        }),
         occurredAt: event.occurredAt,
       });
     }
@@ -6972,9 +7507,52 @@ export class OutboxWriter {
 }
 `;
 }
+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,
@@ -6999,13 +7577,42 @@ type HandlerError = {
   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: unknown,
+    private readonly db: OutboxQueryExecutor,
     subscriptions: EventSubscription[],
     config?: OutboxDispatcherConfig,
   ) {
@@ -7022,11 +7629,10 @@ export class OutboxDispatcher {
   }
 
   async dispatchPending(): Promise<{ processed: number; failed: number }> {
-    const drizzle = this.db as any;
     let processed = 0;
     let failed = 0;
 
-    const rows: OutboxRow[] = await drizzle
+    const rows: OutboxRow[] = await this.db
       .select()
       .from(outboxEvents)
       .where(eq(outboxEvents.status, "pending"))
@@ -7058,9 +7664,9 @@ export class OutboxDispatcher {
       version: row.eventVersion,
       payload: row.payload,
       eventContext: {
-        correlationId: metadata.correlationId as any,
-        causationId: metadata.causationId as any,
-        recordedBy: metadata.recordedBy as any,
+        correlationId: createCorrelationId(requiredMetadataValue(metadata, "correlationId", row.eventType)),
+        causationId: createEventId(requiredMetadataValue(metadata, "causationId", row.eventType)),
+        recordedBy: createPersonnelId(requiredMetadataValue(metadata, "recordedBy", row.eventType)),
       },
     };
 
@@ -7106,8 +7712,7 @@ export class OutboxDispatcher {
     status: "pending" | "processed" | "failed",
     fields: Record<string, unknown>,
   ): Promise<void> {
-    const drizzle = this.db as any;
-    await drizzle
+    await this.db
       .update(outboxEvents)
       .set({ status, ...fields })
       .where(eq(outboxEvents.id, id));
@@ -7115,6 +7720,187 @@ export class OutboxDispatcher {
 }
 `;
 }
+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";
 
@@ -7180,12 +7966,13 @@ export class OutboxPoller {
 }
 function buildCompositionOutboxArtifacts(infrastructureStrategy) {
 	const ownership = sharedArtifactOwnership("composition");
+	const usesMikroOrm = infrastructureStrategy?.orm === "mikroorm";
 	return [
-		createGeneratedArtifact("infrastructure/outbox/outbox-dispatcher.ts", createOutboxDispatcher(), ownership),
+		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", createOutboxWriter(), ownership)
+		createGeneratedArtifact("infrastructure/outbox/outbox-writer.ts", usesMikroOrm ? createMikroOrmOutboxWriter(infrastructureStrategy) : createOutboxWriter(), ownership)
 	].sort((left, right) => left.logicalPath.localeCompare(right.logicalPath));
 }
 
@@ -7365,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);
@@ -7394,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";
@@ -7419,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")}
@@ -7439,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 });
@@ -7462,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";
@@ -7484,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}
       >(
         {
@@ -7499,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 });
@@ -7619,12 +8464,13 @@ function resolveRuntimeDependencies(compositionSpec) {
 	return [...dependencies].sort((left, right) => left.localeCompare(right));
 }
 function buildCompositionDependencyManifestArtifacts(compositionSpec) {
-	const manifest = {
-		kind: "zodmire-dependency-manifest",
-		infrastructure: compositionSpec.infrastructure,
-		dependencies: resolveRuntimeDependencies(compositionSpec)
-	};
-	return [createGeneratedArtifact("codegen/dependency-manifest.json", `${JSON.stringify(manifest, null, 2)}\n`, sharedArtifactOwnership("composition"))];
+	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
@@ -7635,7 +8481,7 @@ function buildCompositionDependencyManifestArtifacts(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);
@@ -7725,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(``);
@@ -7841,10 +8687,12 @@ function uniqueReadContexts(acls) {
 	}
 	return contexts;
 }
-function buildRepoFactoryContent(contextSpecs) {
+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 isMikroOrm = (repositoryPort ? spec.adapters.find((candidate) => candidate.port === repositoryPort.name && (candidate.kind === "drizzle-repository" || candidate.kind === "mikroorm-repository")) : void 0)?.kind === "mikroorm-repository";
+		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 {
@@ -7951,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;
@@ -7961,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);
@@ -7971,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");
@@ -8186,7 +9035,10 @@ async function buildContextNormalizedSpecFromConfig(input) {
 	}))), config);
 }
 async function buildV5ContextArtifacts(input) {
-	return generateContextArtifacts(await buildContextNormalizedSpecFromConfig(input), { infrastructureStrategy: input.infrastructureStrategy });
+	return generateContextArtifacts(await buildContextNormalizedSpecFromConfig(input), {
+		infrastructureStrategy: input.infrastructureStrategy,
+		generation: input.generation
+	});
 }
 async function buildV5Artifacts(input) {
 	const spec = await buildNormalizedSpecFromConfig(input);
@@ -8222,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, buildCompositionDependencyManifestArtifacts, buildCompositionOutboxArtifacts, buildCompositionRouterArtifacts, buildCompositionSpecDiff, buildCompositionSubscriptionArtifacts, buildCompositionTypeArtifacts, buildConsumerAclArtifacts, buildContextInputChecks, buildContextNormalizedSpec, buildContextNormalizedSpecFromConfig, buildContextSpecDiff, buildDrizzleConfig, buildFileArtifactTags, buildMaterializationManifestTags, buildMigrationResultTags, buildNormalizedCompositionSpec, buildNormalizedSpec, buildNormalizedSpecFromConfig, buildNormalizedSpecTags, buildProjectionArtifacts, buildReadModelCompositionArtifacts, buildSpecDiffTags, buildSummaryTags, buildV5ApplicationArtifacts, buildV5ApplicationContextArtifacts, buildV5Artifacts, buildV5ContextArtifacts, buildV5DomainArtifacts, buildV5InfrastructureArtifacts, buildV5InfrastructureContextArtifacts, buildV5LibArtifacts, buildV5PortArtifacts, buildV5PresentationArtifacts, buildV5RouteArtifacts, buildV5SharedKernelArtifacts, buildV5TestArtifacts, buildVendoredFileTags, camelCase, collectOwnedValueObjects, compositionSpecDiffDataName, contextArtifactOwnership, contextSpecDiffDataName, contractFileName, createGeneratedArtifact, discoverReferencedVos, ensureContextSupportFilesExist, filterPerContextArtifactsForComposition, flattenEntities, generateContextArtifacts, inferArtifactOwnership, inferCodegenSupportPathForContext, inferCodegenSupportPathFromSchemaFile, inferReconcileScopes, introspectObjectShape, introspectSchema, isRegisteredEntity, kebabCase, loadContextConfig, mergeGeneratedArtifacts, mergeSchemaReadResults, normalizeModulePath, parseConnectionString, parseDrizzleKitOutput, pascalCase, prepareAllVendoredFiles, prepareVendoredFile, readSchemaFile, repositoryPortFileName, repositoryPortTypeName, resolveAbsoluteContextInputs, resolveArtifactOwnership, resolveContextInputs, resolveFactoryPath, resolveGeneratedMigrationSchemaPath, resolveMethodContextInputsForCheck, resolveSchemaFilePathsForContext, resolveVoOwner, rewriteImports, runMigration, serializeCompositionSpec, serializeContextSpec, sharedArtifactOwnership, sliceArtifactOwnership, sliceContextIntoAggregateViews, snakeCase, snakeUpperCase, toImportURL, toUpperSnakeCase, unwrapFieldType, validateContextImports, walkEntityTree, withArtifactOwnership, wordsFromName };
+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 };