@cratis/chronicle 6.36.0 → 6.37.0

package/patterns/for_Patterns/when_browsing/within_a_scope.spec.ts

@@ -0,0 +1,25 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { beforeEach, chai, describe, it } from 'vitest';
+import { BehaviorPatternDetailsResponse } from '@cratis/chronicle.contracts';
+import type { BehaviorPattern } from '../../index.js';
+import { a_patterns_service } from '../given/a_patterns_service.fixture.js';
+
+chai.should();
+
+describe('when browsing every pattern for a scope', () => {
+    let context: a_patterns_service;
+    let result: BehaviorPattern[];
+    beforeEach(async () => {
+        context = new a_patterns_service();
+        context.response.Data = [BehaviorPatternDetailsResponse.create({ Id: 'pattern-1', GroupingKey: 'user-42' })];
+        result = await context.patterns.getPatternsForScope('user-42');
+    });
+    it('should address the scope within the event store namespace without limits', () => {
+        context.client.patternsForScope.mock.calls[0][0].should.deep.equal({
+            EventStore: 'accounts', Namespace: 'tenant-a', GroupingKey: 'user-42'
+        });
+    });
+    it('should convert the established patterns', () => result[0].id.should.equal('pattern-1'));
+});

package/patterns/for_Patterns/when_querying/with_query_outcomes.spec.ts

@@ -0,0 +1,47 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { beforeEach, chai, describe, it } from 'vitest';
+import { ChronicleCallFailed } from '../../../connection/callResults.js';
+import type { IPatterns } from '../../index.js';
+import { a_patterns_service } from '../given/a_patterns_service.fixture.js';
+
+const should = chai.should();
+const queries: Record<string, (patterns: IPatterns) => Promise<unknown[]>> = {
+    matching: patterns => patterns.getPatterns('user-42', {}),
+    actions: patterns => patterns.getUsualActions('user-42', {}),
+    moment: patterns => patterns.getPatternsAt('user-42'),
+    scope: patterns => patterns.getPatternsForScope('user-42'),
+    scopes: patterns => patterns.getScopes()
+};
+
+for (const [name, query] of Object.entries(queries)) {
+    describe(`when querying ${name} with no established behavior`, () => {
+        let result: unknown[];
+        beforeEach(async () => result = await query(new a_patterns_service().patterns));
+        it('should return an empty answer without inventing behavior', () => result.should.deep.equal([]));
+    });
+
+    for (const failureKind of ['authorization', 'validation', 'exception', 'transport']) {
+        describe(`when querying ${name} with a ${failureKind} failure`, () => {
+            let failure: unknown;
+            const transportFailure = new Error('transport unavailable');
+            beforeEach(async () => {
+                const context = new a_patterns_service();
+                for (const response of [context.response, context.scopesResponse]) {
+                    if (failureKind === 'authorization') response.IsAuthorized = false;
+                    if (failureKind === 'validation') response.ValidationResults = [{ Severity: 3, Message: 'invalid context', Members: [] }];
+                    if (failureKind === 'exception') response.ExceptionMessages = ['query failed'];
+                }
+                if (failureKind === 'transport') {
+                    for (const client of Object.values(context.client)) client.mockRejectedValue(transportFailure);
+                }
+                try { await query(context.patterns); } catch (error) { failure = error; }
+            });
+            it('should reject instead of disguising failure as no behavior', () => {
+                if (failureKind === 'transport') should.equal(failure, transportFailure);
+                else (failure as Error).should.be.instanceOf(ChronicleCallFailed);
+            });
+        });
+    }
+}

package/patterns/for_Patterns/when_querying_a_context/with_established_patterns.spec.ts

