@cratis/chronicle 6.30.0 → 6.31.1

package/jobs/for_Jobs/against_a_kernel/when_managing_a_replay_job.integration.spec.ts

@@ -0,0 +1,114 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { randomUUID } from 'node:crypto';
+import { afterAll, beforeAll, chai, describe, it } from 'vitest';
+import { JobStatus, JobStepStatus, type JobStepSummaryResponse, type JobSummaryResponse } from '@cratis/chronicle.contracts';
+import { field, Guid } from '@cratis/fundamentals';
+import { ChronicleClient } from '../../../ChronicleClient.js';
+import { ChronicleOptions } from '../../../ChronicleOptions.js';
+import { fromContractsGuid } from '../../../connection/Guid.js';
+import type { IClientArtifactsProvider } from '../../../artifacts/index.js';
+import { eventType } from '../../../events/index.js';
+import type { IEventStore } from '../../../IEventStore.js';
+import { fromEvent } from '../../../projections/index.js';
+import { JobId } from '../../JobId.js';
+
+chai.should();
+
+// Runs against a real Chronicle kernel; skipped locally unless the connection string is set (see vitest.integration.config.ts).
+// In CI it never skips, so a missing connection string or unreachable kernel fails instead of passing vacuously.
+const connectionString = process.env.CHRONICLE_INTEGRATION_CONNECTION_STRING;
+
+@eventType()
+class ItemAdded {
+    @field(String) name = '';
+}
+
+@fromEvent(ItemAdded)
+class Item {
+    @field(String) name = '';
+}
+
+const artifacts: IClientArtifactsProvider = {
+    eventTypes: [ItemAdded],
+    readModels: [Item],
+    reactors: [],
+    reducers: [],
+    seeders: [],
+    constraints: [],
+    projections: [],
+    webhooks: [],
+    eventTypeMigrations: [],
+    globalForHandlers: []
+};
+
+async function eventually<T>(read: () => Promise<T>, accept: (value: T) => boolean, timeoutMs = 20_000): Promise<T> {
+    const deadline = Date.now() + timeoutMs;
+    let value = await read();
+    while (!accept(value)) {
+        if (Date.now() > deadline) throw new Error('Timed out waiting for the kernel');
+        await new Promise(resolve => setTimeout(resolve, 100));
+        value = await read();
+    }
+    return value;
+}
+
+describe.skipIf(!connectionString && !process.env.CI)('when managing a replay job against a kernel', () => {
+    let client: ChronicleClient;
+    let store: IEventStore;
+    let jobId: JobId;
+    let listed: JobSummaryResponse[];
+    let stopped: JobSummaryResponse | undefined;
+    let steps: JobStepSummaryResponse[];
+    let afterDelete: JobSummaryResponse | undefined;
+    let stopUnknownJob: unknown;
+    let deleteUnknownJob: unknown;
+
+    beforeAll(async () => {
+        client = new ChronicleClient(ChronicleOptions.fromConnectionString(connectionString!, {
+            discoveryPatterns: [],
+            clientArtifactsProvider: artifacts
+        }));
+        store = await client.getEventStore(`JobsEndToEnd${randomUUID().replaceAll('-', '')}`);
+
+        // Enough events that the replay is still running when it is stopped; a stopped job stays until deleted,
+        // where a completed one is removed and could not be listed reliably.
+        await store.eventLog.appendMany(Array.from({ length: 500 }, (_, index) => ({
+            eventSourceId: randomUUID(),
+            event: Object.assign(new ItemAdded(), { name: `Item ${index}` })
+        })));
+
+        jobId = await store.projections.replayForModel(Item);
+
+        // Stopping a job in the instant it starts leaves its step running forever, so wait until it is running.
+        await eventually(() => store.jobs.getJob(jobId), _ => _?.Status === JobStatus.JOB_STATUS_Running);
+        await store.jobs.stop(jobId);
+
+        listed = await store.jobs.getJobs();
+        stopped = await eventually(() => store.jobs.getJob(jobId), _ => _?.Status === JobStatus.JOB_STATUS_Stopped);
+        // The kernel updates step status asynchronously, after the job itself reports stopped.
+        steps = await eventually(
+            () => store.jobs.getJobSteps(jobId),
+            _ => _.length > 0 && _.every(step => step.Status === JobStepStatus.JOB_STEP_STATUS_Stopped),
+            30_000);
+
+        await store.jobs.delete(jobId);
+        afterDelete = await eventually(() => store.jobs.getJob(jobId), _ => _ === undefined);
+
+        stopUnknownJob = await store.jobs.stop(randomUUID()).catch((error: unknown) => error);
+        deleteUnknownJob = await store.jobs.delete(randomUUID()).catch((error: unknown) => error);
+    });
+
+    afterAll(() => client?.dispose());
+
+    it('should start a replay job', () => jobId.toString().should.not.equal(Guid.empty.toString()));
+    it('should list the job', () => listed.some(_ => fromContractsGuid(_.Id).toString() === jobId.toString()).should.be.true);
+    it('should report the job as a replay', () => stopped!.Type.should.equal('ReplayObserver'));
+    it('should report the job as stopped', () => stopped!.Status.should.equal(JobStatus.JOB_STATUS_Stopped));
+    it('should list the steps of the job', () => steps.length.should.be.greaterThan(0));
+    it('should report the steps as stopped', () => steps.every(_ => _.Status === JobStepStatus.JOB_STEP_STATUS_Stopped).should.be.true);
+    it('should no longer list the deleted job', () => (afterDelete === undefined).should.be.true);
+    it('should report stopping a job that does not exist', () => stopUnknownJob.should.be.instanceOf(Error));
+    it('should report deleting a job that does not exist', () => deleteUnknownJob.should.be.instanceOf(Error));
+});

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cratis/chronicle",
-    "version": "6.30.0",
+    "version": "6.31.1",
     "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/reactors/for_Reactors/against_a_kernel/when_replaying_once_only_reactors.integration.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 { randomUUID } from 'node:crypto';
