better-supabase 0.7.1 → 0.9.0

package/dist/otel/index.js

@@ -1,7 +1,7 @@
 import { r as definePlugin } from "../plugin-tfXW1-qO.js";
-import { t as SPEC_PINS } from "../spec-pins--j6mTok4.js";
-import { r as blockEventAttributes } from "../block-events-CrT8r7Fe.js";
-import "../version-C6OfRAIn.js";
+import { t as SPEC_PINS } from "../spec-pins-S4PymRxp.js";
+import { i as blockEventAttributes } from "../block-events-DD9Q_NUz.js";
+import "../version-D87ZteKy.js";
 import { SpanKind, SpanStatusCode, context, metrics, propagation, trace } from "@opentelemetry/api";
 //#region src/otel/index.ts
 const INSTRUMENTATION_NAME = "better-supabase";
@@ -40,9 +40,9 @@ function systemOf(executor) {
 * ```
 */
 function otel(options = {}) {
-	const tracer = options.tracer ?? trace.getTracer("better-supabase", "0.7.1");
+	const tracer = options.tracer ?? trace.getTracer("better-supabase", "0.9.0");
 	let histogram;
-	if (options.metrics !== false) histogram = (options.meter ?? metrics.getMeter("better-supabase", "0.7.1")).createHistogram("db.client.operation.duration", {
+	if (options.metrics !== false) histogram = (options.meter ?? metrics.getMeter("better-supabase", "0.9.0")).createHistogram("db.client.operation.duration", {
 		unit: "s",
 		description: "Duration of database client operations.",
 		advice: { explicitBucketBoundaries: [
@@ -148,6 +148,33 @@ function otel(options = {}) {
 				"db.system.name": system
 			};
 			const rpc = executor.rpc?.bind(executor);
+			const batch = executor.batch?.bind(executor);
+			/** Semantic conventions name a batch `BATCH <operation>` when every operation shares it. */
+			const describeBatch = (ops) => {
+				const [only, ...others] = new Set(ops.map(operationName));
+				const operation = only && others.length === 0 ? `BATCH ${only}` : "BATCH";
+				const [first, ...otherTables] = new Set(ops.map((op) => op.table));
+				const table = otherTables.length === 0 ? first : void 0;
+				const summary = table ? `${operation} ${table.name}` : operation;
+				const shared = {
+					"db.operation.name": operation,
+					...table ? { "db.collection.name": table.name } : {}
+				};
+				return {
+					summary,
+					attributes: {
+						...base,
+						...table ? { "db.namespace": database ? `${database}|${table.schema}` : table.schema } : {},
+						...shared,
+						"db.query.summary": summary,
+						"db.operation.batch.size": ops.length
+					},
+					metric: {
+						...baseMetric,
+						...shared
+					}
+				};
+			};
 			return {
 				...executor,
 				name: executor.name,
@@ -171,6 +198,14 @@ function otel(options = {}) {
 						"db.operation.name": "EXECUTE",
 						"db.stored_procedure.name": name
 					}, () => rpc(name, args, rpcContext), (span, result) => result.ok ? void 0 : failed(span, result.error));
+				} } : {},
+				...batch ? { batch(ops, executeContext) {
+					const { summary, attributes, metric } = describeBatch(ops);
+					return traced(summary, attributes, metric, () => batch(ops, executeContext), (span, results) => {
+						const failure = results.find((result) => !result.ok);
+						if (failure) return failed(span, failure.error);
+						if (span.isRecording()) span.setAttribute("db.response.returned_rows", results.reduce((rows, result) => rows + (result.ok ? result.data.rows.length : 0), 0));
+					});
 				} } : {}
 			};
 		}
@@ -181,7 +216,7 @@ function otel(options = {}) {
 * Returns a function that stops listening.
 */
 function traceAuth(betterSupabase, options = {}) {
-	const tracer = options.tracer ?? trace.getTracer("better-supabase", "0.7.1");
+	const tracer = options.tracer ?? trace.getTracer("better-supabase", "0.9.0");
 	const offAuth = betterSupabase.events.on("auth", (event) => {
 		const span = tracer.startSpan("auth.resolve", {
 			kind: SpanKind.INTERNAL,
@@ -219,7 +254,7 @@ function traceAuth(betterSupabase, options = {}) {
 * set an error status. Returns a function that stops listening.
 */
 function traceBlockEvents(betterSupabase, options = {}) {
-	const tracer = options.tracer ?? trace.getTracer("better-supabase", "0.7.1");
+	const tracer = options.tracer ?? trace.getTracer("better-supabase", "0.9.0");
 	return betterSupabase.events.on("block", (event) => {
 		const attributes = {
 			...options.attributes,

package/dist/outbox-BTeqjbum.d.ts

@@ -0,0 +1,181 @@
+/// <reference lib="esnext.temporal" />
+import { b as DbError, t as AsyncResult } from "./result-Cj3yWhjH.js";
+import { n as Logger } from "./logger-DWVYUmwi.js";
+import { i as CursorPageOptions, n as BlockOptions } from "./block-helpers-C86hPEjI.js";
+import { n as BlockHooks } from "./block-hooks-BLPWD3Jt.js";
+import { t as BlockProblemOptions } from "./problem-CEjyhV5T.js";
+import { i as EventSink, t as CloudEvent } from "./cloud-event-5rCEzIgK.js";
+import { g as SubscriberPolicy, i as AuthorizationHooks } from "./authorization-hooks-DkmrnDX7.js";
+//#region src/blocks/outbox/outbox.d.ts
+/** One row of the outbox, as `outbox_claim` and `outbox_history` return it. */
+interface OutboxEvent {
+  /** The cursor value: increases with every event. */
+  readonly position: number;
+  readonly id: string;
+  readonly type: string;
+  readonly payload: unknown;
+  /** The module or function that wrote it, e.g. `better-supabase/blocks/organizations`. */
+  readonly source: string | null;
+  readonly subject: string | null;
+  readonly tenant: string | null;
+  readonly key: string | null;
+  readonly actorId: string | null;
+  readonly createdAt: Temporal.Instant;
+}
+interface EmitOptions {
+  readonly subject?: string;
+  readonly tenant?: string;
+  /** With a key, emitting again (per tenant) returns the first event. */
+  readonly key?: string;
+  readonly source?: string;
+}
+/**
+ * `transport` writes (`emit`) and reads (`history`); `service`, which
+ * defaults to `transport`, runs the consumer calls (`register`, `relay`,
+ * `consume`, `deadLetters`, `purge`), which need the service role.
+ */
+interface OutboxOptions extends BlockOptions {
+  /** CloudEvents `source` of the relayed events, e.g. `https://crm.example.com`. */
+  readonly source: string;
+  /** Prepended to each type with a dot when relaying, e.g. `com.example`. Defaults to `dev.better-supabase`. */
+  readonly typePrefix?: string;
+  /**
+   * Decides, per event, whether a consumer gets it. The consumer is the
+   * subscriber `{ principal: <consumer name>, kind: "service" }`. An event
+   * it leaves out is skipped and the cursor moves past it; a throw counts
+   * as a failed attempt. Defaults to `authorization.delivery.subscribers`.
+   */
+  readonly subscribers?: SubscriberPolicy;
+  /** `server.authorization`, for its `delivery.subscribers` policy. */
+  readonly authorization?: Pick<AuthorizationHooks, "delivery">;
+  /** `withBlockHooks` hooks around the client's methods. */
+  readonly hooks?: BlockHooks<Outbox>;
+  /** Receives the errors `after` hooks throw. Default: `console`. */
+  readonly logger?: Logger;
+}
+interface RegisterOptions {
+  /** Type patterns such as `organization.*` or `invoice.paid`. Defaults to every event. */
+  readonly types?: readonly string[];
+  /** Start at the first kept event instead of after the latest one. */
+  readonly fromStart?: boolean;
+}
+interface RelayOptions {
+  /** Events per claim and per `sink.send`. Defaults to 100. */
+  readonly batch?: number;
+  /** How long a claim holds the consumer. Defaults to `1 minute`. */
+  readonly lease?: string;
+  /** Stops claiming after this many milliseconds. */
+  readonly budgetMs?: number;
+  /** Identifies this worker in the lease. Defaults to a random id. */
+  readonly owner?: string;
+  /**
+   * Failures in a row before the event that keeps failing goes to the dead
+   * letters and the cursor moves past it. Defaults to 10.
+   */
+  readonly maxAttempts?: number;
+  /** The longest wait between failed attempts. Defaults to `10 minutes`. */
+  readonly maxBackoff?: string;
+}
+interface RelayResult {
+  /** Events handed to the sink or handler. */
+  readonly delivered: number;
+  /** Events the `subscribers` policy kept from the consumer, when there were any. */
+  readonly refused?: number;
+  /**
+   * Set when the sink threw: the consumer backs off and retries the batch
+   * one event at a time.
+   */
+  readonly error?: DbError;
+  /** 1 when this run moved the failing event to the dead letters. */
+  readonly deadLettered?: number;
+}
+/** An event a consumer skipped after `maxAttempts` failures. */
+interface OutboxDeadLetter {
+  readonly consumer: string;
+  readonly event: OutboxEvent;
+  readonly attempts: number;
+  readonly error: string | null;
+  readonly deadAt: Temporal.Instant;
+}
+interface OutboxPurgeOptions {
+  /**
+   * A consumer that hasn't claimed for this long (a Postgres interval such
+   * as `30 days`) no longer holds events back. Defaults to waiting for
+   * every consumer.
+   */
+  readonly ignoreIdle?: string;
+}
+/**
+ * Takes a batch of outbox rows, with the actor and tenant that CloudEvents
+ * leave out. Throwing counts a failed attempt: the consumer backs off, then
+ * retries one event at a time until the event that fails goes to the dead
+ * letters.
+ */
+type OutboxHandler = (events: readonly OutboxEvent[]) => unknown;
+interface OutboxRouteOptions extends Omit<RelayOptions, "owner">, BlockProblemOptions {
+  /** The bearer secret, such as `process.env.CRON_SECRET`. */
+  readonly secret: string | undefined;
+  /** Consumer name to the sink its events go to, or a handler that takes the rows. */
+  readonly consumers: Readonly<Record<string, EventSink | OutboxHandler>>;
+  readonly onError?: (error: DbError, consumer: string) => void;
+}
+interface OutboxRouteResult {
+  readonly consumers: Readonly<Record<string, RelayResult>>;
+  readonly budgetExhausted: boolean;
+}
+interface HistoryFilter extends CursorPageOptions<number> {
+  readonly subject?: string;
+  readonly type?: string;
+  /** Only events after this position. */
+  readonly cursor?: number;
+  readonly limit?: number;
+}
+interface Outbox {
+  /** Writes an event in the current transaction and returns its id. */
+  emit(type: string, payload?: unknown, options?: EmitOptions): AsyncResult<string>;
+  /** Creates the consumer, or changes its types. Returns its cursor position. */
+  register(consumer: string, options?: RegisterOptions): AsyncResult<number>;
+  /** Removes the consumer, so purges stop waiting for it. */
+  unregister(consumer: string): AsyncResult<boolean>;
+  /**
+   * Claims the consumer's next events, sends them to `sink` as CloudEvents and
+   * moves the cursor, until none are left or the budget runs out. A sink that
+   * throws leaves the batch for a later run with backoff, so delivery is at
+   * least once; an event that fails `maxAttempts` times goes to the dead
+   * letters.
+   */
+  relay(consumer: string, sink: EventSink, options?: RelayOptions): Promise<RelayResult>;
+  /**
+   * Like `relay`, but hands `handler` the outbox rows themselves, with
+   * `actorId`, `tenant` and `key`, for consumers inside the app (search
+   * indexing, notifications) that need the actor.
+   */
+  consume(consumer: string, handler: OutboxHandler, options?: RelayOptions): Promise<RelayResult>;
+  /** A `GET`/`POST` handler for a cron that relays every consumer at once, within one budget. */
+  relayRoute(options: OutboxRouteOptions): (request: Request) => Promise<Response>;
+  history(filter?: HistoryFilter): AsyncResult<readonly OutboxEvent[]>;
+  /** The consumer's dead letters, newest first (default 100, at most 1000). */
+  deadLetters(consumer: string, limit?: number): AsyncResult<readonly OutboxDeadLetter[]>;
+  /**
+   * Deletes up to `batch` events (default 10,000) older than `olderThan` that
+   * every consumer has passed, and dead letters older than `olderThan`. Call
+   * it again while it returns `batch`.
+   */
+  purge(olderThan?: string, batch?: number, options?: OutboxPurgeOptions): AsyncResult<number>;
+}
+/**
+ * The CloudEvent for an outbox row: the row id as `id` (stable, so receivers
+ * can deduplicate), the payload as `data`, the tenant as `partitionkey` and
+ * the writing module as `producer`. The actor stays out of the context
+ * attributes, which must not carry personal data.
+ */
+declare function outboxCloudEvent(event: OutboxEvent, options: Pick<OutboxOptions, "source" | "typePrefix">): CloudEvent;
+/**
+ * The outbox over a `BlockTransport`: `sqlTransport(postgres)` on a server
+ * connection, where `emit` joins the caller's transaction, or
+ * `rpcTransport(serviceClient)` for apps that reach the database only
+ * through the Data API, where `emit` writes in its own transaction.
+ */
+declare function createOutbox(options: OutboxOptions): Outbox;
+//#endregion
+export { OutboxEvent as a, OutboxPurgeOptions as c, RegisterOptions as d, RelayOptions as f, outboxCloudEvent as h, OutboxDeadLetter as i, OutboxRouteOptions as l, createOutbox as m, HistoryFilter as n, OutboxHandler as o, RelayResult as p, Outbox as r, OutboxOptions as s, EmitOptions as t, OutboxRouteResult as u };