@@ -0,0 +1,34 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { beforeEach, chai, describe, it } from 'vitest';
+import { BehaviorPatternDetailsResponse } from '@cratis/chronicle.contracts';
+import type { BehaviorPattern } from '../../index.js';
+import { a_patterns_service } from '../given/a_patterns_service.fixture.js';
+
+const should = chai.should();
+
+describe('when querying a context with established patterns', () => {
+    let result: BehaviorPattern[];
+    beforeEach(async () => {
+        const context = new a_patterns_service();
+        context.response.Data = [
+            BehaviorPatternDetailsResponse.create({
+                Id: 'pattern-1', GroupingKey: 'user-42', Facets: { Day: 'Monday', CommandType: 'RegisterInvoice' },
+                Confidence: 0.75, Support: 0.2, Occurrences: 9_007_199_254_740_993n, Weight: 3.5, Specificity: 2,
+                FirstSeen: { Value: '2026-01-05T09:00:00+02:00' }, LastSeen: { Value: '2026-01-12T09:00:00+02:00' }
+            }),
+            BehaviorPatternDetailsResponse.create({ Id: 'pattern-2', Confidence: 0.95 })
+        ];
+        result = await context.patterns.getPatterns('user-42', {});
+    });
+    it('should convert every response field without losing occurrence precision', () => {
+        result[0].should.deep.equal({
+            id: 'pattern-1', groupingKey: 'user-42', facets: { Day: 'Monday', CommandType: 'RegisterInvoice' },
+            confidence: 0.75, support: 0.2, occurrences: 9_007_199_254_740_993n, weight: 3.5, specificity: 2,
+            firstSeen: new Date('2026-01-05T07:00:00Z'), lastSeen: new Date('2026-01-12T07:00:00Z')
+        });
+    });
+    it('should preserve the server ranking', () => result.map(pattern => pattern.id).should.deep.equal(['pattern-1', 'pattern-2']));
+    it('should not invent a missing observation timestamp', () => should.equal(result[1].firstSeen, undefined));
+});

package/patterns/for_Patterns/when_querying_a_context/with_facets.spec.ts

@@ -0,0 +1,32 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { beforeEach, chai, describe, it } from 'vitest';
+import { FacetName } from '../../index.js';
+import { a_patterns_service } from '../given/a_patterns_service.fixture.js';
+
+chai.should();
+
+for (const method of ['getPatterns', 'getUsualActions'] as const) {
+    for (const limited of [false, true]) {
+        describe(`when ${method} queries facets ${limited ? 'with explicit limits' : 'with server defaults'}`, () => {
+            let context: a_patterns_service;
+            beforeEach(async () => {
+                context = new a_patterns_service();
+                await context.patterns[method]('user-42', {
+                    [FacetName.CommandType]: 'RegisterInvoice',
+                    [FacetName.AggregateType]: '',
+                    CustomFacet: 'custom-value'
+                }, limited ? { minimumConfidence: 0.75, maximumResults: 3 } : undefined);
+            });
+            it('should scope the query and omit unspecified facet values', () => {
+                const client = method === 'getPatterns' ? context.client.matchingPatterns : context.client.usualActions;
+                client.mock.calls[0][0].should.deep.equal({
+                    EventStore: 'accounts', Namespace: 'tenant-a', GroupingKey: 'user-42',
+                    Context: { CommandType: 'RegisterInvoice', CustomFacet: 'custom-value' },
+                    MinimumConfidence: limited ? 0.75 : 0, MaximumResults: limited ? 3 : 0
+                });
+            });
+        });
+    }
+}

package/patterns/for_Patterns/when_querying_at_a_moment/with_additional_facets.spec.ts

@@ -0,0 +1,34 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { beforeEach, chai, describe, it } from 'vitest';
+import { DayOfWeek, FacetName, type FacetSet, TimeBucket } from '../../index.js';
+import { a_patterns_service } from '../given/a_patterns_service.fixture.js';
+
+chai.should();
+
+describe('when querying at a moment with additional facets', () => {
+    let context: a_patterns_service;
+    const facets: FacetSet = Object.freeze({
+        [FacetName.AggregateType]: 'Invoice',
+        [FacetName.CommandType]: 'RegisterInvoice',
+        [FacetName.Day]: DayOfWeek.Friday,
+        [FacetName.TimeBucket]: TimeBucket.Evening,
+        CustomFacet: 'custom-value'
+    });
+    beforeEach(async () => {
+        context = new a_patterns_service();
+        await context.patterns.getPatternsAt('user-42', {
+            instant: new Date('2026-01-04T23:30:00Z'), offsetMinutes: 345
+        }, { alsoConstraining: facets, minimumConfidence: 0.8, maximumResults: 5 });
+    });
+    it('should ask about usual actions in the explicit offset day and bucket', () => {
+        context.client.usualActions.mock.calls[0][0].should.deep.equal({
+            EventStore: 'accounts', Namespace: 'tenant-a', GroupingKey: 'user-42',
+            Context: { ...facets, Day: DayOfWeek.Monday, TimeBucket: TimeBucket.EarlyMorning },
+            MinimumConfidence: 0.8, MaximumResults: 5
+        });
+    });
+    it('should not use the descriptive matching endpoint', () => context.client.matchingPatterns.mock.calls.should.have.lengthOf(0));
+    it('should leave the caller context unchanged', () => facets[FacetName.Day].should.equal(DayOfWeek.Friday));
+});

