@classytic/arc 1.1.0 → 2.1.3

package/dist/plugins/response-cache.d.mts

@@ -0,0 +1,87 @@
+import { FastifyPluginAsync, FastifyRequest } from "fastify";
+
+//#region src/plugins/response-cache.d.ts
+interface ResponseCacheRule {
+  /** Path prefix to match (e.g., '/api/products') */
+  match: string;
+  /** TTL in seconds for this path (0 = don't cache) */
+  ttl: number;
+}
+interface ResponseCacheOptions {
+  /** Maximum number of cached entries (default: 500). LRU eviction when exceeded. */
+  maxEntries?: number;
+  /** Default TTL in seconds (default: 30). Set to 0 to require explicit rules. */
+  defaultTTL?: number;
+  /** Per-path cache rules */
+  rules?: ResponseCacheRule[];
+  /** Paths to exclude from caching (prefix match) */
+  exclude?: string[];
+  /** HTTP methods that trigger cache invalidation (default: POST, PUT, PATCH, DELETE) */
+  invalidateOn?: string[];
+  /** Whether to add X-Cache header (HIT/MISS) to responses (default: true) */
+  xCacheHeader?: boolean;
+  /** Enable stats endpoint at this path (default: null = disabled) */
+  statsPath?: string | null;
+  /** Custom cache key function (default: method + url + userId + orgId) */
+  keyFn?: (request: FastifyRequest) => string | null;
+  /**
+   * Auto-invalidate cache entries when CRUD domain events fire (requires eventPlugin).
+   *
+   * - `true`: Invalidate resource prefix on its own CRUD events
+   * - `{ patterns: { 'order.*': ['/api/products'] } }`: Cross-resource invalidation rules
+   * - `false` / omitted: Disabled (default)
+   *
+   * @example
+   * ```typescript
+   * await fastify.register(responseCachePlugin, {
+   *   eventInvalidation: {
+   *     patterns: {
+   *       'order.*': ['/api/products', '/api/inventory'],
+   *     },
+   *   },
+   * });
+   * ```
+   */
+  eventInvalidation?: boolean | {
+    patterns?: Record<string, string[]>;
+  };
+}
+interface ResponseCacheStats {
+  entries: number;
+  maxEntries: number;
+  hits: number;
+  misses: number;
+  hitRate: number;
+  evictions: number;
+}
+declare module "fastify" {
+  interface FastifyInstance {
+    responseCache: {
+      /** Invalidate all cached responses matching a path prefix */invalidate: (pathPrefix: string) => number; /** Clear the entire cache */
+      invalidateAll: () => void; /** Get cache statistics */
+      stats: () => ResponseCacheStats;
+      /**
+       * Route-level preHandler for cache lookup.
+       * Wire AFTER authenticate in the preHandler chain so that
+       * `request.user` / `request.scope` are populated before the
+       * cache key is computed.
+       *
+       * `createCrudRouter` injects this automatically for GET routes.
+       * For custom routes, add it manually:
+       * ```typescript
+       * fastify.get('/data', {
+       *   preHandler: [fastify.authenticate, fastify.responseCache.middleware],
+       * }, handler);
+       * ```
+       */
+      middleware: (request: FastifyRequest, reply: FastifyReply) => Promise<void>;
+    };
+  }
+  interface FastifyRequest {
+    /** @internal Cache TTL in seconds — set by onRequest, consumed by middleware + onSend */
+    __arcCacheTTL?: number;
+  }
+}
+declare const responseCachePlugin: FastifyPluginAsync<ResponseCacheOptions>;
+//#endregion
+export { ResponseCacheOptions, ResponseCacheRule, ResponseCacheStats, responseCachePlugin as default, responseCachePlugin };

package/dist/plugins/response-cache.mjs

