@cratis/scene.engine 3.7.0 → 4.1.0

package/for_resolveBehaviors/when_resolving_additive_attachments.ts

@@ -0,0 +1,100 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { Behavior, InteractionActionKind, InteractionTriggerKind } from '@cratis/scene.model';
+import { BehaviorAttachment, resolveApplicationTriggerBehaviors, resolveBehaviors } from '../resolveBehaviors';
+
+const behavior = (name: string | undefined, kind: InteractionTriggerKind, order?: number): Behavior => ({
+    name,
+    order,
+    bindings: [
+        {
+            trigger: { kind } as never,
+            actions: [{ kind: InteractionActionKind.RefreshQuery, query: name ?? 'inline' } as never],
+        },
+    ],
+});
+
+describe('when resolving additive attachments', () => {
+    const attachments: BehaviorAttachment[] = [
+        { level: 'layout', behaviors: [behavior('LayoutWide', InteractionTriggerKind.Click)] },
+        { level: 'module', behaviors: [behavior('ModuleWide', InteractionTriggerKind.Click)] },
+        { level: 'element', behaviors: [behavior(undefined, InteractionTriggerKind.Click)] },
+    ];
+
+    // The point of the additive rule: a module saying 'confirm every destructive action' does not need every
+    // screen beneath it to cooperate, and an element attaching its own does not silently cancel it.
+    it('should run every matching attachment rather than only the most specific', () => {
+        const resolved = resolveBehaviors(attachments, InteractionTriggerKind.Click);
+
+        resolved.should.have.lengthOf(3);
+    });
+
+    it('should run the outermost attachment first', () => {
+        const resolved = resolveBehaviors(attachments, InteractionTriggerKind.Click);
+
+        resolved.map(candidate => candidate.level).should.eql(['layout', 'module', 'element']);
+    });
+
+    it('should keep an inline behavior anonymous', () => {
+        const resolved = resolveBehaviors(attachments, InteractionTriggerKind.Click);
+
+        (resolved[2].behaviorName === undefined).should.be.true;
+    });
+
+    it('should ignore bindings for a different trigger', () => {
+        const resolved = resolveBehaviors(
+            [{ level: 'element', behaviors: [behavior('OnSubmitOnly', InteractionTriggerKind.Submit)] }],
+            InteractionTriggerKind.Click
+        );
+
+        resolved.should.be.empty;
+    });
+
+    it('should let an explicit order win over position', () => {
+        const resolved = resolveBehaviors(
+            [
+                { level: 'layout', behaviors: [behavior('LayoutWide', InteractionTriggerKind.Click)] },
+                { level: 'element', behaviors: [behavior('RunsFirst', InteractionTriggerKind.Click, 1)] },
+            ],
+            InteractionTriggerKind.Click
+        );
+
+        resolved.map(candidate => candidate.behaviorName).should.eql(['RunsFirst', 'LayoutWide']);
+    });
+
+    // Determinism is the reason this is a pure function over an ordered list: the same document has to produce
+    // the same order on every run, or an interaction becomes intermittently wrong rather than wrong.
+    it('should order deterministically across repeated resolutions', () => {
+        const once = resolveBehaviors(attachments, InteractionTriggerKind.Click).map(c => c.level);
+        const twice = resolveBehaviors(attachments, InteractionTriggerKind.Click).map(c => c.level);
+
+        once.should.eql(twice);
+    });
+
+    it('should resolve a named application trigger separately from the built-in kinds', () => {
+        const resolved = resolveApplicationTriggerBehaviors(
+            [
+                {
+                    level: 'screen',
+                    behaviors: [
+                        {
+                            name: undefined,
+                            bindings: [
+                                { trigger: { triggerName: 'InvoiceImported' } as never, actions: [] },
+                                { trigger: { triggerName: 'SomethingElse' } as never, actions: [] },
+                            ],
+                        },
+                    ],
+                },
+            ],
+            'InvoiceImported'
+        );
+
+        resolved.should.have.lengthOf(1);
+    });
+
+    it('should tolerate an attachment with no behaviors at all', () => {
+        resolveBehaviors([{ level: 'element', behaviors: [] }], InteractionTriggerKind.Click).should.be.empty;
+    });
+});

package/for_runActions/given/a_recording_dispatcher.ts