package/patterns/for_Patterns/when_querying_at_a_moment/with_an_invalid_moment.spec.ts

@@ -0,0 +1,20 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { beforeEach, chai, describe, it } from 'vitest';
+import { a_patterns_service } from '../given/a_patterns_service.fixture.js';
+
+chai.should();
+
+describe('when querying an invalid moment', () => {
+    let context: a_patterns_service;
+    let failure: unknown;
+    beforeEach(async () => {
+        context = new a_patterns_service();
+        try {
+            await context.patterns.getPatternsAt('user-42', { instant: new Date(NaN), offsetMinutes: 0 });
+        } catch (error) { failure = error; }
+    });
+    it('should reject the query', () => (failure as Error).should.be.instanceOf(RangeError));
+    it('should not send a misleading context to the kernel', () => context.client.usualActions.mock.calls.should.have.lengthOf(0));
+});

package/patterns/for_Patterns/when_querying_at_a_moment/without_a_moment.spec.ts

@@ -0,0 +1,37 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { afterEach, beforeEach, chai, describe, it, vi } from 'vitest';
+import { DayOfWeek, FacetName, TimeBucket } from '../../index.js';
+import { a_patterns_service } from '../given/a_patterns_service.fixture.js';
+
+chai.should();
+
+for (const withOptions of [false, true]) {
+    describe(`when querying now ${withOptions ? 'with additional facets' : 'with only a scope'}`, () => {
+        let context: a_patterns_service;
+        beforeEach(async () => {
+            vi.useFakeTimers({ toFake: ['Date'] });
+            vi.setSystemTime(new Date('2026-01-05T01:00:00Z'));
+            // Simulate a machine west of UTC regardless of the machine running the specs.
+            vi.spyOn(Date.prototype, 'getTimezoneOffset').mockReturnValue(240);
+            context = new a_patterns_service();
+            if (withOptions) {
+                await context.patterns.getPatternsAt('user-42', undefined, { alsoConstraining: { [FacetName.AggregateType]: 'Invoice' } });
+            } else {
+                await context.patterns.getPatternsAt('user-42');
+            }
+        });
+        afterEach(() => { vi.restoreAllMocks(); vi.useRealTimers(); });
+        it('should capture now at the local system offset with server default limits', () => {
+            context.client.usualActions.mock.calls[0][0].should.deep.equal({
+                EventStore: 'accounts', Namespace: 'tenant-a', GroupingKey: 'user-42',
+                Context: {
+                    ...(withOptions ? { AggregateType: 'Invoice' } : {}),
+                    Day: DayOfWeek.Sunday, TimeBucket: TimeBucket.Evening
+                },
+                MinimumConfidence: 0, MaximumResults: 0
+            });
+        });
+    });
+}

package/patterns/for_Patterns/when_querying_through_the_connection/after_resetting_the_channel.spec.ts