@@ -0,0 +1,283 @@
+import { t as hasEvents } from "../typeGuards-DwxA1t_L.mjs";
+import fp from "fastify-plugin";
+
+//#region src/plugins/response-cache.ts
+/**
+* Response Cache Plugin for Arc
+*
+* In-memory LRU/TTL response cache that sits in front of your database.
+* Caches serialized responses for GET requests, dramatically reducing DB load
+* for frequently accessed resources.
+*
+* Features:
+* - LRU eviction with configurable max entries
+* - Per-route TTL configuration
+* - Automatic invalidation on mutations (POST/PUT/PATCH/DELETE)
+* - Manual invalidation via `fastify.responseCache.invalidate()`
+* - Cache stats endpoint for monitoring
+* - Zero external deps — pure in-memory, serverless-safe
+*
+* NOTE: This cache is per-instance (in-memory). In multi-instance deployments,
+* each instance maintains its own cache. For cross-instance invalidation,
+* wire `fastify.responseCache.invalidate()` to your event bus manually.
+*
+* ## Auth Safety
+*
+* The cache check runs as a **route-level middleware** (`responseCache.middleware`)
+* that must be wired AFTER authentication in the preHandler chain. Arc's
+* `createCrudRouter` does this automatically. For custom routes, wire it
+* manually:
+*
+* ```typescript
+* fastify.get('/data', {
+*   preHandler: [fastify.authenticate, fastify.responseCache.middleware],
+* }, handler);
+* ```
+*
+* This ensures cached responses are never served before auth validates the
+* caller's identity. The default cache key includes `userId` and `orgId`
+* to prevent cross-caller data leaks.
+*
+* This is a SEPARATE subpath import — only loaded when explicitly used:
+*   import { responseCachePlugin } from '@classytic/arc/plugins/response-cache';
+*
+* @example
+* ```typescript
+* import { responseCachePlugin } from '@classytic/arc/plugins/response-cache';
+*
+* await fastify.register(responseCachePlugin, {
+*   maxEntries: 1000,
+*   defaultTTL: 30,       // 30 seconds
+*   rules: [
+*     { match: '/api/products', ttl: 120 },         // 2 min for products
+*     { match: '/api/categories', ttl: 300 },        // 5 min for categories
+*     { match: '/api/users', ttl: 0 },               // never cache users
+*   ],
+*   invalidateOn: ['POST', 'PUT', 'PATCH', 'DELETE'],
+* });
+*
+* // Manual invalidation
+* fastify.responseCache.invalidate('/api/products');
+* fastify.responseCache.invalidateAll();
+*
+* // Stats
+* const stats = fastify.responseCache.stats();
+* // { entries: 42, hits: 1250, misses: 180, hitRate: 0.87, evictions: 5 }
+* ```
+*/
+/**
+* Simple LRU cache using Map iteration order.
+* Map in JS preserves insertion order — we re-insert on access to make it LRU.
+*/
+var LRUCache = class {
+	cache = /* @__PURE__ */ new Map();
+	maxEntries;
+	invalidatedPrefixes = /* @__PURE__ */ new Map();
+	hits = 0;
+	misses = 0;
+	evictions = 0;
+	constructor(maxEntries) {
+		this.maxEntries = maxEntries;
+	}
+	get(key) {
+		const entry = this.cache.get(key);
+		if (!entry) {
+			this.misses++;
+			return null;
+		}
+		if (Date.now() - entry.createdAt > entry.ttl) {
+			this.cache.delete(key);
+			this.misses++;
+			return null;
+		}
+		this.cache.delete(key);
+		this.cache.set(key, entry);
+		this.hits++;
+		return entry;
+	}
+	set(key, entry) {
+		if (this.isPrefixLocked(key)) return;
+		if (this.cache.has(key)) this.cache.delete(key);
+		while (this.cache.size >= this.maxEntries) {
+			const firstKey = this.cache.keys().next().value;
+			if (firstKey !== void 0) {
+				this.cache.delete(firstKey);
+				this.evictions++;
+			}
+		}
+		this.cache.set(key, entry);
+	}
+	/** Invalidate entries matching a path prefix and lock it from caching to allow DB replicas to catch up */
+	invalidatePrefix(prefix, jitterMs = 1500) {
+		let count = 0;
+		for (const key of this.cache.keys()) {
+			const colonIdx = key.indexOf(":");
+			if ((colonIdx >= 0 ? key.slice(colonIdx + 1) : key).split("?")[0].startsWith(prefix)) {
+				this.cache.delete(key);
+				count++;
+			}
+		}
+		if (jitterMs > 0) this.invalidatedPrefixes.set(prefix, Date.now() + jitterMs);
+		return count;
+	}
+	/** Check if a key falls under a recently invalidated prefix */
+	isPrefixLocked(key) {
+		if (this.invalidatedPrefixes.size === 0) return false;
+		const colonIdx = key.indexOf(":");
+		const pathOnly = (colonIdx >= 0 ? key.slice(colonIdx + 1) : key).split("?")[0];
+		const now = Date.now();
+		for (const [prefix, expiresAt] of this.invalidatedPrefixes.entries()) if (now > expiresAt) this.invalidatedPrefixes.delete(prefix);
+		else if (pathOnly.startsWith(prefix)) return true;
+		return false;
+	}
+	/** Clear all entries */
+	clear() {
+		this.cache.clear();
+	}
+	get size() {
+		return this.cache.size;
+	}
+	getStats(maxEntries) {
+		const total = this.hits + this.misses;
+		return {
+			entries: this.cache.size,
+			maxEntries,
+			hits: this.hits,
+			misses: this.misses,
+			hitRate: total > 0 ? Math.round(this.hits / total * 100) / 100 : 0,
+			evictions: this.evictions
+		};
+	}
+};
+const responseCachePluginImpl = async (fastify, opts = {}) => {
+	const { maxEntries = 500, defaultTTL = 30, rules = [], exclude = [], invalidateOn = [
+		"POST",
+		"PUT",
+		"PATCH",
+		"DELETE"
+	], xCacheHeader = true, statsPath = null, keyFn } = opts;
+	const cache = new LRUCache(maxEntries);
+	const invalidateMethods = new Set(invalidateOn.map((m) => m.toUpperCase()));
+	/** Find TTL for a given URL path (seconds) */
+	function getTTL(url) {
+		const path = url.split("?")[0];
+		for (const rule of rules) if (path.startsWith(rule.match)) return rule.ttl;
+		return defaultTTL;
+	}
+	/** Check if a URL should be excluded */
+	function isExcluded(url) {
+		return exclude.some((p) => url.startsWith(p));
+	}
+	/** Build cache key — includes user/org scope by default to prevent cross-caller leaks */
+	function buildKey(request) {
+		if (keyFn) return keyFn(request);
+		const user = request.user;
+		const userId = user?.id ?? user?._id ?? "anon";
+		const orgId = request.scope?.organizationId ?? "no-org";
+		return `${request.method}:${request.url}:u=${userId}:o=${orgId}`;
+	}
+	fastify.addHook("onRequest", async (request) => {
+		if (request.method !== "GET" && request.method !== "HEAD") return;
+		if (isExcluded(request.url)) return;
+		const ttl = getTTL(request.url);
+		if (ttl <= 0) return;
+		request.__arcCacheTTL = ttl;
+	});
+	fastify.addHook("onResponse", async (request, reply) => {
+		if (!invalidateMethods.has(request.method.toUpperCase())) return;
+		const statusCode = reply.statusCode;
+		if (statusCode < 200 || statusCode >= 300) return;
+		const path = request.url.split("?")[0];
+		const segments = path.split("/").filter(Boolean);
+		const lastSegment = segments[segments.length - 1];
+		if (segments.length >= 2 && lastSegment != null && /^[0-9a-f]{8,}$|^\d+$/.test(lastSegment)) {
+			const resourceRoot = "/" + segments.slice(0, -1).join("/");
+			cache.invalidatePrefix(resourceRoot);
+			cache.invalidatePrefix(path);
+		} else cache.invalidatePrefix(path);
+	});
+	const cacheMiddleware = async (request, reply) => {
+		const ttl = request.__arcCacheTTL;
+		if (!ttl || ttl <= 0) return;
+		if (request.method !== "GET" && request.method !== "HEAD") return;
+		const key = buildKey(request);
+		if (!key) return;
+		const entry = cache.get(key);
+		if (!entry) return;
+		if (xCacheHeader) reply.header("x-cache", "HIT");
+		for (const [name, value] of Object.entries(entry.headers)) reply.header(name, value);
+		request.__arcCacheTTL = 0;
+		reply.code(entry.statusCode).send(entry.body);
+	};
+	fastify.addHook("onSend", async (request, reply, payload) => {
+		const ttl = request.__arcCacheTTL;
+		if (!ttl || ttl <= 0) return payload;
+		if (request.method !== "GET" && request.method !== "HEAD") return payload;
+		const statusCode = reply.statusCode;
+		if (statusCode < 200 || statusCode >= 300) return payload;
+		const key = buildKey(request);
+		if (!key) return payload;
+		if (xCacheHeader) reply.header("x-cache", "MISS");
+		let body;
+		if (typeof payload === "string") body = payload;
+		else if (Buffer.isBuffer(payload)) body = payload.toString("utf-8");
+		else if (payload != null) body = JSON.stringify(payload);
+		else body = "";
+		const headers = {};
+		const contentType = reply.getHeader("content-type");
+		if (contentType) headers["content-type"] = String(contentType);
+		const etag = reply.getHeader("etag");
+		if (etag) headers["etag"] = String(etag);
+		cache.set(key, {
+			body,
+			statusCode,
+			headers,
+			createdAt: Date.now(),
+			ttl: ttl * 1e3
+		});
+		return payload;
+	});
+	fastify.decorate("responseCache", {
+		invalidate: (pathPrefix) => cache.invalidatePrefix(pathPrefix),
+		invalidateAll: () => cache.clear(),
+		stats: () => cache.getStats(maxEntries),
+		middleware: cacheMiddleware
+	});
+	if (statsPath) fastify.get(statsPath, async () => {
+		return cache.getStats(maxEntries);
+	});
+	const evtInv = opts.eventInvalidation;
+	if (evtInv && hasEvents(fastify)) {
+		const crossResourcePatterns = typeof evtInv === "object" ? evtInv.patterns ?? {} : {};
+		fastify.events.subscribe("*", async (event) => {
+			const parts = event.type.split(".");
+			if (parts.length !== 2) return;
+			const [resource, action] = parts;
+			if (!resource || ![
+				"created",
+				"updated",
+				"deleted"
+			].includes(action)) return;
+			cache.invalidatePrefix(`/${resource}s`);
+			cache.invalidatePrefix(`/${resource}`);
+			for (const [pattern, prefixes] of Object.entries(crossResourcePatterns)) if (eventMatchesPattern(event.type, pattern)) for (const prefix of prefixes) cache.invalidatePrefix(prefix);
+		}).catch((err) => {
+			fastify.log?.warn?.({ err }, "Response cache: failed to subscribe to events for invalidation");
+		});
+		fastify.log?.debug?.("Response cache: event-driven invalidation enabled");
+	} else if (evtInv) fastify.log?.warn?.("Response cache: eventInvalidation enabled but eventPlugin not registered.");
+	fastify.log?.debug?.(`Response cache: registered (max=${maxEntries}, defaultTTL=${defaultTTL}s, rules=${rules.length})`);
+};
+/** Check if an event type matches a pattern (supports wildcards) */
+function eventMatchesPattern(type, pattern) {
+	if (pattern === "*") return true;
+	if (pattern.endsWith(".*")) return type.startsWith(pattern.slice(0, -1));
+	return type === pattern;
+}
+const responseCachePlugin = fp(responseCachePluginImpl, {
+	name: "arc-response-cache",
+	fastify: "5.x"
+});
+
+//#endregion
+export { responseCachePlugin as default, responseCachePlugin };

