@classytic/arc-testkit 0.4.0 → 0.6.0

package/dist/index.d.mts

@@ -1,10 +1,8 @@
 import { BootModuleAppOptions as BootModuleAppOptions$1, BootModulesInput, ModuleTestApp as ModuleTestApp$1, TestkitContext as TestkitContext$1 } from "@classytic/arc/testing";
 import { Connection } from "mongoose";
-//#region src/index.d.ts
 type TestkitContext = TestkitContext$1<Connection>;
 type ModulesInput = BootModulesInput<Connection>;
 type BootModuleAppOptions = BootModuleAppOptions$1<Connection>;
 type ModuleTestApp = ModuleTestApp$1<Connection>;
 declare function bootModuleApp(modules: ModulesInput, options?: BootModuleAppOptions): Promise<ModuleTestApp>;
-//#endregion
 export { BootModuleAppOptions, ModuleTestApp, ModulesInput, TestkitContext, bootModuleApp };

package/dist/index.mjs

@@ -1,5 +1,5 @@
 import { bootModuleApp as bootModuleApp$1 } from "@classytic/arc/testing";
-//#region src/index.ts
+// src/index.ts
 /**
 * @classytic/arc-testkit — boots a REAL arc app around the module(s) under
 * test on in-memory MongoDB. The contributor contract: if your module boots
@@ -23,5 +23,4 @@ import { bootModuleApp as bootModuleApp$1 } from "@classytic/arc/testing";
 function bootModuleApp(modules, options = {}) {
 	return bootModuleApp$1(modules, options);
 }
-//#endregion
 export { bootModuleApp };

package/dist/mongo-commands.d.mts

@@ -0,0 +1,27 @@
+import { Connection } from "mongoose";
+type MongoClientLike = ReturnType<Connection["getClient"]>;
+interface CountCommandsOptions {
+  /** Count only commands against these collections. */
+  readonly collections?: readonly string[];
+  /** Count only these command names (`find`, `aggregate`, `insert`, …). */
+  readonly commands?: readonly string[];
+  /** Never count these command names — e.g. `createIndexes` a model may run lazily. */
+  readonly ignore?: readonly string[];
+}
+interface WireCommand {
+  readonly command: string;
+  /** The collection the command targets; `undefined` for session, transaction and admin commands. */
+  readonly collection: string | undefined;
+}
+interface CommandCount<T> {
+  readonly result: T;
+  readonly total: number;
+  /** Counted commands, in the order the driver sent them. */
+  readonly commands: readonly WireCommand[];
+  /** Counts keyed by collection (`(none)` for commands without one). */
+  readonly byCollection: Readonly<Record<string, number>>;
+  readonly byCommand: Readonly<Record<string, number>>;
+}
+declare function countCommands<T>(source: Connection | MongoClientLike, fn: () => Promise<T>, options?: CountCommandsOptions): Promise<CommandCount<T>>;
+declare function assertConstantCommands<T>(source: Connection | MongoClientLike, run: (size: number) => Promise<T>, sizes: readonly number[], options?: CountCommandsOptions): Promise<readonly CommandCount<T>[]>;
+export { CommandCount, CountCommandsOptions, WireCommand, assertConstantCommands, countCommands };

package/dist/mongo-commands.mjs

