@cratis/chronicle 6.29.0 → 6.31.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cratis/chronicle",
-    "version": "6.29.0",
+    "version": "6.31.0",
     "description": "Event sourcing for TypeScript and Node.js — the idiomatic client for Cratis Chronicle, the open-source event-sourcing database",
     "author": "Cratis",
     "license": "MIT",
@@ -167,6 +167,7 @@
         "build": "tsc -b",
         "clean": "rm -rf dist",
         "test": "vitest run",
+        "test:integration": "vitest run --config vitest.integration.config.ts",
         "test:standard-types": "tsc --ignoreConfig --noEmit --target es2022 --module es2022 --moduleResolution bundler --lib es2022,esnext.decorators --types node --skipLibCheck --strict schemas/decorators.standard.spec.ts projections/declarative/addChildCompatibility.standard.spec.ts projections/modelBound/decorators.standard.spec.ts events/classDecorators.standard.spec.ts reactors/decorators.standard.spec.ts readModels/standardFallbacks.standard.spec.ts readModels/registration.standard.spec.ts for_ChronicleClient/when_registering_artifacts/with_standard_property_mappings.standard.spec.ts artifacts/validateArtifactSchemas.spec.ts",
         "test:native": "node ./scripts/check-native-esm.mjs"
     },

package/testing/ReactorScenario.ts