package/dist/plugins/tracing-entry.d.mts

@@ -0,0 +1,2 @@
+import { a as traced, i as isTracingAvailable, n as _default, r as createSpan, t as TracingOptions } from "../tracing-8CEbhF0w.mjs";
+export { type TracingOptions, createSpan, isTracingAvailable, traced, _default as tracingPlugin };

package/dist/plugins/tracing-entry.mjs

@@ -0,0 +1,185 @@
+import { createRequire } from "node:module";
+import fp from "fastify-plugin";
+
+//#region src/plugins/tracing.ts
+const require = createRequire(import.meta.url);
+let trace;
+let context;
+let SpanStatusCode;
+let NodeTracerProvider;
+let BatchSpanProcessor;
+let OTLPTraceExporter;
+let getNodeAutoInstrumentations;
+let isAvailable = false;
+try {
+	const api = require("@opentelemetry/api");
+	trace = api.trace;
+	context = api.context;
+	SpanStatusCode = api.SpanStatusCode;
+	const sdkNode = require("@opentelemetry/sdk-node");
+	NodeTracerProvider = sdkNode.NodeTracerProvider;
+	BatchSpanProcessor = sdkNode.BatchSpanProcessor;
+	OTLPTraceExporter = require("@opentelemetry/exporter-trace-otlp-http").OTLPTraceExporter;
+	require("@opentelemetry/instrumentation-http").HttpInstrumentation;
+	require("@opentelemetry/instrumentation-mongodb").MongoDBInstrumentation;
+	getNodeAutoInstrumentations = require("@opentelemetry/auto-instrumentations-node").getNodeAutoInstrumentations;
+	isAvailable = true;
+} catch (e) {}
+/**
+* Create a tracer provider
+*/
+function createTracerProvider(options) {
+	if (!isAvailable) return null;
+	const { serviceName = "@classytic/arc", exporterUrl = "http://localhost:4318/v1/traces" } = options;
+	const exporter = new OTLPTraceExporter({ url: exporterUrl });
+	const provider = new NodeTracerProvider({ resource: { attributes: {
+		"service.name": serviceName,
+		"service.version": "1.0.0"
+	} } });
+	provider.addSpanProcessor(new BatchSpanProcessor(exporter));
+	provider.register();
+	return provider;
+}
+/**
+* OpenTelemetry Distributed Tracing Plugin
+*/
+async function tracingPlugin(fastify, options = {}) {
+	const { serviceName = "@classytic/arc", autoInstrumentation = true, sampleRate = 1 } = options;
+	if (!isAvailable) {
+		fastify.log.warn("OpenTelemetry not installed. Tracing disabled.");
+		fastify.log.warn("Install: npm install @opentelemetry/api @opentelemetry/sdk-node");
+		return;
+	}
+	if (!createTracerProvider(options)) return;
+	if (autoInstrumentation && getNodeAutoInstrumentations) {
+		const instrumentations = getNodeAutoInstrumentations({
+			"@opentelemetry/instrumentation-http": { enabled: true },
+			"@opentelemetry/instrumentation-mongodb": { enabled: true }
+		});
+		for (const instrumentation of instrumentations) instrumentation.enable();
+		fastify.log.debug("OpenTelemetry auto-instrumentation enabled");
+	}
+	const tracer = trace.getTracer(serviceName);
+	fastify.decorateRequest("tracer", void 0);
+	fastify.addHook("onRequest", async (request, reply) => {
+		if (Math.random() > sampleRate) return;
+		const span = tracer.startSpan(`HTTP ${request.method} ${request.url}`, {
+			kind: 1,
+			attributes: {
+				"http.method": request.method,
+				"http.url": request.url,
+				"http.target": request.routeOptions?.url ?? request.url,
+				"http.host": request.hostname,
+				"http.scheme": request.protocol,
+				"http.user_agent": request.headers["user-agent"]
+			}
+		});
+		request.tracer = {
+			tracer,
+			currentSpan: span
+		};
+		context.with(trace.setSpan(context.active(), span), () => {});
+	});
+	fastify.addHook("onResponse", async (request, reply) => {
+		if (!request.tracer?.currentSpan) return;
+		const span = request.tracer.currentSpan;
+		span.setAttributes({
+			"http.status_code": reply.statusCode,
+			"http.response_content_length": reply.getHeader("content-length")
+		});
+		if (reply.statusCode >= 500) span.setStatus({
+			code: SpanStatusCode.ERROR,
+			message: `HTTP ${reply.statusCode}`
+		});
+		else span.setStatus({ code: SpanStatusCode.OK });
+		span.end();
+	});
+	fastify.addHook("onError", async (request, reply, error) => {
+		if (!request.tracer?.currentSpan) return;
+		const span = request.tracer.currentSpan;
+		span.recordException(error);
+		span.setStatus({
+			code: SpanStatusCode.ERROR,
+			message: error.message
+		});
+	});
+	fastify.log.debug({ serviceName }, "OpenTelemetry tracing enabled");
+}
+/**
+* Utility to create custom spans in your code
+*
+* @example
+* import { createSpan } from '@classytic/arc/plugins';
+*
+* async function expensiveOperation(req) {
+*   return createSpan(req, 'expensiveOperation', async (span) => {
+*     span.setAttribute('custom.attribute', 'value');
+*     return await doWork();
+*   });
+* }
+*/
+function createSpan(request, name, fn, attributes) {
+	if (!isAvailable || !request.tracer) return fn(null);
+	const { tracer, currentSpan } = request.tracer;
+	const span = tracer.startSpan(name, {
+		parent: currentSpan,
+		attributes: attributes || {}
+	}, trace.setSpan(context.active(), currentSpan));
+	return context.with(trace.setSpan(context.active(), span), async () => {
+		try {
+			const result = await fn(span);
+			span.setStatus({ code: SpanStatusCode.OK });
+			return result;
+		} catch (error) {
+			span.recordException(error);
+			span.setStatus({
+				code: SpanStatusCode.ERROR,
+				message: error.message
+			});
+			throw error;
+		} finally {
+			span.end();
+		}
+	});
+}
+/**
+* Decorator to automatically trace repository methods
+*
+* @example
+* class ProductRepository extends Repository {
+*   @traced()
+*   async findActive() {
+*     return this.findAll({ filter: { isActive: true } });
+*   }
+* }
+*/
+function traced(spanName) {
+	return function(target, propertyKey, descriptor) {
+		const originalMethod = descriptor.value;
+		descriptor.value = async function(...args) {
+			const request = args.find((arg) => arg && arg.tracer);
+			if (!request?.tracer) return originalMethod.apply(this, args);
+			return createSpan(request, spanName || `${target.constructor.name}.${propertyKey}`, async (span) => {
+				if (span) {
+					span.setAttribute("db.operation", propertyKey);
+					span.setAttribute("db.system", "mongodb");
+				}
+				return originalMethod.apply(this, args);
+			});
+		};
+		return descriptor;
+	};
+}
+/**
+* Check if OpenTelemetry is available
+*/
+function isTracingAvailable() {
+	return isAvailable;
+}
+var tracing_default = fp(tracingPlugin, {
+	name: "arc-tracing",
+	fastify: "5.x"
+});
+
+//#endregion
+export { createSpan, isTracingAvailable, traced, tracing_default as tracingPlugin };