@@ -0,0 +1,58 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { afterEach, beforeEach, chai, describe, it } from 'vitest';
+import { createServer, type ServiceImplementation } from 'nice-grpc';
+import { ConnectionServiceDefinition, PatternsDefinition, type UsualActionsRequest } from '@cratis/chronicle.contracts';
+import { EventStore } from '../../../EventStore.js';
+import { EventStoreName } from '../../../EventStoreName.js';
+import { EventStoreNamespaceName } from '../../../EventStoreNamespaceName.js';
+import { ChronicleConnection } from '../../../connection/index.js';
+import { ConnectionLifecycle } from '../../../connection/ConnectionLifecycle.js';
+import { DayOfWeek, TimeBucket, type BehaviorPattern } from '../../index.js';
+
+chai.should();
+
+describe('when querying patterns through an event store after resetting its connection', () => {
+    let server: ReturnType<typeof createServer>;
+    let connection: ChronicleConnection;
+    let eventStore: EventStore;
+    let request: UsualActionsRequest;
+    let apiKey: string | undefined;
+    let result: BehaviorPattern[];
+    beforeEach(async () => {
+        server = createServer();
+        const unused = async () => { throw new Error('Unexpected RPC'); };
+        server.add(ConnectionServiceDefinition, {
+            ...Object.fromEntries(Object.keys(ConnectionServiceDefinition.methods).map(name => [name, unused])),
+            checkCompatibility: async () => ({ IsCompatible: true, Incompatibilities: [], ServerVersion: 'test' })
+        } as ServiceImplementation<typeof ConnectionServiceDefinition>);
+        server.add(PatternsDefinition, {
+            allPatterns: unused, allPatternScopes: unused, matchingPatterns: unused, patternsForScope: unused,
+            usualActions: async (received, context) => {
+                request = received;
+                apiKey = context.metadata.get('api-key');
+                return { IsAuthorized: true, Data: [{ Id: 'pattern-1', Occurrences: 9_007_199_254_740_993n }] };
+            }
+        });
+        const port = await server.listen('127.0.0.1:0');
+        connection = new ChronicleConnection({ connectionString: `chronicle://127.0.0.1:${port}?disableTls=true&apiKey=patterns-test` });
+        await connection.connect();
+        eventStore = new EventStore(new EventStoreName('accounts'), new EventStoreNamespaceName('tenant-a'), connection, new ConnectionLifecycle(), 'sink');
+        await connection.resetChannel();
+        result = await eventStore.patterns.getPatternsAt('user-42', { instant: new Date('2026-01-05T00:30:00Z'), offsetMinutes: -240 });
+    });
+    afterEach(async () => {
+        eventStore?.disposeObservations();
+        connection?.dispose();
+        await server?.shutdown();
+    });
+    it('should send the offset-derived context to the generated usual actions service', () => {
+        request.should.deep.equal({
+            EventStore: 'accounts', Namespace: 'tenant-a', GroupingKey: 'user-42',
+            Context: { Day: DayOfWeek.Sunday, TimeBucket: TimeBucket.Evening }, MinimumConfidence: 0, MaximumResults: 0
+        });
+    });
+    it('should use the connection authentication middleware', () => apiKey!.should.equal('patterns-test'));
+    it('should preserve occurrence precision across the actual wire codec', () => result[0].occurrences.should.equal(9_007_199_254_740_993n));
+});

package/patterns/for_toDayOfWeek/when_reading_the_day/at_an_offset.spec.ts

@@ -0,0 +1,31 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { beforeEach, chai, describe, it } from 'vitest';
+import { DayOfWeek, toDayOfWeek } from '../../index.js';
+
+chai.should();
+
+const cases: [string, number, DayOfWeek][] = [
+    ['2026-01-04T23:59:59.999Z', 0, DayOfWeek.Sunday],
+    ['2026-01-05T00:00:00.000Z', 0, DayOfWeek.Monday],
+    ['2026-01-06T12:00:00Z', 0, DayOfWeek.Tuesday],
+    ['2026-01-07T12:00:00Z', 0, DayOfWeek.Wednesday],
+    ['2026-01-08T12:00:00Z', 0, DayOfWeek.Thursday],
+    ['2026-01-09T12:00:00Z', 0, DayOfWeek.Friday],
+    ['2026-01-10T12:00:00Z', 0, DayOfWeek.Saturday],
+    ['2026-01-04T23:30:00Z', 120, DayOfWeek.Monday],
+    ['2026-01-05T00:30:00Z', -120, DayOfWeek.Sunday],
+    ['2025-12-31T23:30:00Z', 345, DayOfWeek.Thursday],
+    ['2026-01-01T00:30:00Z', -210, DayOfWeek.Wednesday],
+    ['2026-01-04T12:00:00Z', 840, DayOfWeek.Monday],
+    ['2026-01-05T12:00:00Z', -840, DayOfWeek.Sunday]
+];
+
+for (const [instant, offsetMinutes, expected] of cases) {
+    describe(`when reading the day of ${instant} at offset ${offsetMinutes}`, () => {
+        let result: DayOfWeek;
+        beforeEach(() => result = toDayOfWeek({ instant: new Date(instant), offsetMinutes }));
+        it('should name the day at the moment offset rather than UTC', () => result.should.equal(expected));
+    });
+}

package/patterns/for_toTimeBucket/when_bucketing/at_boundaries.spec.ts