@@ -140,6 +140,8 @@ export class ReactorScenario {
     get produced(): readonly unknown[] { return Object.freeze(this._effects.map(effect => effect.value)); }
     get sideEffects(): readonly RecordedReactorSideEffect[] { return Object.freeze([...this._effects]); }
     get results(): readonly ReactorDeliveryResult[] { return Object.freeze([...this._results]); }
+    /** Committed input and explicit service appends; recorded returned effects are not part of this history. */
+    get appendedEvents(): readonly AppendedEvent[] { return this._events.appendedEvents; }
     /** Assertion view, deliberately not a callable Promise-like `then`. */
     get then(): { readonly produced: readonly unknown[]; readonly sideEffects: readonly RecordedReactorSideEffect[];
         readonly results: readonly ReactorDeliveryResult[] } {

package/testing/ReadModelScenario.childrenFrom.spec.ts

@@ -5,13 +5,13 @@ import { chai, describe, it } from 'vitest';
 import { eventType } from '../events/eventTypeDecorator.js';
 import { childrenFrom } from '../projections/modelBound/childrenFrom.js';
 import { fromEvent } from '../projections/modelBound/fromEvent.js';
+import { setFrom } from '../projections/modelBound/setFrom.js';
 import { ReadModelScenario, UnsupportedProjectionOperation } from './index.js';
 
 chai.should();
 
 class ScenarioItemAdded {
-    itemId = '';
-    name = '';
+    constructor(public itemId = '', public name = '') {}
 }
 eventType('scenario-keyed-item-added')(ScenarioItemAdded);
 
@@ -21,15 +21,41 @@ class ScenarioItem {
 }
 
 class ScenarioOrder {
+    id = '';
     items: ScenarioItem[] = [];
 }
 childrenFrom(ScenarioItemAdded, { childType: ScenarioItem, key: 'itemId' })(ScenarioOrder.prototype, 'items');
 fromEvent(ScenarioItemAdded)(ScenarioOrder);
 
+class ScenarioNamedItem {
+    id = '';
+    name = '';
+}
+setFrom(ScenarioItemAdded, 'name')(ScenarioNamedItem.prototype, 'name');
+
+class ScenarioNamedOrder {
+    id = '';
+    items: ScenarioNamedItem[] = [];
+}
+childrenFrom(ScenarioItemAdded, { childType: ScenarioNamedItem, key: 'itemId' })(ScenarioNamedOrder.prototype, 'items');
+fromEvent(ScenarioItemAdded)(ScenarioNamedOrder);
+
+const artifacts = { eventTypes: [ScenarioItemAdded], reducers: [], projections: [] };
+
 describe('when a read model scenario evaluates keyed children from the options form', () => {
-    it('should reject children projections explicitly when the scenario is created', () => {
-        (() => new ReadModelScenario(ScenarioOrder, { eventTypes: [ScenarioItemAdded], reducers: [], projections: [] }))
+    it('should add one child per key and update an existing child in place (children-untyped-items)', async () => {
+        const scenario = new ReadModelScenario(ScenarioOrder, artifacts);
+        scenario.given.forEventSource('order-1').events(
+            new ScenarioItemAdded('a', 'first'), new ScenarioItemAdded('b', 'second'), new ScenarioItemAdded('a', 'again'));
+        const order = await scenario.instanceForEventSourceId('order-1');
+        order!.id.should.equal('order-1');
+        // The kernel's AutoMap is schema-driven, and legacy decorators register an untyped child item schema.
+        order!.items.map(item => ({ id: item.id, name: item.name })).should.deep.equal([{ id: 'a', name: '' }, { id: 'b', name: '' }]);
+    });
+
+    it('should reject explicit child property mappings', () => {
+        (() => new ReadModelScenario(ScenarioNamedOrder, artifacts))
             .should.throw(UnsupportedProjectionOperation)
-            .with.property('message').that.includes('Children.items (@childrenFrom)').and.includes('children projections');
+            .with.property('message').that.includes('Children.items').and.includes('explicit child property mappings');
     });
 });

package/testing/ReadModelScenario.composition.spec.ts

@@ -0,0 +1,111 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { field } from '@cratis/fundamentals';
+import { chai, describe, it } from 'vitest';
+import { eventType } from '../events/eventTypeDecorator.js';
+import { fromEvent } from '../projections/modelBound/fromEvent.js';
+import { reactor } from '../reactors/reactor.js';
+import type { ReactorServices } from '../reactors/ReactorServices.js';
+import { reducer } from '../reducers/reducer.js';
+import { EventScenario, ReactorScenario, ReadModelScenario, UnsupportedProjectionOperation } from './index.js';
+
+chai.should();
+
+@eventType('composition-member-joined')
+class MemberJoined {
+    @field(String) name: string;
+    constructor(name: string) { this.name = name; }
+}
+
+@eventType('composition-member-welcomed')
+class MemberWelcomed {
+    @field(String) name: string;
+    constructor(name: string) { this.name = name; }
+}
+
+@fromEvent(MemberJoined)
+class Member {
+    @field(String) id = '';
+    @field(String) name = '';
+}
+
+class MemberCount { joined = 0; }
+class MemberCountReducer {
+    memberJoined(_event: MemberJoined, current: MemberCount | undefined): MemberCount {
+        return { joined: (current?.joined ?? 0) + 1 };
+    }
+}
+reducer('composition-member-count', undefined, MemberCount)(MemberCountReducer);
+
+@fromEvent(MemberWelcomed)
+class Welcome {
+    @field(String) id = '';
+    @field(String) name = '';
+}
+
+@reactor('composition-welcomer')
+class Welcomer {
+    async memberJoined(event: MemberJoined, context: { eventSourceId: string }, services: ReactorServices) {
+        await services.eventStore.eventLog.append(context.eventSourceId, new MemberWelcomed(event.name));
+        return new MemberWelcomed(`returned ${event.name}`);
+    }
+}
+
+const eventTypes = [MemberJoined, MemberWelcomed];
+const catalog = { eventTypes, reducers: [MemberCountReducer], projections: [] };
+
+describe('ReadModelScenario observing an EventScenario', () => {
+    it('projects the committed history at the time of each read', async () => {
+        const events = new EventScenario({ artifacts: { eventTypes }, constraints: 'disabled' });
+        const members = new ReadModelScenario(Member, catalog).observe(events);
+        await events.append('member-1', new MemberJoined('Ada'));
+        (await members.instanceForEventSourceId('member-1'))!.name.should.equal('Ada');
+        await events.appendMany('member-2', [new MemberJoined('Grace')]);
+        (await members.instanceForEventSourceId('member-2'))!.name.should.equal('Grace');
+    });
+
+    it('folds setup and action events through a reducer', async () => {
+        const events = new EventScenario({ artifacts: { eventTypes }, constraints: 'disabled' });
+        const counts = new ReadModelScenario(MemberCount, catalog).observe(events);
+        await events.given.forEventSource('club').events(new MemberJoined('Ada'));
+        await events.when.forEventSource('club').events(new MemberJoined('Grace'));
+        (await counts.instance)!.joined.should.equal(2);
+    });
+
+    it('rejects an explicitly routed event instead of guessing its projection semantics', async () => {
+        const events = new EventScenario({ artifacts: { eventTypes }, constraints: 'disabled' });
+        const members = new ReadModelScenario(Member, catalog).observe(events);
+        await events.appendMany([{ eventSourceId: 'member-1', event: new MemberJoined('Ada'), eventSourceType: 'Members' }]);
+        const error = await members.instanceForEventSourceId('member-1').then(() => undefined, (reason: unknown) => reason);
+        error.should.be.instanceOf(UnsupportedProjectionOperation);
+        (error as Error).message.should.contain('routed events');
+    });
+
+    it('rejects seeding events into an observing scenario', () => {
+        const members = new ReadModelScenario(Member, catalog).observe(new EventScenario({ artifacts: { eventTypes }, constraints: 'disabled' }));
+        (() => members.given.forEventSource('member-1').events(new MemberJoined('Ada'))).should.throw(UnsupportedProjectionOperation, 'not both');
+    });
+
+    it('rejects observing after seeding or observing twice', () => {
+        const events = new EventScenario({ artifacts: { eventTypes }, constraints: 'disabled' });
+        const seeded = new ReadModelScenario(Member, catalog);
+        seeded.given.forEventSource('member-1').events(new MemberJoined('Ada'));
+        (() => seeded.observe(events)).should.throw(UnsupportedProjectionOperation, 'not both');
+        const observing = new ReadModelScenario(Member, catalog).observe(events);
+        (() => observing.observe(events)).should.throw(UnsupportedProjectionOperation, 'not both');
+    });
+});
+
+describe('ReadModelScenario observing a ReactorScenario', () => {
+    it('reads input events and the reactor\'s explicit appends, but not its recorded returned effects', async () => {
+        const reactorScenario = new ReactorScenario(Welcomer, { artifacts: { eventTypes }, constraints: 'disabled' });
+        const welcomes = new ReadModelScenario(Welcome, catalog).observe(reactorScenario);
+        const members = new ReadModelScenario(Member, catalog).observe(reactorScenario);
+        await reactorScenario.when.forEventSource('member-1').events(new MemberJoined('Ada'));
+        (await members.instanceForEventSourceId('member-1'))!.name.should.equal('Ada');
+        (await welcomes.instanceForEventSourceId('member-1'))!.name.should.equal('Ada');
+        reactorScenario.appendedEvents.length.should.equal(2);
+        reactorScenario.shouldHaveProduced(MemberWelcomed, welcome => welcome.name === 'returned Ada');
+    });
+});

package/testing/ReadModelScenario.ts

@@ -23,6 +23,8 @@ import type { IReadModelProcessor } from './IReadModelProcessor.js';
 import type { ReadModelState } from './ReadModelState.js';
 import { ReducerReadModelProcessor } from './ReducerReadModelProcessor.js';
 import type { ScenarioEvent } from './ScenarioEvent.js';
+import type { EventScenario } from './EventScenario.js';
+import type { ReactorScenario } from './ReactorScenario.js';
 import { ProjectionReadModelProcessor } from './projections/ProjectionReadModelProcessor.js';
 import { UnsupportedProjectionOperation } from './projections/UnsupportedProjectionOperation.js';
 
@@ -39,6 +41,7 @@ export class ReadModelScenario<TReadModel extends object> {
     private readonly _modelName: string;
     private readonly _events: ScenarioEvent[] = [];
     private _results: Promise<Map<string, ReadModelState<TReadModel>>> | undefined;
+    private _observed: EventScenario | ReactorScenario | undefined;
 
     /** Selects the reducer (when present) or a single applicable compiled projection. */
     constructor(readModelType: Constructor<TReadModel>, artifacts?: ScenarioArtifacts) {
@@ -109,8 +112,20 @@ export class ReadModelScenario<TReadModel extends object> {
         return (await this.process()).get(id)?.deleted ?? false;
     }
 
+    /**
+     * Reads the committed history of an EventScenario or ReactorScenario instead of seeded events.
+     * Every read replays that shared sequence as it is at the time of the read.
+     */
+    observe(source: EventScenario | ReactorScenario): this {
+        if (this._observed || this._events.length) throw this.mixedHistory();
+        this._observed = source;
+        this._results = undefined;
+        return this;
+    }
+
     /** Collects events for a source; subsequent reads replay the complete seeded history. */
     collectEventsFor(id: string, events: readonly object[]): void {
+        if (this._observed) throw this.mixedHistory();
         for (const event of events) {
             const metadata = getEventTypeMetadata(event.constructor);
             if (!metadata) throw new Error(`Event '${event.constructor.name}' has no @eventType metadata.`);
@@ -139,13 +154,32 @@ export class ReadModelScenario<TReadModel extends object> {
     }
 
     private process(): Promise<Map<string, ReadModelState<TReadModel>>> {
-        if (!this._results) {
-            const events = [...this._events];
-            this._results = this._processor.process(events).catch(error => {
-                if (!(this._processor instanceof ProjectionReadModelProcessor) || error instanceof UnsupportedProjectionOperation) throw error;
-                throw new Error(`Projection replay for read model '${this._modelName}' failed: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
-            });
-        }
+        if (this._observed) return this.replay(this.observedEvents(this._observed));
+        this._results ??= this.replay([...this._events]);
         return this._results;
     }
+
+    private replay(events: ScenarioEvent[]): Promise<Map<string, ReadModelState<TReadModel>>> {
+        return this._processor.process(events).catch(error => {
+            if (!(this._processor instanceof ProjectionReadModelProcessor) || error instanceof UnsupportedProjectionOperation) throw error;
+            throw new Error(`Projection replay for read model '${this._modelName}' failed: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+        });
+    }
+
+    private observedEvents(source: EventScenario | ReactorScenario): ScenarioEvent[] {
+        return source.appendedEvents.map(event => {
+            const { eventSourceType = 'Default', eventStreamType = 'All', eventStreamId = 'Default' } = event.context;
+            // No fixture establishes how the evaluator should treat an explicitly routed event; the kernel decides.
+            if (eventSourceType !== 'Default' || eventStreamType !== 'All' || eventStreamId !== 'Default') {
+                throw new UnsupportedProjectionOperation(this._modelName, 'observe', `${eventSourceType}/${eventStreamType}/${eventStreamId}`,
+                    'observed events must use the default event source type and stream; routed events require a kernel-backed test');
+            }
+            return { sourceId: event.context.eventSourceId, content: event.content, context: event.context };
+        });
+    }
+
+    private mixedHistory(): UnsupportedProjectionOperation {
+        return new UnsupportedProjectionOperation(this._modelName, 'observe', 'given.events',
+            'a scenario replays either its own seeded events or one observed event sequence, not both');
+    }
 }

package/testing/projections/ProjectionCapabilities.ts

@@ -6,8 +6,9 @@ import { EventSequenceId } from '../../eventSequences/EventSequenceId.js';
 import type { CompiledProjectionDefinitions } from '../../projections/CompiledProjectionDefinitions.js';
 import { eventContractPath } from '../../projections/eventContractPath.js';
 import type { ContractEventType, FromRecord, RemovedWithRecord } from '../../projections/declarative/ProjectionBuilderCore.js';
-import { getEventTypeMapKey } from '../../projections/modelBound/childrenAndNestedBuilder.js';
+import { getEventTypeMapKey, type ChildrenDefinitionLike } from '../../projections/modelBound/childrenAndNestedBuilder.js';
 import type { JsonSchema } from '../../schemas/JsonSchema.js';
+import { ProjectionChildrenCapabilities } from './ProjectionChildrenCapabilities.js';
 import { UnsupportedProjectionOperation } from './UnsupportedProjectionOperation.js';
 
 /** Validates *all* subscribed operations against the bounded scenario subset, before replay. */
@@ -36,11 +37,11 @@ export class ProjectionCapabilities {
         if (wire.IsActive === false) reject('IsActive', 'passive projections require a kernel-backed test');
         if (wire.SubscribesToAllEvents === true) reject('SubscribesToAllEvents', 'subscribe-to-all projections require a kernel-backed test');
         if (wire.EventSequenceId !== EventSequenceId.eventLog.value) reject('EventSequenceId', 'non-default event sequences require a kernel-backed test');
-        for (const section of ['Join', 'Children', 'Nested', 'RemovedWithJoin'] as const) {
+        for (const section of ['Join', 'Nested', 'RemovedWithJoin'] as const) {
             const value = wire[section];
             const paths = Array.isArray(value) ? value.map((entry: { Key: ContractEventType }) => eventContractPath(section, entry.Key))
                 : Object.keys(value as Record<string, unknown> ?? {}).map(property => `${section}.${property}`);
-            if (paths.length) reject(paths[0], `${section === 'Children' ? 'children projections' : section === 'Nested' ? 'nested projections' : section === 'Join' ? 'joins' : 'removedWithJoin'} require a kernel-backed test`);
+            if (paths.length) reject(paths[0], `${section === 'Nested' ? 'nested projections' : section === 'Join' ? 'joins' : 'removedWithJoin'} require a kernel-backed test`);
         }
         if ((wire.FromEvery as unknown[] | undefined)?.length) reject('FromEvery', 'derivative projections require a kernel-backed test');
         if (wire.FromEventProperty) reject('FromEventProperty', 'event-property subscriptions require a kernel-backed test');
@@ -110,6 +111,12 @@ export class ProjectionCapabilities {
                 this.checkAutoMap(schema!, eventSchema, properties, wire.NoAutoMapProperties as string[] ?? [], path, reject);
             }
         }
+        ProjectionChildrenCapabilities.validate(wire.Children as Record<string, ChildrenDefinitionLike> ?? {}, {
+            schema: schema!, rootAutoMap: wire.AutoMap as AutoMap, hasInitialModelState: Object.keys(initial as object).length > 0, from, removedWith, requireEventSchema, reject,
+            declarationFor: path => provenance.find(entry => entry.contractPath === path)?.declaration,
+            checkMapping: (modelSchema, eventSchema, destination, expression, path) =>
+                this.checkMapping(modelSchema, eventSchema, destination, expression, path, reject)
+        });
     }
 
     private static checkAutoMap(

package/testing/projections/ProjectionChildrenCapabilities.ts

@@ -0,0 +1,119 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { AutoMap } from '@cratis/chronicle.contracts';
+import { eventContractPath } from '../../projections/eventContractPath.js';
+import type { ContractEventType, FromRecord, RemovedWithRecord } from '../../projections/declarative/ProjectionBuilderCore.js';
+import type { ChildrenDefinitionLike } from '../../projections/modelBound/childrenAndNestedBuilder.js';
+import type { JsonSchema } from '../../schemas/JsonSchema.js';
+
+/** Rejects an operation at a contract path, optionally naming the responsible declaration. */
+export type RejectOperation = (path: string, reason: string, fallback?: string) => never;
+
+/** Validates a scalar mapping into a target schema, rejecting anything outside the fixture-backed subset. */
+export type CheckMapping = (modelSchema: JsonSchema, eventSchema: JsonSchema, destination: string, expression: string, path: string) => void;
+
+/** The inputs children validation shares with root validation. */
+export interface ChildrenValidationContext {
+    readonly schema: JsonSchema;
+    readonly rootAutoMap: AutoMap;
+    readonly hasInitialModelState: boolean;
+    readonly from: readonly FromRecord[];
+    readonly removedWith: readonly RemovedWithRecord[];
+    readonly declarationFor: (path: string) => string | undefined;
+    readonly requireEventSchema: (eventType: ContractEventType, path: string) => JsonSchema;
+    readonly checkMapping: CheckMapping;
+    readonly reject: RejectOperation;
+}
+
+const kernelBacked = 'require a kernel-backed test (ChronicleKernelScenario / live kernel)';
+
+/**
+ * Validates one level of children collections against the packaged-kernel fixtures
+ * (`children-from-keyed`, `children-identified-removed`, `children-untyped-items`).
+ */
+export class ProjectionChildrenCapabilities {
+    /**
+     * Throws for the first children operation outside the fixture-backed subset.
+     * @param children - The wire `Children` section of the root definition.
+     * @param context - Shared root validation state.
+     */
+    static validate(children: Record<string, ChildrenDefinitionLike>, context: ChildrenValidationContext): void {
+        if (Object.keys(children).length && context.hasInitialModelState) {
+            context.reject('InitialModelState', `children with initial model state ${kernelBacked}`);
+        }
+        const owners = new Map<string, string>();
+        for (const [property, child] of Object.entries(children)) {
+            const base = `Children.${property}`;
+            const declaration = context.declarationFor(base);
+            const reject = (path: string, reason: string): never => context.reject(path, reason, declaration);
+            const wire = child as unknown as Record<string, unknown>;
+            if ((child.Join ?? []).length) reject(`${base}.Join`, 'joins require a kernel-backed test');
+            if (Object.keys(child.Children ?? {}).length) reject(`${base}.Children`, `nested children collections ${kernelBacked}`);
+            if (Object.keys(child.Nested ?? {}).length) reject(`${base}.Nested`, `nested projections inside children ${kernelBacked}`);
+            if ((child.RemovedWithJoin ?? []).length) reject(`${base}.RemovedWithJoin`, `removedWithJoin inside children ${kernelBacked}`);
+            if (wire.FromEventProperty) reject(`${base}.FromEventProperty`, `value children from an event property ${kernelBacked}`);
+            if (Object.keys(child.All?.Properties ?? {}).length || child.All?.IncludeChildren || (child.All?.AutoMap ?? AutoMap.Inherit) !== AutoMap.Inherit) {
+                reject(`${base}.All`, `fromEvery/all inside children ${kernelBacked}`);
+            }
+            if ((child.NoAutoMapProperties ?? []).length) reject(`${base}.NoAutoMapProperties`, `child AutoMap exclusions ${kernelBacked}`);
+            const autoMap = child.AutoMap === AutoMap.Inherit ? context.rootAutoMap : child.AutoMap;
+            if (autoMap === AutoMap.Disabled) reject(`${base}.AutoMap`, `children with AutoMap disabled ${kernelBacked}`);
+
+            const collection = context.schema.properties?.[property];
+            const items = collection?.items;
+            if (collection?.type !== 'array' || items?.type !== 'object') {
+                reject(base, `children collections must target an array of objects; other targets ${kernelBacked}`);
+            }
+            const typed = items!.properties !== undefined;
+            const identifiedBy = child.IdentifiedBy;
+            if (!identifiedBy || identifiedBy === '*NotSet*' || identifiedBy.includes('.')) {
+                reject(`${base}.IdentifiedBy`, `children without a direct identifying property ${kernelBacked}`);
+            }
+            const identity = items!.properties?.[identifiedBy];
+            if (typed && (identity?.type !== 'string' || identity.format)) {
+                reject(`${base}.IdentifiedBy`, `only a string child identifier is fixture-backed; other identifiers ${kernelBacked}`);
+            }
+
+            for (const entry of [...(child.From ?? []), ...(child.RemovedWith ?? [])]) {
+                const section = (child.From ?? []).includes(entry as FromRecord) ? 'From' : 'RemovedWith';
+                const path = `${base}.${eventContractPath(section, entry.Key)}`;
+                const owner = owners.get(entry.Key.Id);
+                if (owner) reject(path, `an event subscribed by more than one children operation (${owner}) ${kernelBacked}`);
+                owners.set(entry.Key.Id, path);
+                if (context.removedWith.some(removal => removal.Key.Id === entry.Key.Id) ||
+                    (section === 'RemovedWith' && context.from.some(root => root.Key.Id === entry.Key.Id))) {
+                    reject(path, `an event that both removes and changes the parent or a child ${kernelBacked}`);
+                }
+                const eventSchema = context.requireEventSchema(entry.Key, path);
+                const key = eventSchema.properties?.[entry.Value.Key];
+                if (!/^[A-Za-z_]\w*$/.test(entry.Value.Key) || key?.type !== 'string' || key.format) {
+                    reject(`${path}.Key`, `only a child key read from a string event property is fixture-backed; other child keys ${kernelBacked}`);
+                }
+                if (entry.Value.ParentKey && entry.Value.ParentKey !== '$eventSourceId') {
+                    reject(`${path}.ParentKey`, `parent keys other than the event source id ${kernelBacked}`);
+                }
+                if (section === 'RemovedWith') continue;
+                const properties = (entry as FromRecord).Value.Properties ?? {};
+                for (const [destination, expression] of Object.entries(properties)) {
+                    const mappingPath = `${path}.Properties.${destination}`;
+                    if (destination === identifiedBy) {
+                        if (expression !== entry.Value.Key) reject(mappingPath, `mapping the child identifier from anything but the child key ${kernelBacked}`);
+                        continue;
+                    }
+                    reject(mappingPath, `explicit child property mappings (renames, event context, constants, nulls) ${kernelBacked}; only same-name AutoMap into typed children is supported`);
+                }
+                if (!typed) continue;
+                for (const destination of Object.keys(items!.properties ?? {})) {
+                    if (Object.keys(properties).some(name => name.toLowerCase() === destination.toLowerCase())) continue;
+                    const candidates = Object.keys(eventSchema.properties ?? {}).filter(source => source.toLowerCase() === destination.toLowerCase());
+                    if (!candidates.length) continue;
+                    const mappingPath = `${path}.AutoMap.${destination}`;
+                    if (destination === identifiedBy) reject(mappingPath, `AutoMap into the child identifier ${kernelBacked}`);
+                    if (candidates.length > 1) reject(mappingPath, `inferred AutoMap source is ambiguous: ${candidates.join(', ')}`);
+                    context.checkMapping(items!, eventSchema, destination, candidates[0], mappingPath);
+                }
+            }
+        }
+    }
+}