+import { afterAll, beforeAll, chai, describe, it } from 'vitest';
+import { field } from '@cratis/fundamentals';
+import { ChronicleClient } from '../../../ChronicleClient.js';
+import { ChronicleOptions } from '../../../ChronicleOptions.js';
+import type { IClientArtifactsProvider } from '../../../artifacts/index.js';
+import type { ChronicleConnection } from '../../../connection/index.js';
+import { eventType } from '../../../events/index.js';
+import type { IEventStore } from '../../../IEventStore.js';
+import { onceOnly } from '../../onceOnly.js';
+import { reactor } from '../../reactor.js';
+
+chai.should();
+
+// Runs against a real Chronicle kernel; skipped locally unless the connection string is set (see vitest.integration.config.ts).
+// In CI it never skips, so a missing connection string or unreachable kernel fails instead of passing vacuously.
+const connectionString = process.env.CHRONICLE_INTEGRATION_CONNECTION_STRING;
+
+@eventType()
+class ThingHappened {
+    @field(String) name = '';
+}
+
+// The client constructs reactor instances; share sinks for assertions across that boundary.
+const onceOnlyInvocations: string[] = [];
+const replayableInvocations: string[] = [];
+
+@reactor()
+@onceOnly()
+class OnceOnlyReactor {
+    thingHappened(event: ThingHappened) { onceOnlyInvocations.push(event.name); }
+}
+
+@reactor()
+class ReplayableReactor {
+    thingHappened(event: ThingHappened) { replayableInvocations.push(event.name); }
+}
+
+const artifacts: IClientArtifactsProvider = {
+    eventTypes: [ThingHappened],
+    readModels: [],
+    reactors: [OnceOnlyReactor, ReplayableReactor],
+    reducers: [],
+    seeders: [],
+    constraints: [],
+    projections: [],
+    webhooks: [],
+    eventTypeMigrations: [],
+    globalForHandlers: []
+};
+
+async function eventually(accept: () => boolean, timeoutMs = 30_000): Promise<void> {
+    const deadline = Date.now() + timeoutMs;
+    while (!accept()) {
+        if (Date.now() > deadline) throw new Error('Timed out waiting for the kernel');
+        await new Promise(resolve => setTimeout(resolve, 250));
+    }
+}
+
+const isEmptyJobId = (jobId: string | undefined) => /^[0-]*$/.test(jobId ?? '');
+
+describe.skipIf(!connectionString && !process.env.CI)('when replaying reactors against a kernel', () => {
+    const storeName = `Replay${randomUUID().replaceAll('-', '').slice(0, 12)}`;
+    let client: ChronicleClient;
+    let store: IEventStore;
+    let connection: ChronicleConnection;
+    let onceOnlyJobId: string | undefined;
+    let replayableJobId: string | undefined;
+
+    const replay = (observerId: string) => connection.observers.replay({
+        EventStore: storeName,
+        Namespace: 'Default',
+        ObserverId: observerId,
+        EventSequenceId: 'event-log'
+    });
+
+    beforeAll(async () => {
+        client = new ChronicleClient(ChronicleOptions.fromConnectionString(connectionString!, {
+            discoveryPatterns: [],
+            clientArtifactsProvider: artifacts
+        }));
+        store = await client.getEventStore(storeName);
+        connection = (store as unknown as { _connection: ChronicleConnection })._connection;
+
+        (await store.eventLog.append(randomUUID(), Object.assign(new ThingHappened(), { name: 'first' }))).isSuccess.should.be.true;
+        await eventually(() => onceOnlyInvocations.length === 1 && replayableInvocations.length === 1);
+
+        onceOnlyJobId = (await replay('OnceOnlyReactor')).JobId;
+        replayableJobId = (await replay('ReplayableReactor')).JobId;
+        await eventually(() => replayableInvocations.length === 2);
+        await new Promise(resolve => setTimeout(resolve, 3_000));
+    });
+
+    afterAll(() => client?.dispose());
+
+    it('should replay a reactor that is not once-only', () => {
+        isEmptyJobId(replayableJobId).should.be.false;
+        replayableInvocations.should.deep.equal(['first', 'first']);
+    });
+
+    it('should not start a replay of a class-level once-only reactor', () => {
+        isEmptyJobId(onceOnlyJobId).should.be.true;
+    });
+
+    it('should not invoke a class-level once-only reactor again', () => {
+        onceOnlyInvocations.should.deep.equal(['first']);
+    });
+});

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/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);
+                }
+            }
+        }
+    }
+}