@@ -0,0 +1,39 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { beforeEach, chai, describe, it } from 'vitest';
+import { TimeBucket, toTimeBucket } from '../../index.js';
+
+chai.should();
+
+// Chronicle v19.26.2: TimeBucketExtensions.ToTimeBucket uses >= start and < end on the offset's hour.
+const boundaries: [string, TimeBucket][] = [
+    ['00:00:00.000', TimeBucket.Night],
+    ['04:59:59.999', TimeBucket.Night],
+    ['05:00:00.000', TimeBucket.EarlyMorning],
+    ['07:59:59.999', TimeBucket.EarlyMorning],
+    ['08:00:00.000', TimeBucket.Morning],
+    ['10:59:59.999', TimeBucket.Morning],
+    ['11:00:00.000', TimeBucket.Midday],
+    ['13:59:59.999', TimeBucket.Midday],
+    ['14:00:00.000', TimeBucket.Afternoon],
+    ['16:59:59.999', TimeBucket.Afternoon],
+    ['17:00:00.000', TimeBucket.Evening],
+    ['21:59:59.999', TimeBucket.Evening],
+    ['22:00:00.000', TimeBucket.Night],
+    ['23:59:59.999', TimeBucket.Night]
+];
+
+for (const offsetMinutes of [0, 330, -210, 345, -840, 840]) {
+    for (const [time, expected] of boundaries) {
+        describe(`when bucketing ${time} at offset ${offsetMinutes}`, () => {
+            let result: TimeBucket;
+            beforeEach(() => {
+                const wallClock = new Date(`2026-01-05T${time}Z`);
+                const instant = new Date(wallClock.getTime() - offsetMinutes * 60_000);
+                result = toTimeBucket({ instant, offsetMinutes });
+            });
+            it('should use the same inclusive and exclusive boundaries as the miner', () => result.should.equal(expected));
+        });
+    }
+}

package/patterns/index.ts

@@ -0,0 +1,15 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+export type { BehaviorPattern } from './BehaviorPattern.js';
+export { DayOfWeek } from './DayOfWeek.js';
+export { FacetName } from './FacetName.js';
+export type { FacetSet } from './FacetSet.js';
+export type { IPatterns } from './IPatterns.js';
+export type { PatternMoment } from './PatternMoment.js';
+export type { PatternQueryOptions } from './PatternQueryOptions.js';
+export { Patterns } from './Patterns.js';
+export type { PatternsAtOptions } from './PatternsAtOptions.js';
+export { TimeBucket } from './TimeBucket.js';
+export { toDayOfWeek } from './toDayOfWeek.js';
+export { toTimeBucket } from './toTimeBucket.js';

package/patterns/toBehaviorPattern.ts

@@ -0,0 +1,25 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import type { BehaviorPatternDetailsResponse } from '@cratis/chronicle.contracts';
+import type { BehaviorPattern } from './BehaviorPattern.js';
+
+/**
+ * Converts the wire representation without losing 64-bit occurrence counts or inventing missing timestamps.
+ * @param pattern - The pattern returned by the kernel.
+ * @returns The client representation.
+ */
+export function toBehaviorPattern(pattern: BehaviorPatternDetailsResponse): BehaviorPattern {
+    return {
+        id: pattern.Id,
+        groupingKey: pattern.GroupingKey,
+        facets: { ...pattern.Facets },
+        confidence: pattern.Confidence,
+        support: pattern.Support,
+        occurrences: pattern.Occurrences,
+        weight: pattern.Weight,
+        specificity: pattern.Specificity,
+        firstSeen: pattern.FirstSeen ? new Date(pattern.FirstSeen.Value) : undefined,
+        lastSeen: pattern.LastSeen ? new Date(pattern.LastSeen.Value) : undefined
+    };
+}

package/patterns/toDayOfWeek.ts

@@ -0,0 +1,19 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { DayOfWeek } from './DayOfWeek.js';
+import type { PatternMoment } from './PatternMoment.js';
+import { toOffsetDate } from './toOffsetDate.js';
+
+const days = [DayOfWeek.Sunday, DayOfWeek.Monday, DayOfWeek.Tuesday, DayOfWeek.Wednesday,
+    DayOfWeek.Thursday, DayOfWeek.Friday, DayOfWeek.Saturday];
+
+/**
+ * Reads the day at a moment's own offset, using Chronicle's English day names.
+ * @param moment - The instant and the offset it occurred at.
+ * @returns The day of week used by the Day facet.
+ * @throws {RangeError} If the date or offset is invalid.
+ */
+export function toDayOfWeek(moment: PatternMoment): DayOfWeek {
+    return days[toOffsetDate(moment).getUTCDay()];
+}