package/dist/overlay/index.d.ts

@@ -0,0 +1,233 @@
+import { c as SpecDiagnostic } from "../format-CNwSjXUU.js";
+//#region src/overlay/types.d.ts
+/** The Overlay versions `applyOverlay` reads. Patch versions are ignored (Overlay § 4.1). */
+type OverlayVersion = "1.0.0" | "1.1.0" | "1.2.0";
+/** Specification extensions: fields that start with `x-` (Overlay 1.2 § 4.7). */
+type Extensions = {
+  readonly [key: `x-${string}`]: unknown;
+};
+type OverlayInfo = {
+  /** The purpose of the overlay. */
+  readonly title: string;
+  /** The overlay's own version, not the Overlay Specification version. */
+  readonly version: string;
+  /** CommonMark (1.1 and later). */
+  readonly description?: string;
+} & Extensions;
+/** Fields every action kind shares. */
+interface ActionFields {
+  readonly description?: string;
+  /** Merged into objects, concatenated or appended to arrays, or replaces primitives. */
+  readonly update?: unknown;
+  /** When `true`, every selected node is removed. Wins over `update` and `copy`. */
+  readonly remove?: boolean;
+  /**
+   * Accept a target that selects nothing. Without it, `applyOverlay`
+   * reports `overlay-no-match` as an error.
+   */
+  readonly "x-better-supabase-allow-empty"?: boolean;
+}
+/** An Overlay 1.0 Action Object. */
+type OverlayAction10 = ActionFields & {
+  /** An RFC 9535 JSONPath query. */
+  readonly target: string;
+} & Extensions;
+/** An Overlay 1.1 and 1.2 Action Object, which adds `copy`. */
+type OverlayAction = OverlayAction10 & {
+  /** A JSONPath query that selects one node whose value is used like `update`. */
+  readonly copy?: string;
+};
+/** The fields of a reusable action (1.2): an Action Object without `target`. */
+type ReusableActionFields = Omit<OverlayAction, "target">;
+/** A Reusable Action Object (Overlay 1.2 § 4.5.5). */
+type ReusableAction = {
+  readonly description?: string;
+  readonly fields?: ReusableActionFields;
+} & Extensions;
+/**
+ * A Reusable Action Reference Object (Overlay 1.2 § 4.5.6). Its own action
+ * fields override the referenced ones for this use.
+ */
+type ReusableActionReference = Partial<Omit<OverlayAction, "target">> & {
+  /** `#/components/actions/<name>`, with the name escaped per RFC 6901. */
+  readonly $ref: `#/components/actions/${string}`;
+  readonly target: string;
+};
+interface OverlayBase {
+  readonly info: OverlayInfo;
+  /** URI of the target document, without a fragment. */
+  readonly extends?: string;
+}
+type Overlay10 = OverlayBase & {
+  readonly overlay: "1.0.0";
+  readonly actions: readonly OverlayAction10[];
+} & Extensions;
+type Overlay11 = OverlayBase & {
+  readonly overlay: "1.1.0";
+  readonly actions: readonly OverlayAction[];
+} & Extensions;
+type Overlay12 = OverlayBase & {
+  readonly overlay: "1.2.0";
+  /** URI of this overlay and its base URI, without a fragment. */
+  readonly $self?: string;
+  readonly actions: readonly (OverlayAction | ReusableActionReference)[];
+  readonly components?: {
+    readonly actions?: Readonly<Record<string, ReusableAction>>;
+  } & Extensions;
+} & Extensions;
+/** An Overlay document of any supported version. */
+type Overlay = Overlay10 | Overlay11 | Overlay12;
+/**
+ * The JSONPath engine `applyOverlay` runs targets with. `paths` returns the
+ * RFC 9535 normalized paths (`$['paths']['/a'][0]`) of the selected nodes
+ * and throws for an invalid query. `loadJsonPath()` returns the
+ * `jsonpath-rfc9535` engine; any RFC 9535 implementation fits.
+ */
+interface JsonPathEngine {
+  paths(document: unknown, expression: string): readonly string[];
+}
+interface ApplyOverlayOptions {
+  readonly jsonpath: JsonPathEngine;
+  /** Accept targets that select nothing in every action. Default `false`. */
+  readonly allowEmpty?: boolean;
+}
+interface OverlayResult<T> {
+  /** A new document; the input is never changed. */
+  readonly document: T;
+  /** Errors, warnings and notes, in action order. Callers decide what fails a build. */
+  readonly diagnostics: readonly SpecDiagnostic[];
+}
+//#endregion
+//#region src/overlay/apply.d.ts
+/**
+ * Applies an Overlay 1.0, 1.1 or 1.2 document to `document` and returns a
+ * new document. The input is cloned once with `structuredClone` and never
+ * changed; each target runs once through `options.jsonpath`.
+ *
+ * Actions run in order, each on the result of the previous one (Overlay
+ * § 4.5.1.1). `update` merges objects, concatenates or appends to arrays and
+ * replaces primitives; `remove` deletes the selected nodes; `copy` (1.1 and
+ * later) uses the value of the single node its query selects. Reusable action
+ * references (1.2) are expanded, with a warning when the overlay declares
+ * 1.0 or 1.1.
+ *
+ * Problems never throw: they are diagnostics, and the failing action is
+ * skipped. A target that selects nothing reports `overlay-no-match` as an
+ * error unless the action sets `x-better-supabase-allow-empty: true` or the
+ * options set `allowEmpty`. The other codes are `overlay-invalid-target`,
+ * `overlay-invalid-action`, `overlay-mixed-targets`,
+ * `overlay-merge-conflict`, `overlay-copy-source`, `overlay-ref-unresolved`,
+ * `overlay-version-feature`, `overlay-version-unsupported` and
+ * `overlay-empty-action`.
+ *
+ * The result keeps the input's type; an overlay that changes the shape
+ * needs the caller to narrow it.
+ *
+ * @example
+ * const jsonpath = await loadJsonPath();
+ * const { document, diagnostics } = applyOverlay(openapi, overlay, { jsonpath });
+ */
+export declare function applyOverlay<T>(document: T, overlay: Overlay, options: ApplyOverlayOptions): OverlayResult<T>;
+/**
+ * Applies overlays in order, each to the result of the previous one, with a
+ * single clone of the input. Diagnostic pointers start with the overlay's
+ * index (`/1/actions/0`).
+ */
+export declare function applyOverlays<T>(document: T, overlays: readonly Overlay[], options: ApplyOverlayOptions): OverlayResult<T>;
+//#endregion
+//#region src/overlay/define.d.ts
+/** What `defineOverlay` accepts: an Overlay document whose `overlay` field is optional. */
+type OverlayInput = {
+  readonly overlay?: OverlayVersion;
+  readonly info: OverlayInfo;
+  readonly extends?: string;
+  readonly $self?: string;
+  readonly actions: readonly (OverlayAction | ReusableActionReference)[];
+  readonly components?: {
+    readonly actions?: Readonly<Record<string, ReusableAction>>;
+  } & Extensions;
+} & Extensions;
+type UsesOverlay12<I extends OverlayInput> = I extends {
+  readonly components: object;
+} ? true : I extends {
+  readonly $self: string;
+} ? true : [Extract<I["actions"][number], {
+  readonly $ref: string;
+}>] extends [never] ? false : true;
+/** The document type `defineOverlay` returns for an input. */
+type DefinedOverlay<I extends OverlayInput> = I extends {
+  readonly overlay: "1.0.0";
+} ? Overlay10 : I extends {
+  readonly overlay: "1.1.0";
+} ? Overlay11 : I extends {
+  readonly overlay: "1.2.0";
+} ? Overlay12 : UsesOverlay12<I> extends true ? Overlay12 : Overlay11;
+/**
+ * Defines an Overlay document with checks a schema cannot make. `overlay`
+ * defaults to `1.1.0`, or to `1.2.0` when the input uses a 1.2 feature
+ * (`components`, `$self` or a reusable action reference), and the return
+ * type follows it.
+ *
+ * Throws a `TypeError` when there are no actions, when a feature needs a
+ * newer version than the one set (`copy` needs 1.1, reusable actions and
+ * `$self` need 1.2), when a reference names a missing reusable action, or
+ * when `extends` or `$self` contains a fragment.
+ *
+ * @example
+ * const overlay = defineOverlay({
+ *   info: { title: "Public API", version: "1.0.0" },
+ *   actions: [
+ *     { target: "$.paths['/customers'].get", update: { summary: "List customers" } },
+ *     { target: "$.paths[?@['x-internal'] == true]", remove: true },
+ *   ],
+ * });
+ */
+export declare function defineOverlay<const I extends OverlayInput>(input: I): DefinedOverlay<I>;
+/**
+ * Turns an overlay into an equivalent Overlay 1.1 document for tools that do
+ * not read 1.2: every reusable action reference becomes a plain action, and
+ * `$self` and `components` are dropped. A reference that does not resolve is
+ * left out and reported as `overlay-ref-unresolved`.
+ */
+export declare function expandReusableActions(overlay: Overlay): {
+  readonly overlay: Overlay11;
+  readonly diagnostics: readonly SpecDiagnostic[];
+};
+//#endregion
+//#region src/overlay/diff.d.ts
+interface OverlayFromDiffOptions<V extends OverlayVersion> {
+  /** The Overlay version to write. Default `1.1.0`. */
+  readonly version?: V;
+  /** Default `{ title: "better-supabase changes", version: "1.0.0" }`. */
+  readonly info?: OverlayInfo;
+  readonly extends?: string;
+}
+type OverlayOf<V extends OverlayVersion> = V extends "1.0.0" ? Overlay10 : V extends "1.2.0" ? Overlay12 : Overlay11;
+/**
+ * Writes the Overlay that turns `base` into `enriched`, so other tools can
+ * reproduce what hooks and transforms changed. Targets use stable keys
+ * (`$.paths['/customers'].get`); array indexes appear only inside arrays of
+ * the same length.
+ *
+ * A deleted key becomes a `remove` action; added keys become one `update` on
+ * their parent; a changed primitive becomes an `update` on it (1.1 and
+ * later) or a `remove` and re-add (1.0). An array that only grew gets its new
+ * items appended; any other array change replaces the array. Applying the
+ * result to `base` gives a document equal to `enriched`, though replaced
+ * keys move to the end of their object.
+ *
+ * Throws a `TypeError` when the roots are not both objects, or when the two
+ * documents are equal (an overlay needs at least one action).
+ */
+export declare function overlayFromDiff<V extends OverlayVersion = "1.1.0">(base: unknown, enriched: unknown, options?: OverlayFromDiffOptions<V>): OverlayOf<V>;
+//#endregion
+//#region src/overlay/load.d.ts
+/**
+ * Loads the optional `jsonpath-rfc9535` peer, an RFC 9535 implementation
+ * that passes the JSONPath Compliance Test Suite, for `applyOverlay`.
+ * Rejects with an install message when the package is missing. The engine
+ * is loaded once per module; `importer` replaces the import in tests.
+ */
+export declare function loadJsonPath(importer?: () => Promise<unknown>): Promise<JsonPathEngine>;
+//#endregion
+export type { ApplyOverlayOptions, DefinedOverlay, Extensions, JsonPathEngine, Overlay, Overlay10, Overlay11, Overlay12, OverlayAction, OverlayAction10, OverlayFromDiffOptions, OverlayInfo, OverlayInput, OverlayResult, OverlayVersion, ReusableAction, ReusableActionFields, ReusableActionReference, SpecDiagnostic };