@@ -0,0 +1,72 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { BindingExpression, NotificationLevel } from '@cratis/scene.model';
+import { ActionDispatcher, CommandOutcome, DialogOutcome } from '../../ActionDispatcher';
+import { InteractionContext } from '../../runActions';
+
+/**
+ * A dispatcher that records what it was asked to do instead of doing it.
+ *
+ * The whole point of the engine owning the sequencing is that this is possible: no DOM, no React, no transport -
+ * the rules are assertable as a list of calls.
+ */
+export class RecordingDispatcher implements ActionDispatcher {
+    readonly calls: string[] = [];
+
+    commandSucceeds = true;
+    dialogConfirmed = true;
+    confirmAnswer = true;
+
+    async executeCommand(command: string, args: Record<string, unknown>): Promise<CommandOutcome> {
+        this.calls.push(`executeCommand:${command}:${JSON.stringify(args)}`);
+        return this.commandSucceeds
+            ? { isSuccess: true }
+            : { isSuccess: false, validationErrors: [{ member: 'amount', message: 'Must be positive' }] };
+    }
+
+    navigate(screen: string): void {
+        this.calls.push(`navigate:${screen}`);
+    }
+
+    navigateBack(): void {
+        this.calls.push('navigateBack');
+    }
+
+    async openDialog(dialogTemplate: string, args: Record<string, unknown>): Promise<DialogOutcome> {
+        this.calls.push(`openDialog:${dialogTemplate}:${JSON.stringify(args)}`);
+        return { isConfirmed: this.dialogConfirmed, result: 'the-result' };
+    }
+
+    closeDialog(): void {
+        this.calls.push('closeDialog');
+    }
+
+    async refreshQuery(query: string): Promise<void> {
+        this.calls.push(`refreshQuery:${query}`);
+    }
+
+    setState(target: string, value: unknown): void {
+        this.calls.push(`setState:${target}:${String(value)}`);
+    }
+
+    notify(level: NotificationLevel, message: string): void {
+        this.calls.push(`notify:${level}:${message}`);
+    }
+
+    async confirm(message: string): Promise<boolean> {
+        this.calls.push(`confirm:${message}`);
+        return this.confirmAnswer;
+    }
+
+    async raise(trigger: string): Promise<void> {
+        this.calls.push(`raise:${trigger}`);
+    }
+}
+
+/**
+ * A context that resolves a binding to its path, so an assertion can see which binding was used.
+ */
+export const pathEchoingContext: InteractionContext = {
+    resolve: (binding: BindingExpression) => `<${binding.path}>`,
+};

package/for_runActions/when_running_a_sequence_of_actions.ts

