@classytic/arc 2.3.0 → 2.4.2

package/dist/cache/index.d.mts

@@ -1,6 +1,27 @@
-import { i as CacheStore, n as CacheSetOptions, r as CacheStats, t as CacheLogger } from "../interface-DTbsvIWe.mjs";
-import { a as CacheEnvelope, c as QueryCache, i as queryCachePlugin, l as QueryCacheConfig, n as QueryCacheDefaults, o as CacheResult, r as QueryCachePluginOptions, s as CacheStatus, t as CrossResourceRule } from "../queryCachePlugin-Q6SYuHZ6.mjs";
+import { i as CacheStore, n as CacheSetOptions, r as CacheStats, t as CacheLogger } from "../interface-D_BWALyZ.mjs";
+import { a as CacheEnvelope, c as QueryCache, i as queryCachePlugin, l as QueryCacheConfig, n as QueryCacheDefaults, o as CacheResult, r as QueryCachePluginOptions, s as CacheStatus, t as CrossResourceRule } from "../queryCachePlugin-DcmETvcB.mjs";
 
+//#region src/cache/keys.d.ts
+/**
+ * Cache Key Utilities
+ *
+ * Deterministic, scope-safe key generation for QueryCache.
+ * Keys include resource version, operation, params hash, and user/org scope
+ * to ensure multi-tenant isolation and O(1) version-based invalidation.
+ */
+/** Build a deterministic cache key for a query */
+declare function buildQueryKey(resource: string, operation: string, resourceVersion: number, params: Record<string, unknown>, userId?: string, orgId?: string): string;
+/** Resource version key — stored in CacheStore, bumped on mutations */
+declare function versionKey(resource: string): string;
+/** Tag version key — stored in CacheStore, bumped on cross-resource invalidation */
+declare function tagVersionKey(tag: string): string;
+/**
+ * Stable hash for query params.
+ * Sorts keys recursively, serializes to JSON, then applies djb2 hash.
+ * Returns hex string.
+ */
+declare function hashParams(params: Record<string, unknown>): string;
+//#endregion
 //#region src/cache/memory.d.ts
 interface MemoryCacheStoreOptions {
   /** Default TTL in milliseconds (default: 60_000) */
@@ -121,25 +142,4 @@ declare class RedisCacheStore<TValue = unknown> implements CacheStore<TValue> {
   private withPrefix;
 }
 //#endregion
-//#region src/cache/keys.d.ts
-/**
- * Cache Key Utilities
- *
- * Deterministic, scope-safe key generation for QueryCache.
- * Keys include resource version, operation, params hash, and user/org scope
- * to ensure multi-tenant isolation and O(1) version-based invalidation.
- */
-/** Build a deterministic cache key for a query */
-declare function buildQueryKey(resource: string, operation: string, resourceVersion: number, params: Record<string, unknown>, userId?: string, orgId?: string): string;
-/** Resource version key — stored in CacheStore, bumped on mutations */
-declare function versionKey(resource: string): string;
-/** Tag version key — stored in CacheStore, bumped on cross-resource invalidation */
-declare function tagVersionKey(tag: string): string;
-/**
- * Stable hash for query params.
- * Sorts keys recursively, serializes to JSON, then applies djb2 hash.
- * Returns hex string.
- */
-declare function hashParams(params: Record<string, unknown>): string;
-//#endregion
 export { type CacheEnvelope, type CacheLogger, type CacheResult, type CacheSetOptions, type CacheStats, type CacheStatus, type CacheStore, type CrossResourceRule, MemoryCacheStore, type MemoryCacheStoreOptions, QueryCache, type QueryCacheConfig, type QueryCacheDefaults, type QueryCachePluginOptions, type RedisCacheClient, RedisCacheStore, type RedisCacheStoreOptions, type RedisPipeline, buildQueryKey, hashParams, queryCachePlugin, tagVersionKey, versionKey };

package/dist/cache/index.mjs

@@ -1,7 +1,6 @@
-import { i as versionKey, n as hashParams, r as tagVersionKey, t as buildQueryKey } from "../keys-DhqDRxv3.mjs";
-import { t as MemoryCacheStore } from "../memory-B2v7KrCB.mjs";
-import { r as QueryCache, t as queryCachePlugin } from "../queryCachePlugin-B6R0d4av.mjs";
-
+import { i as versionKey, n as hashParams, r as tagVersionKey, t as buildQueryKey } from "../keys-qcD-TVJl.mjs";
+import { t as MemoryCacheStore } from "../memory-Cb_7iy9e.mjs";
+import { r as QueryCache, t as queryCachePlugin } from "../queryCachePlugin-ClosZdNS.mjs";
 //#region src/cache/redis.ts
 /**
 * Redis-backed cache store.
@@ -86,6 +85,5 @@ var RedisCacheStore = class {
 		return `${this.prefix}${key}`;
 	}
 };
-
 //#endregion
-export { MemoryCacheStore, QueryCache, RedisCacheStore, buildQueryKey, hashParams, queryCachePlugin, tagVersionKey, versionKey };
+export { MemoryCacheStore, QueryCache, RedisCacheStore, buildQueryKey, hashParams, queryCachePlugin, tagVersionKey, versionKey };

package/dist/{caching-GSDJcA6-.mjs → caching-BSXB-Xr7.mjs}

@@ -1,27 +1,6 @@
-import { t as __exportAll } from "./chunk-C7Uep-_p.mjs";
+import { t as __exportAll } from "./chunk-BpYLSNr0.mjs";
 import fp from "fastify-plugin";
-
 //#region src/plugins/caching.ts
-/**
-* Caching Plugin
-*
-* Adds ETag and Cache-Control headers to GET/HEAD responses.
-* Supports conditional requests (304 Not Modified) for bandwidth savings.
-*
-* @example
-* import { cachingPlugin } from '@classytic/arc/plugins';
-*
-* // Basic — ETag + conditional requests, no browser caching
-* await fastify.register(cachingPlugin);
-*
-* // With cache rules per path
-* await fastify.register(cachingPlugin, {
-*   rules: [
-*     { match: '/api/products', maxAge: 60 },
-*     { match: '/api/categories', maxAge: 300, staleWhileRevalidate: 60 },
-*   ],
-* });
-*/
 var caching_exports = /* @__PURE__ */ __exportAll({
 	cachingPlugin: () => cachingPlugin,
 	default: () => caching_default
@@ -88,6 +67,5 @@ var caching_default = fp(cachingPlugin, {
 	name: "arc-caching",
 	fastify: "5.x"
 });
-
 //#endregion
-export { caching_default as n, caching_exports as r, cachingPlugin as t };
+export { caching_default as n, caching_exports as r, cachingPlugin as t };

package/dist/chunk-BpYLSNr0.mjs

@@ -0,0 +1,14 @@
+import "node:module";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+export { __exportAll as t };

package/dist/circuitBreaker-BOBOpN2w.mjs

@@ -0,0 +1,284 @@
+//#region src/utils/circuitBreaker.ts
+/**
+* Circuit Breaker Pattern
+*
+* Wraps external service calls with failure protection.
+* Prevents cascading failures by "opening" the circuit when
+* a service is failing, allowing it time to recover.
+*
+* States:
+* - CLOSED: Normal operation, requests pass through
+* - OPEN: Too many failures, all requests fail fast
+* - HALF_OPEN: Testing if service recovered, limited requests
+*
+* @example
+* import { CircuitBreaker } from '@classytic/arc/utils';
+*
+* const paymentBreaker = new CircuitBreaker(async (amount) => {
+*   return await stripe.charges.create({ amount });
+* }, {
+*   failureThreshold: 5,
+*   resetTimeout: 30000,
+*   timeout: 5000,
+* });
+*
+* try {
+*   const result = await paymentBreaker.call(100);
+* } catch (error) {
+*   // Handle failure or circuit open
+* }
+*/
+const CircuitState = {
+	CLOSED: "CLOSED",
+	OPEN: "OPEN",
+	HALF_OPEN: "HALF_OPEN"
+};
+var CircuitBreakerError = class extends Error {
+	state;
+	constructor(message, state) {
+		super(message);
+		this.name = "CircuitBreakerError";
+		this.state = state;
+	}
+};
+var CircuitBreaker = class {
+	state = CircuitState.CLOSED;
+	failures = 0;
+	successes = 0;
+	totalCalls = 0;
+	nextAttempt = 0;
+	lastCallAt = null;
+	openedAt = null;
+	failureThreshold;
+	resetTimeout;
+	timeout;
+	successThreshold;
+	fallback;
+	onStateChange;
+	onError;
+	name;
+	fn;
+	constructor(fn, options = {}) {
+		this.fn = fn;
+		this.failureThreshold = options.failureThreshold ?? 5;
+		this.resetTimeout = options.resetTimeout ?? 6e4;
+		this.timeout = options.timeout ?? 1e4;
+		this.successThreshold = options.successThreshold ?? 1;
+		this.fallback = options.fallback;
+		this.onStateChange = options.onStateChange;
+		this.onError = options.onError;
+		this.name = options.name ?? "CircuitBreaker";
+	}
+	/**
+	* Call the wrapped function with circuit breaker protection
+	*/
+	async call(...args) {
+		this.totalCalls++;
+		this.lastCallAt = Date.now();
+		if (this.state === CircuitState.OPEN) {
+			if (Date.now() < this.nextAttempt) {
+				const error = new CircuitBreakerError(`Circuit breaker is OPEN for ${this.name}`, CircuitState.OPEN);
+				if (this.fallback) return this.fallback(...args);
+				throw error;
+			}
+			this.setState(CircuitState.HALF_OPEN);
+		}
+		try {
+			const result = await this.executeWithTimeout(args);
+			this.onSuccess();
+			return result;
+		} catch (err) {
+			this.onFailure(err instanceof Error ? err : new Error(String(err)));
+			throw err;
+		}
+	}
+	/**
+	* Execute function with timeout
+	*/
+	async executeWithTimeout(args) {
+		return new Promise((resolve, reject) => {
+			const timeoutId = setTimeout(() => {
+				reject(/* @__PURE__ */ new Error(`Request timeout after ${this.timeout}ms`));
+			}, this.timeout);
+			this.fn(...args).then((result) => {
+				clearTimeout(timeoutId);
+				resolve(result);
+			}).catch((error) => {
+				clearTimeout(timeoutId);
+				reject(error);
+			});
+		});
+	}
+	/**
+	* Handle successful call
+	*/
+	onSuccess() {
+		this.failures = 0;
+		this.successes++;
+		if (this.state === CircuitState.HALF_OPEN) {
+			if (this.successes >= this.successThreshold) {
+				this.setState(CircuitState.CLOSED);
+				this.successes = 0;
+			}
+		}
+	}
+	/**
+	* Handle failed call
+	*/
+	onFailure(error) {
+		this.failures++;
+		this.successes = 0;
+		if (this.onError) this.onError(error);
+		if (this.state === CircuitState.HALF_OPEN || this.failures >= this.failureThreshold) {
+			this.setState(CircuitState.OPEN);
+			this.nextAttempt = Date.now() + this.resetTimeout;
+			this.openedAt = Date.now();
+		}
+	}
+	/**
+	* Change circuit state
+	*/
+	setState(newState) {
+		const oldState = this.state;
+		if (oldState !== newState) {
+			this.state = newState;
+			if (this.onStateChange) this.onStateChange(oldState, newState);
+		}
+	}
+	/**
+	* Manually open the circuit
+	*/
+	open() {
+		this.setState(CircuitState.OPEN);
+		this.nextAttempt = Date.now() + this.resetTimeout;
+		this.openedAt = Date.now();
+	}
+	/**
+	* Manually close the circuit
+	*/
+	close() {
+		this.failures = 0;
+		this.successes = 0;
+		this.setState(CircuitState.CLOSED);
+		this.openedAt = null;
+	}
+	/**
+	* Get current statistics
+	*/
+	getStats() {
+		return {
+			name: this.name,
+			state: this.state,
+			failures: this.failures,
+			successes: this.successes,
+			totalCalls: this.totalCalls,
+			openedAt: this.openedAt,
+			lastCallAt: this.lastCallAt
+		};
+	}
+	/**
+	* Get current state
+	*/
+	getState() {
+		return this.state;
+	}
+	/**
+	* Check if circuit is open
+	*/
+	isOpen() {
+		return this.state === CircuitState.OPEN;
+	}
+	/**
+	* Check if circuit is closed
+	*/
+	isClosed() {
+		return this.state === CircuitState.CLOSED;
+	}
+	/**
+	* Reset statistics
+	*/
+	reset() {
+		this.failures = 0;
+		this.successes = 0;
+		this.totalCalls = 0;
+		this.lastCallAt = null;
+		this.openedAt = null;
+		this.setState(CircuitState.CLOSED);
+	}
+};
+/**
+* Create a circuit breaker with sensible defaults
+*
+* @example
+* const emailBreaker = createCircuitBreaker(
+*   async (to, subject, body) => sendEmail(to, subject, body),
+*   { name: 'email-service' }
+* );
+*/
+function createCircuitBreaker(fn, options) {
+	return new CircuitBreaker(fn, options);
+}
+/**
+* Circuit breaker registry for managing multiple breakers
+*/
+var CircuitBreakerRegistry = class {
+	breakers = /* @__PURE__ */ new Map();
+	/**
+	* Register a circuit breaker
+	*/
+	register(name, fn, options) {
+		const breaker = new CircuitBreaker(fn, {
+			...options,
+			name
+		});
+		this.breakers.set(name, breaker);
+		return breaker;
+	}
+	/**
+	* Get a circuit breaker by name
+	*/
+	get(name) {
+		return this.breakers.get(name);
+	}
+	/**
+	* Get all breakers
+	*/
+	getAll() {
+		return this.breakers;
+	}
+	/**
+	* Get statistics for all breakers
+	*/
+	getAllStats() {
+		const stats = {};
+		for (const [name, breaker] of this.breakers.entries()) stats[name] = breaker.getStats();
+		return stats;
+	}
+	/**
+	* Reset all breakers
+	*/
+	resetAll() {
+		for (const breaker of this.breakers.values()) breaker.reset();
+	}
+	/**
+	* Open all breakers
+	*/
+	openAll() {
+		for (const breaker of this.breakers.values()) breaker.open();
+	}
+	/**
+	* Close all breakers
+	*/
+	closeAll() {
+		for (const breaker of this.breakers.values()) breaker.close();
+	}
+};
+/**
+* Create a new CircuitBreakerRegistry instance.
+* Use this instead of a global singleton — attach to fastify.arc or pass explicitly.
+*/
+function createCircuitBreakerRegistry() {
+	return new CircuitBreakerRegistry();
+}
+//#endregion
+export { createCircuitBreaker as a, CircuitState as i, CircuitBreakerError as n, createCircuitBreakerRegistry as o, CircuitBreakerRegistry as r, CircuitBreaker as t };

package/dist/circuitBreaker-JP2GdJ4b.d.mts

@@ -0,0 +1,206 @@
+//#region src/utils/circuitBreaker.d.ts
+/**
+ * Circuit Breaker Pattern
+ *
+ * Wraps external service calls with failure protection.
+ * Prevents cascading failures by "opening" the circuit when
+ * a service is failing, allowing it time to recover.
+ *
+ * States:
+ * - CLOSED: Normal operation, requests pass through
+ * - OPEN: Too many failures, all requests fail fast
+ * - HALF_OPEN: Testing if service recovered, limited requests
+ *
+ * @example
+ * import { CircuitBreaker } from '@classytic/arc/utils';
+ *
+ * const paymentBreaker = new CircuitBreaker(async (amount) => {
+ *   return await stripe.charges.create({ amount });
+ * }, {
+ *   failureThreshold: 5,
+ *   resetTimeout: 30000,
+ *   timeout: 5000,
+ * });
+ *
+ * try {
+ *   const result = await paymentBreaker.call(100);
+ * } catch (error) {
+ *   // Handle failure or circuit open
+ * }
+ */
+declare const CircuitState: {
+  readonly CLOSED: "CLOSED";
+  readonly OPEN: "OPEN";
+  readonly HALF_OPEN: "HALF_OPEN";
+};
+type CircuitState = (typeof CircuitState)[keyof typeof CircuitState];
+interface CircuitBreakerOptions {
+  /**
+   * Number of failures before opening circuit
+   * @default 5
+   */
+  failureThreshold?: number;
+  /**
+   * Time in ms before attempting to close circuit
+   * @default 60000 (60 seconds)
+   */
+  resetTimeout?: number;
+  /**
+   * Request timeout in ms
+   * @default 10000 (10 seconds)
+   */
+  timeout?: number;
+  /**
+   * Number of successful requests in HALF_OPEN before closing
+   * @default 1
+   */
+  successThreshold?: number;
+  /**
+   * Fallback function when circuit is open.
+   * Receives the same arguments as the wrapped function.
+   */
+  fallback?: (...args: unknown[]) => Promise<unknown>;
+  /**
+   * Callback when state changes
+   */
+  onStateChange?: (from: CircuitState, to: CircuitState) => void;
+  /**
+   * Callback on error
+   */
+  onError?: (error: Error) => void;
+  /**
+   * Name for logging/monitoring
+   */
+  name?: string;
+}
+interface CircuitBreakerStats {
+  name?: string;
+  state: CircuitState;
+  failures: number;
+  successes: number;
+  totalCalls: number;
+  openedAt: number | null;
+  lastCallAt: number | null;
+}
+declare class CircuitBreakerError extends Error {
+  state: CircuitState;
+  constructor(message: string, state: CircuitState);
+}
+declare class CircuitBreaker<T extends (...args: any[]) => Promise<any>> {
+  private state;
+  private failures;
+  private successes;
+  private totalCalls;
+  private nextAttempt;
+  private lastCallAt;
+  private openedAt;
+  private readonly failureThreshold;
+  private readonly resetTimeout;
+  private readonly timeout;
+  private readonly successThreshold;
+  private readonly fallback?;
+  private readonly onStateChange?;
+  private readonly onError?;
+  private readonly name;
+  private readonly fn;
+  constructor(fn: T, options?: CircuitBreakerOptions);
+  /**
+   * Call the wrapped function with circuit breaker protection
+   */
+  call(...args: Parameters<T>): Promise<ReturnType<T>>;
+  /**
+   * Execute function with timeout
+   */
+  private executeWithTimeout;
+  /**
+   * Handle successful call
+   */
+  private onSuccess;
+  /**
+   * Handle failed call
+   */
+  private onFailure;
+  /**
+   * Change circuit state
+   */
+  private setState;
+  /**
+   * Manually open the circuit
+   */
+  open(): void;
+  /**
+   * Manually close the circuit
+   */
+  close(): void;
+  /**
+   * Get current statistics
+   */
+  getStats(): CircuitBreakerStats;
+  /**
+   * Get current state
+   */
+  getState(): CircuitState;
+  /**
+   * Check if circuit is open
+   */
+  isOpen(): boolean;
+  /**
+   * Check if circuit is closed
+   */
+  isClosed(): boolean;
+  /**
+   * Reset statistics
+   */
+  reset(): void;
+}
+/**
+ * Create a circuit breaker with sensible defaults
+ *
+ * @example
+ * const emailBreaker = createCircuitBreaker(
+ *   async (to, subject, body) => sendEmail(to, subject, body),
+ *   { name: 'email-service' }
+ * );
+ */
+declare function createCircuitBreaker<T extends (...args: any[]) => Promise<any>>(fn: T, options?: CircuitBreakerOptions): CircuitBreaker<T>;
+/**
+ * Circuit breaker registry for managing multiple breakers
+ */
+declare class CircuitBreakerRegistry {
+  private breakers;
+  /**
+   * Register a circuit breaker
+   */
+  register<T extends (...args: any[]) => Promise<any>>(name: string, fn: T, options?: Omit<CircuitBreakerOptions, "name">): CircuitBreaker<T>;
+  /**
+   * Get a circuit breaker by name
+   */
+  get(name: string): CircuitBreaker<any> | undefined;
+  /**
+   * Get all breakers
+   */
+  getAll(): Map<string, CircuitBreaker<any>>;
+  /**
+   * Get statistics for all breakers
+   */
+  getAllStats(): Record<string, CircuitBreakerStats>;
+  /**
+   * Reset all breakers
+   */
+  resetAll(): void;
+  /**
+   * Open all breakers
+   */
+  openAll(): void;
+  /**
+   * Close all breakers
+   */
+  closeAll(): void;
+}
+/**
+ * Create a new CircuitBreakerRegistry instance.
+ * Use this instead of a global singleton — attach to fastify.arc or pass explicitly.
+ */
+declare function createCircuitBreakerRegistry(): CircuitBreakerRegistry;
+//#endregion
+export { CircuitBreakerStats as a, createCircuitBreakerRegistry as c, CircuitBreakerRegistry as i, CircuitBreakerError as n, CircuitState as o, CircuitBreakerOptions as r, createCircuitBreaker as s, CircuitBreaker as t };

package/dist/cli/commands/describe.mjs

@@ -1,7 +1,6 @@
-import { t as CRUD_OPERATIONS } from "../../constants-DdXFXQtN.mjs";
+import { t as CRUD_OPERATIONS } from "../../constants-Cxde4rpC.mjs";
 import { resolve } from "node:path";
 import { pathToFileURL } from "node:url";
-
 //#region src/cli/commands/describe.ts
 /**
 * Arc CLI - Describe Command
@@ -144,7 +143,8 @@ function describeEvents(resourceName, events) {
 	return Object.entries(events).map(([action, def]) => ({
 		name: `${resourceName}:${action}`,
 		description: def.description,
-		hasSchema: !!def.schema
+		hasSchema: !!def.schema,
+		hasHandler: !!def.handler
 	}));
 }
 function describeMiddlewares(middlewares) {
@@ -179,7 +179,7 @@ async function describe(args) {
 	try {
 		const flags = new Set(args.filter((a) => a.startsWith("--")));
 		const positional = args.filter((a) => !a.startsWith("--"));
-		const pretty = flags.has("--pretty") || !flags.has("--json");
+		const pretty = flags.has("--pretty") || !flags.has("--json") && (process.stdout.isTTY ?? true);
 		const filterResource = positional[1];
 		const entryPath = positional[0];
 		if (!entryPath) {
@@ -196,11 +196,18 @@ async function describe(args) {
 		}
 		const entryModule = await import(pathToFileURL(resolve(process.cwd(), entryPath)).href);
 		const resources = [];
+		let eventRegistry;
 		function tryCollect(value) {
 			if (value && typeof value === "object" && "name" in value && "_registryMeta" in value && "toPlugin" in value) resources.push(value);
 		}
+		function tryCollectRegistry(value) {
+			if (value && typeof value === "object" && "catalog" in value && "register" in value && "validate" in value && typeof value.catalog === "function") eventRegistry = value;
+		}
 		for (const exported of Object.values(entryModule)) if (Array.isArray(exported)) exported.forEach(tryCollect);
-		else tryCollect(exported);
+		else {
+			tryCollect(exported);
+			tryCollectRegistry(exported);
+		}
 		if (resources.length === 0) throw new Error("No resource definitions found in entry file.\nMake sure your file exports defineResource() results:\n  export const productResource = defineResource({ ... });");
 		const filtered = filterResource ? resources.filter((r) => r.name === filterResource) : resources;
 		if (filterResource && filtered.length === 0) throw new Error(`Resource '${filterResource}' not found.\nAvailable: ${resources.map((r) => r.name).join(", ")}`);
@@ -213,14 +220,25 @@ async function describe(args) {
 			if (res.pipeline) totalPipelineSteps += res.pipeline.guards.length + res.pipeline.transforms.length + res.pipeline.interceptors.length;
 			if (res.fields) totalFields += Object.keys(res.fields).length;
 		}
+		let eventCatalog;
+		if (eventRegistry) eventCatalog = eventRegistry.catalog().map((e) => ({
+			name: e.name,
+			version: e.version,
+			description: e.description,
+			hasSchema: !!e.schema,
+			schemaFields: e.schema?.properties ? Object.keys(e.schema.properties) : [],
+			requiredFields: e.schema?.required ?? []
+		}));
 		const output = {
 			$schema: "arc-describe/v1",
 			generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
 			resources: described,
+			...eventCatalog?.length ? { eventCatalog } : {},
 			stats: {
 				totalResources: described.length,
 				totalRoutes: described.reduce((sum, r) => sum + r.routes.length, 0),
 				totalEvents: described.reduce((sum, r) => sum + r.events.length, 0),
+				totalCatalogedEvents: eventCatalog?.length ?? 0,
 				totalFields,
 				presetUsage: presetCounts,
 				pipelineSteps: totalPipelineSteps
@@ -233,6 +251,5 @@ async function describe(args) {
 		throw new Error(String(error));
 	}
 }
-
 //#endregion
-export { describe as default, describe };
+export { describe as default, describe };