package/patterns/toOffsetDate.ts

@@ -0,0 +1,22 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import type { PatternMoment } from './PatternMoment.js';
+
+/**
+ * Produces a date whose UTC fields represent the moment's wall-clock fields.
+ * Internal only: the shifted value must never be used as an actual instant.
+ * @param moment - An instant and its explicit offset.
+ * @returns The shifted date for reading UTC calendar fields.
+ */
+export function toOffsetDate(moment: PatternMoment): Date {
+    if (!Number.isInteger(moment.offsetMinutes) || Math.abs(moment.offsetMinutes) > 14 * 60) {
+        throw new RangeError('The moment offset must be a whole number of minutes between -840 and 840.');
+    }
+    const milliseconds = moment.instant.getTime();
+    const shifted = new Date(milliseconds + moment.offsetMinutes * 60_000);
+    if (!Number.isFinite(milliseconds) || !Number.isFinite(shifted.getTime())) {
+        throw new RangeError('The moment must represent a valid date at its offset.');
+    }
+    return shifted;
+}

package/patterns/toTimeBucket.ts

@@ -0,0 +1,22 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import type { PatternMoment } from './PatternMoment.js';
+import { TimeBucket } from './TimeBucket.js';
+import { toOffsetDate } from './toOffsetDate.js';
+
+/**
+ * Buckets a moment using its own offset, matching DateTimeOffset.ToTimeBucket() in Chronicle.
+ * @param moment - The instant and the offset it occurred at, not the machine's offset.
+ * @returns The time bucket, with inclusive starts and exclusive ends.
+ * @throws {RangeError} If the date or offset is invalid.
+ */
+export function toTimeBucket(moment: PatternMoment): TimeBucket {
+    const hour = toOffsetDate(moment).getUTCHours();
+    if (hour >= 5 && hour < 8) return TimeBucket.EarlyMorning;
+    if (hour >= 8 && hour < 11) return TimeBucket.Morning;
+    if (hour >= 11 && hour < 14) return TimeBucket.Midday;
+    if (hour >= 14 && hour < 17) return TimeBucket.Afternoon;
+    if (hour >= 17 && hour < 22) return TimeBucket.Evening;
+    return TimeBucket.Night;
+}

package/testing/ReactorScenario.spec.ts

@@ -187,6 +187,19 @@ describe('ReactorScenario live delivery', () => {
         scenario.results[0].completed.should.be.false;
     });
 
+    it('rejects behavior pattern queries through the default event store', async () => {
+        let error: unknown;
+        @reactor('pattern-rejection-reactor')
+        class PatternRejection {
+            registered(_event: Registered, _context: EventContext, services: ReactorServices) {
+                try { void services.eventStore.patterns; } catch (caught) { error = caught; }
+            }
+        }
+        const scenario = new ReactorScenario(PatternRejection, options);
+        await scenario.when.forEventSource('A').events(new Registered('first')).catch(() => undefined);
+        (error instanceof UnsupportedReactorOperation && String(error).includes('services.eventStore.patterns')).should.be.true;
+    });
+
     it('stops a multi-event delivery at the event whose handler swallowed an unsupported call', async () => {
         const invoked: string[] = [];
         @reactor('swallowed-in-batch-reactor')

package/testing/ReactorScenario.ts

@@ -131,7 +131,7 @@ export class ReactorScenario {
             namespace: new EventStoreNamespaceName(this._options.namespace ?? 'default'), eventLog: guardedLog, readModels };
         const unsupportedStoreProperties = new Set(['eventTypes', 'constraints', 'projections', 'reactors', 'reducers',
             'unitOfWorkManager', 'jobs', 'webhooks', 'subscriptions', 'seeding', 'externalServices', 'identities',
-            'pii', 'failedPartitions', 'observers']);
+            'pii', 'failedPartitions', 'observers', 'patterns']);
         return new Proxy(store, { get: (target, key) => {
             if (typeof key !== 'string') return undefined;
             if (Object.hasOwn(target, key)) return target[key as keyof typeof target];