@@ -0,0 +1,226 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { InteractionAction, InteractionActionKind, NotificationLevel } from '@cratis/scene.model';
+import { InteractionStop, runActions } from '../runActions';
+import { pathEchoingContext, RecordingDispatcher } from './given/a_recording_dispatcher';
+
+const action = (kind: InteractionActionKind, extra: Record<string, unknown> = {}): InteractionAction =>
+    ({ kind, ...extra }) as InteractionAction;
+
+describe('when running a sequence of actions', () => {
+    it('should run them in the order they were declared', async () => {
+        const dispatcher = new RecordingDispatcher();
+
+        await runActions(
+            [
+                action(InteractionActionKind.RefreshQuery, { query: 'Invoices' }),
+                action(InteractionActionKind.Notify, { level: NotificationLevel.Info, message: { text: 'Done' } }),
+            ],
+            dispatcher,
+            pathEchoingContext
+        );
+
+        dispatcher.calls.should.eql(['refreshQuery:Invoices', 'notify:Info:Done']);
+    });
+
+    it('should resolve an action\'s arguments through the binding resolver', async () => {
+        const dispatcher = new RecordingDispatcher();
+
+        await runActions(
+            [
+                action(InteractionActionKind.ExecuteCommand, {
+                    command: 'CancelInvoice',
+                    arguments: [{ name: 'invoiceId', value: { path: 'item.invoiceId' } }],
+                }),
+            ],
+            dispatcher,
+            pathEchoingContext
+        );
+
+        dispatcher.calls.should.eql(['executeCommand:CancelInvoice:{"invoiceId":"<item.invoiceId>"}']);
+    });
+
+    it('should take the success branch when a command succeeds', async () => {
+        const dispatcher = new RecordingDispatcher();
+
+        const run = await runActions(
+            [
+                action(InteractionActionKind.ExecuteCommand, {
+                    command: 'RegisterInvoice',
+                    onSuccess: [action(InteractionActionKind.CloseDialog)],
+                    onFailure: [action(InteractionActionKind.Notify, { level: NotificationLevel.Error, message: { text: 'Failed' } })],
+                }),
+            ],
+            dispatcher,
+            pathEchoingContext
+        );
+
+        dispatcher.calls.should.eql(['executeCommand:RegisterInvoice:{}', 'closeDialog']);
+        run.stop.should.equal(InteractionStop.Completed);
+    });
+
+    it('should take the failure branch when a command fails', async () => {
+        const dispatcher = new RecordingDispatcher();
+        dispatcher.commandSucceeds = false;
+
+        await runActions(
+            [
+                action(InteractionActionKind.ExecuteCommand, {
+                    command: 'RegisterInvoice',
+                    onSuccess: [action(InteractionActionKind.CloseDialog)],
+                    onFailure: [action(InteractionActionKind.Notify, { level: NotificationLevel.Error, message: { text: 'Failed' } })],
+                }),
+            ],
+            dispatcher,
+            pathEchoingContext
+        );
+
+        dispatcher.calls.should.eql(['executeCommand:RegisterInvoice:{}', 'notify:Error:Failed']);
+    });
+
+    // A confirm exists to gate what follows it. If a decline let the rest run, the gate would be decorative.
+    it('should stop the sequence when a confirm is declined', async () => {
+        const dispatcher = new RecordingDispatcher();
+        dispatcher.confirmAnswer = false;
+
+        const run = await runActions(
+            [
+                action(InteractionActionKind.Confirm, {
+                    message: { text: 'Are you sure?' },
+                    onSuccess: [action(InteractionActionKind.ExecuteCommand, { command: 'CancelInvoice' })],
+                }),
+                action(InteractionActionKind.Notify, { level: NotificationLevel.Info, message: { text: 'Cancelled' } }),
+            ],
+            dispatcher,
+            pathEchoingContext
+        );
+
+        dispatcher.calls.should.eql(['confirm:Are you sure?']);
+        run.stop.should.equal(InteractionStop.Declined);
+    });
+
+    it('should run the gated actions when a confirm is accepted', async () => {
+        const dispatcher = new RecordingDispatcher();
+
+        await runActions(
+            [
+                action(InteractionActionKind.Confirm, {
+                    message: { text: 'Are you sure?' },
+                    onSuccess: [action(InteractionActionKind.ExecuteCommand, { command: 'CancelInvoice' })],
+                }),
+            ],
+            dispatcher,
+            pathEchoingContext
+        );
+
+        dispatcher.calls.should.eql(['confirm:Are you sure?', 'executeCommand:CancelInvoice:{}']);
+    });
+
+    // The screen the remaining actions were written for is gone. The compiler reports this as unreachable, so
+    // reaching it at runtime means the document changed underneath - still not a reason to run them.
+    it('should stop the sequence after a navigation', async () => {
+        const dispatcher = new RecordingDispatcher();
+
+        const run = await runActions(
+            [
+                action(InteractionActionKind.Navigate, { screen: 'InvoiceList' }),
+                action(InteractionActionKind.Notify, { level: NotificationLevel.Info, message: { text: 'Never runs' } }),
+            ],
+            dispatcher,
+            pathEchoingContext
+        );
+
+        dispatcher.calls.should.eql(['navigate:InvoiceList']);
+        run.stop.should.equal(InteractionStop.Navigated);
+    });
+
+    it('should stop the sequence after navigating back', async () => {
+        const dispatcher = new RecordingDispatcher();
+
+        const run = await runActions(
+            [action(InteractionActionKind.NavigateBack), action(InteractionActionKind.CloseDialog)],
+            dispatcher,
+            pathEchoingContext
+        );
+
+        dispatcher.calls.should.eql(['navigateBack']);
+        run.stop.should.equal(InteractionStop.Navigated);
+    });
+
+    it('should run a dialog\'s result continuation after it closes', async () => {
+        const dispatcher = new RecordingDispatcher();
+
+        await runActions(
+            [
+                action(InteractionActionKind.OpenDialog, {
+                    dialogTemplate: 'InvoiceDetails',
+                    arguments: [{ name: 'invoiceId', value: { path: 'item.invoiceId' } }],
+                    onResult: [action(InteractionActionKind.RefreshQuery, { query: 'Invoices' })],
+                }),
+            ],
+            dispatcher,
+            pathEchoingContext
+        );
+
+        dispatcher.calls.should.eql([
+            'openDialog:InvoiceDetails:{"invoiceId":"<item.invoiceId>"}',
+            'refreshQuery:Invoices',
+        ]);
+    });
+
+    it('should resolve a message from a binding when it has one', async () => {
+        const dispatcher = new RecordingDispatcher();
+
+        await runActions(
+            [action(InteractionActionKind.Notify, { level: NotificationLevel.Info, message: { binding: { path: 'state.message' } } })],
+            dispatcher,
+            pathEchoingContext
+        );
+
+        dispatcher.calls.should.eql(['notify:Info:<state.message>']);
+    });
+
+    it('should localize a message given a strings key', async () => {
+        const dispatcher = new RecordingDispatcher();
+
+        await runActions(
+            [action(InteractionActionKind.Notify, { level: NotificationLevel.Info, message: { stringsKey: 'invoiceRegistered' } })],
+            dispatcher,
+            { resolve: () => undefined, localize: key => `localized(${key})` }
+        );
+
+        dispatcher.calls.should.eql(['notify:Info:localized(invoiceRegistered)']);
+    });
+
+    // Fail closed and visible: an action kind this engine does not know is reported, and the rest of the
+    // sequence is abandoned rather than half-applied silently.
+    it('should report an action kind it does not know instead of ignoring it', async () => {
+        const dispatcher = new RecordingDispatcher();
+
+        const run = await runActions(
+            [action('SomethingFromALaterVersion' as InteractionActionKind)],
+            dispatcher,
+            pathEchoingContext
+        );
+
+        dispatcher.calls.should.be.empty;
+        run.stop.should.equal(InteractionStop.Reported);
+        run.findings.should.have.lengthOf(1);
+        run.findings[0].kind.should.equal('unknownAction');
+        run.findings[0].detail.should.contain('SomethingFromALaterVersion');
+    });
+
+    it('should report a message binding that resolved to nothing', async () => {
+        const dispatcher = new RecordingDispatcher();
+
+        const run = await runActions(
+            [action(InteractionActionKind.Confirm, { message: { binding: { path: 'state.missing' } } })],
+            dispatcher,
+            { resolve: () => undefined }
+        );
+
+        run.findings[0].kind.should.equal('unresolvedMessage');
+        run.findings[0].detail.should.contain('state.missing');
+    });
+});