@@ -0,0 +1,53 @@
+// src/mongo-commands.ts
+async function countCommands(source, fn, options = {}) {
+	const client = "getClient" in source ? source.getClient() : source;
+	if (client.options.monitorCommands !== true) throw new Error("[arc-testkit] countCommands: the client was created without `monitorCommands: true` — the driver emits no command events, so every count would read 0");
+	const commands = [];
+	const onStarted = (e) => {
+		const collection = collectionOf(e.commandName, e.command);
+		if (options.ignore?.includes(e.commandName)) return;
+		if (options.commands && !options.commands.includes(e.commandName)) return;
+		if (options.collections && (collection === void 0 || !options.collections.includes(collection))) return;
+		commands.push({
+			command: e.commandName,
+			collection
+		});
+	};
+	client.on("commandStarted", onStarted);
+	let result;
+	try {
+		result = await fn();
+	} finally {
+		client.off("commandStarted", onStarted);
+	}
+	return {
+		result,
+		total: commands.length,
+		commands,
+		byCollection: tally(commands.map((c) => c.collection ?? "(none)")),
+		byCommand: tally(commands.map((c) => c.command))
+	};
+}
+async function assertConstantCommands(source, run, sizes, options = {}) {
+	if (new Set(sizes).size < 2) throw new Error("[arc-testkit] assertConstantCommands: needs at least two distinct sizes");
+	const counts = [];
+	for (const size of sizes) counts.push(await countCommands(source, () => run(size), options));
+	const shape = (c) => c.commands.map((w) => `${w.collection ?? "(none)"}.${w.command}`).join(", ");
+	const [first] = counts;
+	if (!first || first.total === 0) throw new Error(`[arc-testkit] assertConstantCommands: size ${sizes[0]} sent no counted command — the measurement saw nothing`);
+	if (counts.some((c) => shape(c) !== shape(first))) {
+		const lines = counts.map((c, i) => `  at ${sizes[i]}: ${c.total} [${shape(c)}]`).join("\n");
+		throw new Error(`[arc-testkit] assertConstantCommands: the commands grow with the size\n${lines}`);
+	}
+	return counts;
+}
+function collectionOf(name, command) {
+	const target = name === "getMore" ? command.collection : command[name];
+	return typeof target === "string" ? target : void 0;
+}
+function tally(keys) {
+	const out = {};
+	for (const k of keys) out[k] = (out[k] ?? 0) + 1;
+	return out;
+}
+export { assertConstantCommands, countCommands };

package/dist/mongo-explain.d.mts

@@ -0,0 +1,32 @@
+/**
+ * Read a MongoDB `explain()` result — find, aggregate, classic or SBE — as the WINNING plan's stage
+ * names, the indexes it scans, and its execution stats (`executionStats` verbosity). Rejected plans
+ * and query predicates are never read. `assertIndexServed` fails on a COLLSCAN, on a plan scanning
+ * no index (an explain of an empty or missing collection), and on every option not met.
+ *
+ * ```ts
+ * const explain = await Model.find({ organizationId, state: "posted" }).explain("executionStats");
+ * assertIndexServed(explain, { index: "org_state_date", maxDocsExamined: 40 });
+ * ```
+ */
+interface ExplainSummary {
+  /** Stage names of the winning plan(s), outermost first. */
+  readonly stages: readonly string[];
+  /** Index names the winning plan scans (`_id_` for an id lookup). */
+  readonly indexes: readonly string[];
+  /** From the first `executionStats` block; `undefined` under `queryPlanner` verbosity. */
+  readonly docsExamined: number | undefined;
+  readonly keysExamined: number | undefined;
+  readonly returned: number | undefined;
+}
+interface IndexServedOptions {
+  /** Every one of these must be scanned. */
+  readonly index?: string | readonly string[];
+  /** Every one of these stages must appear — e.g. `OR` for a `$or` served arm by arm. */
+  readonly stages?: readonly string[];
+  /** Ceiling on `totalDocsExamined`; requires `executionStats` verbosity. */
+  readonly maxDocsExamined?: number;
+}
+declare function summarizeExplain(explain: unknown): ExplainSummary;
+declare function assertIndexServed(explain: unknown, options?: IndexServedOptions): ExplainSummary;
+export { ExplainSummary, IndexServedOptions, assertIndexServed, summarizeExplain };

package/dist/mongo-explain.mjs