package/dist/pluralize-CM-jZg7p.mjs

@@ -0,0 +1,86 @@
+//#region src/cli/utils/pluralize.ts
+/**
+* Lightweight English pluralization for the Arc CLI.
+*
+* Covers the common cases developers hit when naming resources:
+*   company  → companies
+*   category → categories
+*   status   → statuses
+*   address  → addresses
+*   person   → people
+*   child    → children
+*   bus      → buses
+*   box      → boxes
+*   quiz     → quizzes
+*   leaf     → leaves
+*   wolf     → wolves
+*
+* No external dependencies — designed to keep the CLI install-free.
+*/
+const IRREGULARS = {
+	person: "people",
+	child: "children",
+	man: "men",
+	woman: "women",
+	mouse: "mice",
+	goose: "geese",
+	tooth: "teeth",
+	foot: "feet",
+	ox: "oxen",
+	datum: "data",
+	medium: "media",
+	index: "indices",
+	matrix: "matrices",
+	vertex: "vertices",
+	criterion: "criteria"
+};
+const UNCOUNTABLES = new Set([
+	"sheep",
+	"fish",
+	"deer",
+	"series",
+	"species",
+	"money",
+	"rice",
+	"information",
+	"equipment",
+	"media",
+	"data"
+]);
+/**
+* Pluralize an English word.
+*
+* @param word - Singular noun (e.g. "company", "product", "person")
+* @returns Plural form (e.g. "companies", "products", "people")
+*/
+function pluralize(word) {
+	const lower = word.toLowerCase();
+	if (UNCOUNTABLES.has(lower)) return word;
+	if (IRREGULARS[lower]) {
+		const plural = IRREGULARS[lower];
+		return word[0] === word[0].toUpperCase() ? plural.charAt(0).toUpperCase() + plural.slice(1) : plural;
+	}
+	if (lower.endsWith("fe")) return word.slice(0, -2) + "ves";
+	if (lower.endsWith("f") && !lower.endsWith("ff") && !lower.endsWith("roof") && !lower.endsWith("chief") && !lower.endsWith("belief")) return word.slice(0, -1) + "ves";
+	if (lower.endsWith("y") && !/[aeiou]y$/i.test(lower)) return word.slice(0, -1) + "ies";
+	if (lower.endsWith("is")) return word.slice(0, -2) + "es";
+	if (new Set([
+		"cactus",
+		"stimulus",
+		"focus",
+		"fungus",
+		"nucleus",
+		"syllabus",
+		"radius",
+		"alumnus",
+		"terminus",
+		"bacillus"
+	]).has(lower)) return word.slice(0, -2) + "i";
+	if (lower.endsWith("z") && !lower.endsWith("zz")) return word + "zes";
+	if (/(?:s|sh|ch|x|zz)$/i.test(lower)) return word + "es";
+	if (lower.endsWith("o") && !/[aeiou]o$/i.test(lower)) return word + "es";
+	return word + "s";
+}
+
+//#endregion
+export { pluralize as t };