package/for_runActions/when_running_against_the_shared_fixture_corpus.ts

@@ -0,0 +1,124 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { InteractionAction, InteractionActionKind, InteractionTriggerKind, NotificationLevel } from '@cratis/scene.model';
+import { BehaviorAttachment, resolveBehaviors } from '../resolveBehaviors';
+import { InteractionStop, runActions } from '../runActions';
+import { pathEchoingContext, RecordingDispatcher } from './given/a_recording_dispatcher';
+
+interface FixtureBehavior {
+    name: string | null;
+    trigger: keyof typeof InteractionTriggerKind;
+    order?: number;
+}
+
+interface FixtureAttachment {
+    level: string;
+    depth?: number;
+    behaviors: FixtureBehavior[];
+}
+
+interface ResolutionCase {
+    name: string;
+    trigger: keyof typeof InteractionTriggerKind;
+    attachments: FixtureAttachment[];
+    expected: (string | null)[];
+}
+
+interface FixtureAction {
+    kind: string;
+    command?: string;
+    query?: string;
+    screen?: string;
+    dialogTemplate?: string;
+    level?: keyof typeof NotificationLevel;
+    text?: string;
+    onSuccess?: FixtureAction[];
+    onFailure?: FixtureAction[];
+    onResult?: FixtureAction[];
+}
+
+interface SequencingCase {
+    name: string;
+    actions: FixtureAction[];
+    commandSucceeds: boolean;
+    confirmAnswer: boolean;
+    expectedCalls: string[];
+    expectedStop: keyof typeof InteractionStop;
+    expectedFindings?: string[];
+}
+
+interface FixtureCorpus {
+    resolutionCases: ResolutionCase[];
+    sequencingCases: SequencingCase[];
+}
+
+const manifestPath = join(import.meta.dirname, '..', '..', '..', '..', 'interaction-fixtures.json');
+const corpus = JSON.parse(readFileSync(manifestPath, 'utf-8')) as FixtureCorpus;
+
+function attachment(fixture: FixtureAttachment): BehaviorAttachment {
+    return {
+        level: fixture.level,
+        depth: fixture.depth,
+        behaviors: fixture.behaviors.map(behavior => ({
+            name: behavior.name ?? undefined,
+            order: behavior.order,
+            bindings: [
+                {
+                    trigger: { kind: InteractionTriggerKind[behavior.trigger] } as never,
+                    actions: [],
+                },
+            ],
+        })),
+    };
+}
+
+function action(fixture: FixtureAction): InteractionAction {
+    return {
+        kind: InteractionActionKind[fixture.kind as keyof typeof InteractionActionKind] ?? fixture.kind,
+        command: fixture.command,
+        query: fixture.query,
+        screen: fixture.screen,
+        dialogTemplate: fixture.dialogTemplate,
+        level: fixture.level === undefined ? undefined : NotificationLevel[fixture.level],
+        message: fixture.text === undefined ? undefined : { text: fixture.text },
+        onSuccess: (fixture.onSuccess ?? []).map(action),
+        onFailure: (fixture.onFailure ?? []).map(action),
+        onResult: (fixture.onResult ?? []).map(action),
+    } as InteractionAction;
+}
+
+// The dispatcher records the command name without its arguments, because the corpus pins the sequencing rule
+// and not how a binding resolves - that is asserted by the unit specs next to this file.
+function callsWithoutArguments(calls: string[]): string[] {
+    return calls.map(call => call.replace(/:\{.*\}$/, ''));
+}
+
+describe('when running against the shared fixture corpus', () => {
+    for (const fixture of corpus.resolutionCases) {
+        it(`should resolve the case where ${fixture.name}`, () => {
+            const resolved = resolveBehaviors(
+                fixture.attachments.map(attachment),
+                InteractionTriggerKind[fixture.trigger]
+            );
+
+            resolved.map(candidate => candidate.behaviorName ?? null).should.eql(fixture.expected);
+        });
+    }
+
+    for (const fixture of corpus.sequencingCases) {
+        it(`should sequence the case where ${fixture.name}`, async () => {
+            const dispatcher = new RecordingDispatcher();
+            dispatcher.commandSucceeds = fixture.commandSucceeds;
+            dispatcher.confirmAnswer = fixture.confirmAnswer;
+
+            const run = await runActions(fixture.actions.map(action), dispatcher, pathEchoingContext);
+
+            callsWithoutArguments(dispatcher.calls).should.eql(fixture.expectedCalls);
+            run.stop.should.equal(InteractionStop[fixture.expectedStop]);
+            run.findings.map(finding => finding.kind).should.eql(fixture.expectedFindings ?? []);
+        });
+    }
+});