@@ -0,0 +1,66 @@
+// src/mongo-explain.ts
+/** Keys whose subtree is a rejected alternative or a query predicate — never plan structure. */
+const SKIPPED = /* @__PURE__ */ new Set([
+	"rejectedPlans",
+	"allPlansExecution",
+	"command",
+	"parsedQuery",
+	"filter",
+	"slotBasedPlan"
+]);
+const ID_LOOKUPS = /* @__PURE__ */ new Set(["IDHACK", "EXPRESS_IDHACK"]);
+function summarizeExplain(explain) {
+	const stages = [];
+	const indexes = [];
+	let stats;
+	const walk = (node, inPlan) => {
+		if (Array.isArray(node)) {
+			for (const item of node) walk(item, inPlan);
+			return;
+		}
+		if (!isRecord(node)) return;
+		if (inPlan && typeof node.stage === "string") {
+			stages.push(node.stage);
+			if (typeof node.indexName === "string") indexes.push(node.indexName);
+			else if (ID_LOOKUPS.has(node.stage)) indexes.push("_id_");
+		}
+		for (const [key, value] of Object.entries(node)) {
+			if (SKIPPED.has(key)) continue;
+			if (key === "executionStats" && isRecord(value) && typeof value.totalDocsExamined === "number") stats ??= value;
+			walk(value, inPlan || key === "winningPlan");
+		}
+	};
+	walk(explain, false);
+	return {
+		stages,
+		indexes: [...new Set(indexes)],
+		docsExamined: numberOr(stats?.totalDocsExamined),
+		keysExamined: numberOr(stats?.totalKeysExamined),
+		returned: numberOr(stats?.nReturned)
+	};
+}
+function assertIndexServed(explain, options = {}) {
+	const plan = summarizeExplain(explain);
+	const fail = (msg) => {
+		throw new Error(`[arc-testkit] assertIndexServed: ${msg} — plan [${plan.stages.join(" > ")}], indexes [${plan.indexes.join(", ")}]`);
+	};
+	if (plan.stages.length === 0) fail("no winning plan found — pass the result of explain()");
+	if (plan.stages.includes("COLLSCAN")) fail("the plan scans the collection");
+	if (plan.indexes.length === 0) fail("the plan scans no index — is the collection empty or missing?");
+	const unused = (typeof options.index === "string" ? [options.index] : options.index ?? []).filter((i) => !plan.indexes.includes(i));
+	if (unused.length > 0) fail(`index ${unused.map((i) => `"${i}"`).join(", ")} is not scanned`);
+	const absent = (options.stages ?? []).filter((s) => !plan.stages.includes(s));
+	if (absent.length > 0) fail(`stage ${absent.join(", ")} is not in the plan`);
+	if (options.maxDocsExamined !== void 0) {
+		if (plan.docsExamined === void 0) fail("maxDocsExamined needs explain('executionStats')");
+		else if (plan.docsExamined > options.maxDocsExamined) fail(`examined ${plan.docsExamined} documents, ceiling ${options.maxDocsExamined}`);
+	}
+	return plan;
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+function numberOr(value) {
+	return typeof value === "number" ? value : void 0;
+}
+export { assertIndexServed, summarizeExplain };

package/dist/mongo.d.mts

@@ -1,6 +1,5 @@
 import { TestServerProvider } from "./pool.mjs";
 import { Connection } from "mongoose";
-//#region src/mongo.d.ts
 /** WiredTiger cache per server, in GB. 0.25 is mongod's own floor. */
 declare function cacheSizeGB(): number;
 /** mongod CLI args that bound a test server's footprint. */
@@ -83,5 +82,4 @@ interface MongoServerProviderOptions {
  * pool serve both kinds from one process when sharing is on.
  */
 declare function mongoServerProvider(options?: MongoServerProviderOptions): TestServerProvider<Connection>;
-//#endregion
 export { MongoServerProviderOptions, MongooseLike, awaitIndexBuilds, cacheSizeGB, mongoServerProvider, mongodMemoryArgs, safePoolSize, safeWorkerCount, withDbName };

package/dist/mongo.mjs

@@ -1,5 +1,5 @@
 import { cpus, freemem, totalmem } from "node:os";
-//#region src/mongo.ts
+// src/mongo.ts
 /**
 * `@classytic/arc-testkit/mongo` — the Mongo adapter for the driver-agnostic pool.
 *
@@ -225,5 +225,4 @@ function mongoServerProvider(options = {}) {
 		}
 	};
 }
-//#endregion
 export { awaitIndexBuilds, cacheSizeGB, mongoServerProvider, mongodMemoryArgs, safePoolSize, safeWorkerCount, withDbName };

package/dist/pool.d.mts

@@ -1,5 +1,4 @@
 import { TestDatabase, TestDatabaseFactory } from "@classytic/arc/testing";
-//#region src/pool.d.ts
 /** Which server shape a suite needs. */
 type ServerKind = "standalone" | "transactional";
 /** A running server the pool may hand out namespaces on. */
@@ -186,5 +185,4 @@ declare function createTestDatabasePool<TConn>(provider: TestServerProvider<TCon
  * `globalSetup` in a run that prefers boot-cost-up-front over laziness.
  */
 declare function publishPoolServers(servers: Partial<Record<ServerKind, readonly string[]>>, envPrefix?: string): void;
-//#endregion
 export { ServerKind, TestDatabasePool, TestDatabasePoolOptions, TestServerHandle, TestServerProvider, createTestDatabasePool, publishPoolServers };

package/dist/pool.mjs

@@ -1,8 +1,8 @@
-import { randomBytes } from "node:crypto";
 import { existsSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
 import { join } from "node:path";
-//#region src/pool.ts
+import { randomBytes } from "node:crypto";
+import { tmpdir } from "node:os";
+// src/pool.ts
 /**
 * `@classytic/arc-testkit/pool` — a POOLED `TestDatabaseFactory`, driver-agnostic.
 *
@@ -406,5 +406,4 @@ function publishPoolServers(servers, envPrefix = "ARC_TESTKIT") {
 	}
 	writeFileSync(file, JSON.stringify(servers));
 }
-//#endregion
 export { createTestDatabasePool, publishPoolServers };

package/dist/story.d.mts

@@ -0,0 +1,202 @@
+import { expect } from "vitest";
+type Clauses = string | readonly string[];
+/** `[REQ-1 | Reminders] the reminder reached the holder`. */
+declare function clauseMessage(clauses: Clauses | undefined, what: string): string;
+interface StepContext {
+  /** The step's number in the story. */
+  readonly n: number;
+  readonly title: string;
+  readonly clauses: readonly string[];
+  /** The tagged message for an assertion in this step: `[clauses] what`. */
+  msg(what: string, clauses?: Clauses): string;
+  /** `expect(actual, "[clauses] what")`. */
+  expect<T>(actual: T, what: string, clauses?: Clauses): ReturnType<typeof expect<T>>;
+  /** `expect.soft`: a failure is reported at the end of the step, the step keeps running. */
+  soft<T>(actual: T, what: string, clauses?: Clauses): ReturnType<typeof expect.soft<T>>;
+  /** A known defect: soft, tagged `KNOWN DEFECT <id>` so the report names the open finding. */
+  known<T>(defect: string, actual: T, what: string, clauses?: Clauses): ReturnType<typeof expect.soft<T>>;
+}
+interface StepOptions {
+  clauses?: Clauses;
+  /** Per-step timeout in ms. */
+  timeout?: number;
+}
+/** What a step body is: the step context, then the vitest test context (fixtures of an extended `test`). */
+type StepBody<Ctx> = (t: StepContext, ctx: Ctx) => void | Promise<void>;
+interface Story<Ctx = unknown> {
+  /** Register the next numbered step. */
+  step(title: string, run: StepBody<Ctx>): void;
+  step(title: string, options: StepOptions, run: StepBody<Ctx>): void;
+  /** Number the next step will have. */
+  readonly next: number;
+}
+/** The registration function of an extended `test` (`test.extend(...)`), so steps receive its fixtures. */
+type StepRegistrar<Ctx> = (name: string, fn: (ctx: Ctx & {
+  skip(note?: string): never;
+}) => Promise<void>, timeout?: number) => unknown;
+interface StoryOptions<Ctx = unknown> {
+  /** An extended `test`: steps then get its fixtures as their second argument. Default: vitest's `it`. */
+  test?: StepRegistrar<Ctx>;
+  /** Names of the extended test's fixtures the steps use; they arrive in the second argument. */
+  fixtures?: readonly (keyof Ctx & string)[];
+  /** Number of the first step. Default: 1. */
+  firstStep?: number;
+  /** Skip the remaining steps once one fails. Default: true. */
+  bail?: boolean;
+  /** Clauses added to every step. */
+  clauses?: Clauses;
+}
+/** Registers a `describe` holding the story's numbered steps. */
+declare function describeStory<Ctx = unknown>(title: string, define: (story: Story<Ctx>) => void, options?: StoryOptions<Ctx>): void;
+/** Read a handed-over value, with an error that names the missing step instead of a bare `undefined`. */
+declare function need<T>(bag: Readonly<Record<string, T | undefined>>, key: string): T;
+type Row = Record<string, unknown>;
+type Awaitable<T> = T | PromiseLike<T>;
+/** A string / RegExp (tested on the row's key field), a function, or an object matched as a deep subset. */
+type RowMatch = string | RegExp | ((row: never) => boolean) | Row;
+interface FeedItem {
+  title?: string;
+  message?: string;
+  [key: string]: unknown;
+}
+interface StoryPorts<TActor = unknown> {
+  /** Deliver everything pending in the transactional outbox (one pass). */
+  drain?: () => Awaitable<unknown>;
+  /** The domain events seen so far (see {@link createEventLog}). */
+  events?: () => Awaitable<readonly Row[]>;
+  /** A user's in-app feed, newest first or not: order is never asserted. */
+  feed?: (actor: TActor) => Awaitable<readonly FeedItem[]>;
+  /** Mails the dev outbox holds. */
+  mail?: () => Awaitable<readonly Row[]>;
+  /** Audit rows, optionally narrowed by the host-defined filter. */
+  audit?: (filter?: Row) => Awaitable<readonly Row[]>;
+  /** Field holding an event's type. Default: `type`. */
+  eventTypeKey?: string;
+}
+interface Expectation {
+  clauses?: Clauses;
+  /** Exact number of matching rows. */
+  count?: number;
+  /** At least this many (default 1 unless `count` is given). */
+  min?: number;
+  /** Ignore the first `since` events (a mark from {@link EventLog.mark}). */
+  since?: number;
+}
+interface RelayOptions {
+  timeout?: number;
+  interval?: number;
+}
+/** True when `actual` carries every field of `expected` (RegExp and function leaves are tested, not compared). */
+declare function subsetMatches(actual: unknown, expected: unknown): boolean;
+interface StoryAssertions<TActor> {
+  /** Drain the outbox `rounds` times (a handler may write further events). */
+  drain(rounds?: number): Promise<void>;
+  /** Drain, then assert; repeat until the assertion holds (events are relayed asynchronously). */
+  relayed<T>(assertion: () => T | Promise<T>, options?: RelayOptions): Promise<T>;
+  /** Events matching `match` (after `since`). */
+  eventsOf(match: RowMatch, since?: number): Promise<Row[]>;
+  expectEvent(match: RowMatch, spec?: Expectation): Promise<Row[]>;
+  expectNoEvent(match: RowMatch, spec?: Pick<Expectation, "clauses" | "since">): Promise<void>;
+  /** Feed items of `actor` whose title / message match. */
+  feedOf(actor: TActor): Promise<readonly FeedItem[]>;
+  expectFeed(actor: TActor, match: RowMatch, spec?: Expectation): Promise<readonly FeedItem[]>;
+  expectNoFeed(actor: TActor, match: RowMatch, spec?: Pick<Expectation, "clauses">): Promise<void>;
+  expectMail(match: RowMatch, spec?: Expectation): Promise<Row[]>;
+  expectAudit(filter: Row | undefined, match: RowMatch, spec?: Expectation): Promise<Row[]>;
+}
+declare function createStoryAssertions<TActor = unknown>(ports: StoryPorts<TActor>): StoryAssertions<TActor>;
+interface EventLog<E extends Row = Row> {
+  record(event: E): void;
+  all(): readonly E[];
+  /** The number of events so far: pass it as `since` to look only at what happens next. */
+  mark(): number;
+  clear(): void;
+  /**
+   * Subscribe `patterns` through the host's bus (`subscribe(pattern, handler)`, e.g. `app.events.subscribe`)
+   * so every matching event is recorded.
+   */
+  tap(subscribe: (pattern: string, handler: (event: E) => unknown) => unknown, patterns: readonly string[]): void;
+}
+/** An in-memory event log fed by a tap on the host's event bus; the `events` port reads it. */
+declare function createEventLog<E extends Row = Row>(): EventLog<E>;
+/**
+ * A cast: the named users of a story, each provisioned with roles by a host function that signs the
+ * user up on the booted app and returns whatever the story talks through (a client, a token).
+ */
+interface CastSpecEntry<TOpts> {
+  roles: readonly string[];
+  opts?: TOpts;
+}
+/** `roles` shorthand, or `{ roles, opts }` when the host's provisioner takes options (e.g. `{ mfa: false }`). */
+type CastSpec<TOpts> = readonly string[] | CastSpecEntry<TOpts>;
+interface Cast<TActor, TOpts> {
+  /** Provision every member of `spec` (in order) and remember them by name. */
+  build<const S extends Record<string, CastSpec<TOpts>>>(spec: S): Promise<{ [K in keyof S]: TActor; }>;
+  /** Provision one member. */
+  add(name: string, roles: readonly string[], opts?: TOpts): Promise<TActor>;
+  /** A provisioned member; throws a story-readable error when the name was never added. */
+  get(name: string): TActor;
+  names(): string[];
+}
+declare function createCast<TActor, TOpts = undefined>(provision: (roles: readonly string[], opts: TOpts | undefined, name: string) => Promise<TActor>): Cast<TActor, TOpts>;
+/** `Authorization` headers for a bearer token. */
+declare const bearer: (token: string) => Record<string, string>;
+/**
+ * A controllable clock with time-travel helpers, and the civil-date arithmetic a story needs to say
+ * "thirty days later" without drifting across a zone's day boundary. The clock satisfies
+ * `{ now(): Date }`, the shape hosts inject into their app; the story moves it, the app reads it.
+ */
+interface StoryClock {
+  /** The `{ now }` the app reads. */
+  now(): Date;
+  /** The IANA zone civil dates are read in. */
+  readonly zone: string;
+  /** Jump to an instant. */
+  set(at: Date | string | number): void;
+  advanceMs(ms: number): void;
+  advanceDays(days: number): void;
+  /** Move to `hour:00` (default noon) in the zone on a civil date (`YYYY-MM-DD`). */
+  travelTo(day: string, hour?: number): Date;
+  /** The civil date now. */
+  today(): string;
+  /** Called after every move with the new instant. */
+  onChange(listener: (at: Date) => void): () => void;
+}
+interface StoryClockOptions {
+  start?: Date | string | number;
+  /** IANA zone for civil dates. Default: UTC. */
+  zone?: string;
+}
+/** The civil date (`YYYY-MM-DD`) of an instant in a zone. */
+declare function civilDateOf(at: Date, zone?: string): string;
+/** A civil date plus whole days. */
+declare function addCivilDays(day: string, days: number): string;
+/** A civil date plus whole months (same day of month; keep stories off the 29th to 31st). */
+declare function addCivilMonths(day: string, months: number): string;
+/** Whole days from civil date `a` to civil date `b`. */
+declare function daysBetween(a: string, b: string): number;
+/** The instant at `hour:00` (default noon) on a civil date in a zone: a stable "that day". */
+declare function instantOn(day: string, zone?: string, hour?: number): Date;
+declare function createStoryClock(options?: StoryClockOptions): StoryClock;
+interface IdempotencyOptions<TResult, TSnapshot> {
+  /** The sweep. */
+  run: () => Promise<TResult>;
+  /** What must be identical after run 1 and after run 2 (counts, ids, rows). */
+  snapshot: () => Promise<TSnapshot>;
+  /** Deliver asynchronous effects (outbox drain) before each snapshot. */
+  settle?: () => Promise<unknown>;
+  clauses?: Clauses;
+  /** Names the sweep in the failure. */
+  label?: string;
+}
+interface IdempotencyOutcome<TResult, TSnapshot> {
+  first: TResult;
+  second: TResult;
+  afterFirst: TSnapshot;
+  afterSecond: TSnapshot;
+}
+/** Run twice; fail unless the snapshot after the second run equals the one after the first. */
+declare function expectIdempotent<TResult, TSnapshot>(opts: IdempotencyOptions<TResult, TSnapshot>): Promise<IdempotencyOutcome<TResult, TSnapshot>>;
+/** {@link expectIdempotent} for several named sweeps sharing one snapshot. */
+declare function expectSweepsIdempotent<TSnapshot>(sweeps: Readonly<Record<string, () => Promise<unknown>>>, common: Pick<IdempotencyOptions<unknown, TSnapshot>, "snapshot" | "settle" | "clauses">): Promise<void>;
+export { Cast, CastSpec, CastSpecEntry, Clauses, EventLog, Expectation, FeedItem, IdempotencyOptions, IdempotencyOutcome, RelayOptions, RowMatch, StepBody, StepContext, StepOptions, StepRegistrar, Story, StoryAssertions, StoryClock, StoryClockOptions, StoryOptions, StoryPorts, addCivilDays, addCivilMonths, bearer, civilDateOf, clauseMessage, createCast, createEventLog, createStoryAssertions, createStoryClock, daysBetween, describeStory, expectIdempotent, expectSweepsIdempotent, instantOn, need, subsetMatches };