package/index.ts

@@ -22,3 +22,6 @@ export * from './packageCatalog';
 export * from './resolveScreenTemplates';
 export * from './buildStarterProfile';
 export * from './incompatibleStarterThemes';
+export * from './ActionDispatcher';
+export * from './runActions';
+export * from './resolveBehaviors';

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cratis/scene.engine",
-    "version": "3.7.0",
+    "version": "4.1.0",
     "description": "The Scene runtime: walks a Scene element tree and drives whichever renderer is plugged in. Does not know React, or any other rendering platform, exists.",
     "keywords": [
         "cratis",
@@ -47,9 +47,9 @@
         "up": "yarn g:up"
     },
     "dependencies": {
-        "@cratis/scene.model": "3.7.0"
+        "@cratis/scene.model": "4.1.0"
     },
     "devDependencies": {
-        "@cratis/scene.model": "3.7.0"
+        "@cratis/scene.model": "4.1.0"
     }
 }

package/resolveBehaviors.ts

@@ -0,0 +1,137 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { Behavior, InteractionBinding, InteractionTrigger, InteractionTriggerKind } from '@cratis/scene.model';
+
+/**
+ * One level of the containment tree a behavior can be attached to, outermost first.
+ *
+ * Named rather than positional so a finding can say *where* a behavior came from - 'the module's behavior ran
+ * before the element's' is only a useful thing to report if the level has a name.
+ */
+export interface BehaviorAttachment {
+    level: string;
+    behaviors: Behavior[];
+
+    /**
+     * How deeply nested this attachment is, with 0 the outermost.
+     *
+     * Optional, defaulting to the position in the list. Stating it explicitly is what lets a caller assemble the
+     * list in whatever order is convenient - walking a tree upwards from the element, for instance - without the
+     * resolved order silently depending on that choice.
+     */
+    depth?: number;
+}
+
+/**
+ * One binding to run, with the attachment it came from.
+ */
+export interface ResolvedBinding {
+    level: string;
+    behaviorName?: string;
+    binding: InteractionBinding;
+}
+
+/**
+ * Whether the trigger is the built-in kind asked for.
+ */
+function isKind(trigger: InteractionTrigger, kind: InteractionTriggerKind): boolean {
+    return (trigger as { kind?: InteractionTriggerKind }).kind === kind;
+}
+
+/**
+ * Collects the bindings that respond to a built-in interaction kind, in the order they run.
+ *
+ * Attachments are **additive**: a behavior on a template and a behavior on an element both run, rather than the
+ * more specific one replacing the less specific one. The order is outermost attachment first, declaration order
+ * within a level, and any behavior that declares an `order` sorts by it.
+ *
+ * The additive rule is what lets a module say 'confirm every destructive action' without every screen beneath it
+ * having to cooperate - but it also means the order has to be deterministic, or the same document behaves
+ * differently between runs. That is why this is a pure function over an ordered list rather than something
+ * assembled while rendering.
+ *
+ * @param attachments The attachment levels, outermost first.
+ * @param kind The built-in interaction kind that occurred.
+ * @returns The bindings to run, in order.
+ */
+export function resolveBehaviors(attachments: BehaviorAttachment[], kind: InteractionTriggerKind): ResolvedBinding[] {
+    const resolved: { entry: ResolvedBinding; level: number; declaration: number; order?: number }[] = [];
+
+    attachments.forEach((attachment, level) => {
+        let declaration = 0;
+        for (const behavior of (attachment.behaviors ?? [])) {
+            for (const binding of (behavior.bindings ?? [])) {
+                if (!isKind(binding.trigger, kind)) continue;
+
+                resolved.push({
+                    entry: { level: attachment.level, behaviorName: behavior.name, binding },
+                    level: attachment.depth ?? level,
+                    declaration: declaration++,
+                    order: behavior.order,
+                });
+            }
+        }
+    });
+
+    // An explicit order wins over position; everything else keeps the order it was written in. Sorting is
+    // stable on (order, level, declaration) so the result never depends on the sort implementation.
+    return resolved
+        .sort((left, right) => {
+            if (left.order !== right.order) {
+                if (left.order === undefined) return 1;
+                if (right.order === undefined) return -1;
+                return left.order - right.order;
+            }
+
+            return left.level !== right.level ? left.level - right.level : left.declaration - right.declaration;
+        })
+        .map(candidate => candidate.entry);
+}
+
+/**
+ * Collects the bindings that respond to a named application trigger firing.
+ *
+ * @param attachments The attachment levels, outermost first.
+ * @param triggerName The application trigger that fired.
+ * @returns The bindings to run, in order.
+ */
+export function resolveApplicationTriggerBehaviors(attachments: BehaviorAttachment[], triggerName: string): ResolvedBinding[] {
+    return collect(attachments, trigger => (trigger as { triggerName?: string }).triggerName === triggerName);
+}
+
+/**
+ * Collects the bindings that respond to a modeled domain event being observed.
+ *
+ * @param attachments The attachment levels, outermost first.
+ * @param eventName The event that was observed.
+ * @returns The bindings to run, in order.
+ */
+export function resolveEventBehaviors(attachments: BehaviorAttachment[], eventName: string): ResolvedBinding[] {
+    return collect(attachments, trigger => (trigger as { eventName?: string }).eventName === eventName);
+}
+
+/**
+ * Collects every interval binding, so a host can schedule them.
+ *
+ * @param attachments The attachment levels, outermost first.
+ * @returns The interval bindings, in order.
+ */
+export function resolveIntervalBehaviors(attachments: BehaviorAttachment[]): ResolvedBinding[] {
+    return collect(attachments, trigger => typeof (trigger as { seconds?: number }).seconds === 'number');
+}
+
+function collect(attachments: BehaviorAttachment[], matches: (trigger: InteractionTrigger) => boolean): ResolvedBinding[] {
+    const resolved: ResolvedBinding[] = [];
+    for (const attachment of attachments) {
+        for (const behavior of (attachment.behaviors ?? [])) {
+            for (const binding of (behavior.bindings ?? [])) {
+                if (matches(binding.trigger)) {
+                    resolved.push({ level: attachment.level, behaviorName: behavior.name, binding });
+                }
+            }
+        }
+    }
+
+    return resolved;
+}