@momentumcms/plugins-core 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,3 @@
+## 0.1.0 (2026-02-16)
+
+This was a version bump only for plugins-core to align it with other projects, there were no code changes.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024-present Momentum CMS Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/index.cjs

@@ -0,0 +1,530 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// libs/plugins/core/src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  MomentumEventBus: () => MomentumEventBus,
+  PluginFatalError: () => PluginFatalError,
+  PluginRunner: () => PluginRunner,
+  eventBusPlugin: () => eventBusPlugin,
+  injectCollectionEventHooks: () => injectCollectionEventHooks
+});
+module.exports = __toCommonJS(src_exports);
+
+// libs/logger/src/lib/log-level.ts
+var LOG_LEVEL_VALUES = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+  fatal: 4,
+  silent: 5
+};
+function shouldLog(messageLevel, configuredLevel) {
+  return LOG_LEVEL_VALUES[messageLevel] >= LOG_LEVEL_VALUES[configuredLevel];
+}
+
+// libs/logger/src/lib/ansi-colors.ts
+var ANSI = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  // Foreground colors
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  white: "\x1B[37m",
+  gray: "\x1B[90m",
+  // Background colors
+  bgRed: "\x1B[41m",
+  bgYellow: "\x1B[43m"
+};
+function colorize(text, ...codes) {
+  if (codes.length === 0)
+    return text;
+  return `${codes.join("")}${text}${ANSI.reset}`;
+}
+function supportsColor() {
+  if (process.env["FORCE_COLOR"] === "1")
+    return true;
+  if (process.env["NO_COLOR"] !== void 0)
+    return false;
+  if (process.env["TERM"] === "dumb")
+    return false;
+  return process.stdout.isTTY === true;
+}
+
+// libs/logger/src/lib/formatters.ts
+var LEVEL_COLORS = {
+  debug: [ANSI.dim, ANSI.gray],
+  info: [ANSI.cyan],
+  warn: [ANSI.yellow],
+  error: [ANSI.red],
+  fatal: [ANSI.bold, ANSI.white, ANSI.bgRed]
+};
+function padLevel(level) {
+  return level.toUpperCase().padEnd(5);
+}
+function formatTimestamp(date) {
+  const y = date.getFullYear();
+  const mo = String(date.getMonth() + 1).padStart(2, "0");
+  const d = String(date.getDate()).padStart(2, "0");
+  const h = String(date.getHours()).padStart(2, "0");
+  const mi = String(date.getMinutes()).padStart(2, "0");
+  const s = String(date.getSeconds()).padStart(2, "0");
+  const ms = String(date.getMilliseconds()).padStart(3, "0");
+  return `${y}-${mo}-${d} ${h}:${mi}:${s}.${ms}`;
+}
+function formatData(data) {
+  const entries = Object.entries(data);
+  if (entries.length === 0)
+    return "";
+  return " " + entries.map(([k, v]) => `${k}=${typeof v === "string" ? v : JSON.stringify(v)}`).join(" ");
+}
+function prettyFormatter(entry) {
+  const useColor = supportsColor();
+  const level = entry.level;
+  const ts = formatTimestamp(entry.timestamp);
+  const levelStr = padLevel(entry.level);
+  const ctx = `[${entry.context}]`;
+  const msg = entry.message;
+  const enrichmentStr = entry.enrichments ? formatData(entry.enrichments) : "";
+  const dataStr = entry.data ? formatData(entry.data) : "";
+  const extra = `${enrichmentStr}${dataStr}`;
+  if (useColor) {
+    const colors = LEVEL_COLORS[level];
+    const coloredLevel = colorize(levelStr, ...colors);
+    const coloredCtx = colorize(ctx, ANSI.magenta);
+    const coloredTs = colorize(ts, ANSI.gray);
+    return `${coloredTs} ${coloredLevel} ${coloredCtx} ${msg}${extra}
+`;
+  }
+  return `${ts} ${levelStr} ${ctx} ${msg}${extra}
+`;
+}
+function jsonFormatter(entry) {
+  const output = {
+    timestamp: entry.timestamp.toISOString(),
+    level: entry.level,
+    context: entry.context,
+    message: entry.message
+  };
+  if (entry.enrichments && Object.keys(entry.enrichments).length > 0) {
+    Object.assign(output, entry.enrichments);
+  }
+  if (entry.data && Object.keys(entry.data).length > 0) {
+    output["data"] = entry.data;
+  }
+  return JSON.stringify(output) + "\n";
+}
+
+// libs/logger/src/lib/logger-config.types.ts
+function resolveLoggingConfig(config) {
+  return {
+    level: config?.level ?? "info",
+    format: config?.format ?? "pretty",
+    timestamps: config?.timestamps ?? true,
+    output: config?.output ?? ((msg) => {
+      process.stdout.write(msg);
+    }),
+    errorOutput: config?.errorOutput ?? ((msg) => {
+      process.stderr.write(msg);
+    })
+  };
+}
+
+// libs/logger/src/lib/logger.ts
+var ERROR_LEVELS = /* @__PURE__ */ new Set(["warn", "error", "fatal"]);
+var MomentumLogger = class _MomentumLogger {
+  static {
+    this.enrichers = [];
+  }
+  constructor(context, config) {
+    this.context = context;
+    this.config = isResolvedConfig(config) ? config : resolveLoggingConfig(config);
+    this.formatter = this.config.format === "json" ? jsonFormatter : prettyFormatter;
+  }
+  debug(message, data) {
+    this.log("debug", message, data);
+  }
+  info(message, data) {
+    this.log("info", message, data);
+  }
+  warn(message, data) {
+    this.log("warn", message, data);
+  }
+  error(message, data) {
+    this.log("error", message, data);
+  }
+  fatal(message, data) {
+    this.log("fatal", message, data);
+  }
+  /**
+   * Creates a child logger with a sub-context.
+   * e.g., `Momentum:DB` → `Momentum:DB:Migrate`
+   */
+  child(subContext) {
+    return new _MomentumLogger(`${this.context}:${subContext}`, this.config);
+  }
+  /**
+   * Registers a global enricher that adds extra fields to all log entries.
+   */
+  static registerEnricher(enricher) {
+    _MomentumLogger.enrichers.push(enricher);
+  }
+  /**
+   * Removes a previously registered enricher.
+   */
+  static removeEnricher(enricher) {
+    const index = _MomentumLogger.enrichers.indexOf(enricher);
+    if (index >= 0) {
+      _MomentumLogger.enrichers.splice(index, 1);
+    }
+  }
+  /**
+   * Clears all registered enrichers. Primarily for testing.
+   */
+  static clearEnrichers() {
+    _MomentumLogger.enrichers.length = 0;
+  }
+  log(level, message, data) {
+    if (!shouldLog(level, this.config.level))
+      return;
+    const enrichments = this.collectEnrichments();
+    const entry = {
+      timestamp: /* @__PURE__ */ new Date(),
+      level,
+      context: this.context,
+      message,
+      data,
+      enrichments: Object.keys(enrichments).length > 0 ? enrichments : void 0
+    };
+    const formatted = this.formatter(entry);
+    if (ERROR_LEVELS.has(level)) {
+      this.config.errorOutput(formatted);
+    } else {
+      this.config.output(formatted);
+    }
+  }
+  collectEnrichments() {
+    const result = {};
+    for (const enricher of _MomentumLogger.enrichers) {
+      Object.assign(result, enricher.enrich());
+    }
+    return result;
+  }
+};
+function isResolvedConfig(config) {
+  if (!config)
+    return false;
+  return typeof config.level === "string" && typeof config.format === "string" && typeof config.timestamps === "boolean" && // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- type guard narrows union
+  typeof config.output === "function" && // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- type guard narrows union
+  typeof config.errorOutput === "function";
+}
+
+// libs/logger/src/lib/logger-singleton.ts
+var loggerInstance = null;
+var ROOT_CONTEXT = "Momentum";
+function getMomentumLogger() {
+  if (!loggerInstance) {
+    loggerInstance = new MomentumLogger(ROOT_CONTEXT);
+  }
+  return loggerInstance;
+}
+function createLogger(context) {
+  return getMomentumLogger().child(context);
+}
+
+// libs/plugins/core/src/lib/plugin-fatal-error.ts
+var PluginFatalError = class extends Error {
+  constructor(pluginName, message) {
+    super(`[Plugin:${pluginName}] Fatal: ${message}`);
+    this.name = "PluginFatalError";
+    this.pluginName = pluginName;
+  }
+};
+
+// libs/plugins/core/src/lib/plugin-runner.ts
+var PluginRunner = class {
+  constructor(options) {
+    this.middlewareDescriptors = [];
+    this.providerDescriptors = [];
+    this.initialized = false;
+    this.ready = false;
+    this.plugins = options.plugins;
+    this.config = options.config;
+    this.collections = options.collections;
+    this.logger = createLogger("Plugins");
+  }
+  /**
+   * Create a plugin-scoped context.
+   */
+  createContext(plugin) {
+    return {
+      config: this.config,
+      collections: this.collections,
+      logger: this.logger.child(plugin.name),
+      registerMiddleware: (descriptor) => {
+        this.middlewareDescriptors.push(descriptor);
+      },
+      registerProvider: (descriptor) => {
+        this.providerDescriptors.push(descriptor);
+      }
+    };
+  }
+  /**
+   * Run onInit for all plugins (in order).
+   * Call this before API initialization.
+   */
+  async runInit() {
+    if (this.initialized) {
+      this.logger.warn("Plugins already initialized");
+      return;
+    }
+    for (const plugin of this.plugins) {
+      try {
+        if (plugin.onInit) {
+          this.logger.debug(`Initializing plugin: ${plugin.name}`);
+          await plugin.onInit(this.createContext(plugin));
+        }
+      } catch (error) {
+        if (error instanceof PluginFatalError) {
+          throw error;
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        this.logger.error(`Plugin "${plugin.name}" failed during onInit: ${message}`);
+      }
+    }
+    this.initialized = true;
+  }
+  /**
+   * Run onReady for all plugins (in order).
+   * Call this after API + seeding complete.
+   */
+  async runReady(api) {
+    if (this.ready) {
+      this.logger.warn("Plugins already marked ready");
+      return;
+    }
+    for (const plugin of this.plugins) {
+      try {
+        if (plugin.onReady) {
+          this.logger.debug(`Plugin ready: ${plugin.name}`);
+          const context = {
+            ...this.createContext(plugin),
+            api
+          };
+          await plugin.onReady(context);
+        }
+      } catch (error) {
+        if (error instanceof PluginFatalError) {
+          throw error;
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        this.logger.error(`Plugin "${plugin.name}" failed during onReady: ${message}`);
+      }
+    }
+    this.ready = true;
+  }
+  /**
+   * Run onShutdown for all plugins (in reverse order).
+   * Call this during graceful shutdown.
+   */
+  async runShutdown() {
+    const reversed = [...this.plugins].reverse();
+    for (const plugin of reversed) {
+      try {
+        if (plugin.onShutdown) {
+          this.logger.debug(`Shutting down plugin: ${plugin.name}`);
+          await plugin.onShutdown(this.createContext(plugin));
+        }
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        this.logger.error(`Plugin "${plugin.name}" failed during onShutdown: ${message}`);
+      }
+    }
+  }
+  /**
+   * Get the list of registered plugin names.
+   */
+  getPluginNames() {
+    return this.plugins.map((p) => p.name);
+  }
+  /**
+   * Get middleware descriptors registered by plugins during onInit.
+   * Returns descriptors in the order they were registered.
+   */
+  getMiddleware() {
+    return [...this.middlewareDescriptors];
+  }
+  /**
+   * Get provider descriptors registered by plugins during onInit.
+   * Returns descriptors in the order they were registered.
+   */
+  getProviders() {
+    return [...this.providerDescriptors];
+  }
+};
+
+// libs/plugins/core/src/lib/hook-injector.ts
+function injectCollectionEventHooks(collections, listener) {
+  for (const collection of collections) {
+    collection.hooks = collection.hooks ?? {};
+    const afterChangeHook = (args) => {
+      const operation = args.operation ?? "create";
+      const eventType = operation === "create" ? "afterChange" : "afterChange";
+      const event = {
+        collection: collection.slug,
+        event: eventType,
+        operation,
+        doc: args.doc ?? args.data,
+        previousDoc: args.originalDoc,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      listener(event);
+    };
+    const existingAfterChange = collection.hooks.afterChange ?? [];
+    collection.hooks.afterChange = [...existingAfterChange, afterChangeHook];
+    const afterDeleteHook = (args) => {
+      const event = {
+        collection: collection.slug,
+        event: "afterDelete",
+        operation: "delete",
+        doc: args.doc,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      listener(event);
+    };
+    const existingAfterDelete = collection.hooks.afterDelete ?? [];
+    collection.hooks.afterDelete = [...existingAfterDelete, afterDeleteHook];
+  }
+}
+
+// libs/plugins/core/src/lib/event-bus/event-bus.ts
+var MomentumEventBus = class {
+  constructor() {
+    this.subscriptions = [];
+  }
+  /**
+   * Subscribe to events matching a pattern.
+   *
+   * @param pattern - Pattern string: "collection:event", "*:event", "collection:*", or "*"
+   * @param handler - Callback invoked when a matching event occurs
+   * @returns Unsubscribe function
+   *
+   * @example
+   * ```typescript
+   * bus.on('posts:afterChange', (event) => { ... });
+   * bus.on('*:afterDelete', (event) => { ... });
+   * const unsub = bus.on('*', (event) => { ... });
+   * unsub(); // remove subscription
+   * ```
+   */
+  on(pattern, handler) {
+    const subscription = { pattern, handler };
+    this.subscriptions.push(subscription);
+    return () => {
+      const index = this.subscriptions.indexOf(subscription);
+      if (index !== -1) {
+        this.subscriptions.splice(index, 1);
+      }
+    };
+  }
+  /**
+   * Subscribe to all events for a specific collection.
+   * Shorthand for `on("collection:*", handler)`.
+   */
+  onCollection(collection, handler) {
+    return this.on(`${collection}:*`, handler);
+  }
+  /**
+   * Subscribe to a specific event type across all collections.
+   * Shorthand for `on("*:event", handler)`.
+   */
+  onEvent(event, handler) {
+    return this.on(`*:${event}`, handler);
+  }
+  /**
+   * Emit a collection event to all matching subscribers.
+   */
+  emit(event) {
+    for (const sub of this.subscriptions) {
+      if (matchesPattern(sub.pattern, event.collection, event.event)) {
+        sub.handler(event);
+      }
+    }
+  }
+  /**
+   * Remove all subscriptions.
+   */
+  clear() {
+    this.subscriptions = [];
+  }
+  /**
+   * Get the current number of subscriptions.
+   */
+  get size() {
+    return this.subscriptions.length;
+  }
+};
+function matchesPattern(pattern, collection, event) {
+  if (pattern === "*") {
+    return true;
+  }
+  const parts = pattern.split(":");
+  if (parts.length !== 2) {
+    return false;
+  }
+  const [patternCollection, patternEvent] = parts;
+  const collectionMatch = patternCollection === "*" || patternCollection === collection;
+  const eventMatch = patternEvent === "*" || patternEvent === event;
+  return collectionMatch && eventMatch;
+}
+
+// libs/plugins/core/src/lib/event-bus/event-bus-plugin.ts
+function eventBusPlugin() {
+  const bus = new MomentumEventBus();
+  return {
+    name: "event-bus",
+    bus,
+    onInit({ collections, logger }) {
+      logger.info("Injecting event hooks into collections");
+      injectCollectionEventHooks(collections, (event) => {
+        bus.emit(event);
+      });
+      logger.info(`Event hooks injected into ${collections.length} collections`);
+    },
+    onShutdown({ logger }) {
+      logger.info("Clearing event bus subscriptions");
+      bus.clear();
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MomentumEventBus,
+  PluginFatalError,
+  PluginRunner,
+  eventBusPlugin,
+  injectCollectionEventHooks
+});

package/package.json

@@ -0,0 +1,32 @@
+{
+	"name": "@momentumcms/plugins-core",
+	"version": "0.1.0",
+	"description": "Plugin system core and event bus for Momentum CMS",
+	"license": "MIT",
+	"author": "Momentum CMS Contributors",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/momentum-cms/momentum-cms.git",
+		"directory": "libs/plugins/core"
+	},
+	"homepage": "https://github.com/momentum-cms/momentum-cms#readme",
+	"bugs": {
+		"url": "https://github.com/momentum-cms/momentum-cms/issues"
+	},
+	"keywords": [
+		"cms",
+		"momentum-cms",
+		"plugins",
+		"event-bus"
+	],
+	"engines": {
+		"node": ">=18"
+	},
+	"type": "commonjs",
+	"main": "./index.cjs",
+	"types": "./src/index.d.ts",
+	"dependencies": {
+		"@momentumcms/core": "0.1.0",
+		"@momentumcms/logger": "0.1.0"
+	}
+}

package/src/index.d.ts

@@ -0,0 +1,6 @@
+export type { MomentumPlugin, PluginContext, PluginReadyContext, MomentumAPI, CollectionEvent, CollectionEventType, PluginMiddlewareDescriptor, PluginProviderDescriptor, PluginAdminRouteDescriptor, } from './lib/plugin.types';
+export { PluginRunner, type PluginRunnerOptions } from './lib/plugin-runner';
+export { PluginFatalError } from './lib/plugin-fatal-error';
+export { injectCollectionEventHooks, type CollectionEventListener } from './lib/hook-injector';
+export { MomentumEventBus, type EventHandler, type EventPattern } from './lib/event-bus/event-bus';
+export { eventBusPlugin, type EventBusPlugin } from './lib/event-bus/event-bus-plugin';

package/src/lib/event-bus/event-bus-plugin.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Event Bus Plugin
+ *
+ * A Momentum plugin that wires the event bus to collection hooks.
+ * Events are emitted for all collection CRUD operations.
+ *
+ * @example
+ * ```typescript
+ * import { eventBusPlugin } from '@momentumcms/plugins/core';
+ *
+ * const events = eventBusPlugin();
+ *
+ * // Subscribe to events
+ * events.bus.on('posts:afterChange', (event) => {
+ *   // cache invalidation, notifications, etc.
+ * });
+ *
+ * // Register in config
+ * export default defineMomentumConfig({
+ *   plugins: [events],
+ *   // ...
+ * });
+ * ```
+ */
+import type { MomentumPlugin } from '../plugin.types';
+import { MomentumEventBus } from './event-bus';
+/**
+ * Event bus plugin with an accessible bus instance.
+ */
+export interface EventBusPlugin extends MomentumPlugin {
+    /** The event bus instance — subscribe to events here */
+    bus: MomentumEventBus;
+}
+/**
+ * Creates an event bus plugin.
+ *
+ * The returned object has a `.bus` property for subscribing to events,
+ * and implements MomentumPlugin for lifecycle integration.
+ *
+ * @returns Plugin instance with event bus
+ */
+export declare function eventBusPlugin(): EventBusPlugin;

package/src/lib/event-bus/event-bus.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Momentum Event Bus
+ *
+ * Lightweight pub/sub with pattern matching for collection events.
+ *
+ * Patterns:
+ * - "posts:afterChange" — specific collection + event
+ * - "*:afterDelete" — any collection, specific event
+ * - "posts:*" — specific collection, any event
+ * - "*" — all events
+ */
+import type { CollectionEvent, CollectionEventType } from '../plugin.types';
+/**
+ * Event handler callback.
+ */
+export type EventHandler = (event: CollectionEvent) => void;
+/**
+ * Subscription pattern string.
+ * Format: "collection:event" where either part can be "*" for wildcard.
+ */
+export type EventPattern = string;
+/**
+ * Lightweight pub/sub event bus for collection events.
+ */
+export declare class MomentumEventBus {
+    private subscriptions;
+    /**
+     * Subscribe to events matching a pattern.
+     *
+     * @param pattern - Pattern string: "collection:event", "*:event", "collection:*", or "*"
+     * @param handler - Callback invoked when a matching event occurs
+     * @returns Unsubscribe function
+     *
+     * @example
+     * ```typescript
+     * bus.on('posts:afterChange', (event) => { ... });
+     * bus.on('*:afterDelete', (event) => { ... });
+     * const unsub = bus.on('*', (event) => { ... });
+     * unsub(); // remove subscription
+     * ```
+     */
+    on(pattern: EventPattern, handler: EventHandler): () => void;
+    /**
+     * Subscribe to all events for a specific collection.
+     * Shorthand for `on("collection:*", handler)`.
+     */
+    onCollection(collection: string, handler: EventHandler): () => void;
+    /**
+     * Subscribe to a specific event type across all collections.
+     * Shorthand for `on("*:event", handler)`.
+     */
+    onEvent(event: CollectionEventType, handler: EventHandler): () => void;
+    /**
+     * Emit a collection event to all matching subscribers.
+     */
+    emit(event: CollectionEvent): void;
+    /**
+     * Remove all subscriptions.
+     */
+    clear(): void;
+    /**
+     * Get the current number of subscriptions.
+     */
+    get size(): number;
+}

package/src/lib/hook-injector.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Hook Injector
+ *
+ * Utility to inject collection event hooks that emit CollectionEvents.
+ * Mirrors the pattern from registerWebhookHooks() in webhooks.ts.
+ */
+import type { CollectionConfig } from '@momentumcms/core';
+import type { CollectionEvent } from './plugin.types';
+/**
+ * Callback type for collection event listeners.
+ */
+export type CollectionEventListener = (event: CollectionEvent) => void;
+/**
+ * Injects afterChange and afterDelete hooks into collections that emit events.
+ *
+ * @param collections - Mutable collections array
+ * @param listener - Callback invoked for each collection event
+ */
+export declare function injectCollectionEventHooks(collections: CollectionConfig[], listener: CollectionEventListener): void;

package/src/lib/plugin-fatal-error.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Plugin Fatal Error
+ *
+ * Thrown by plugins that must halt server startup.
+ * Regular plugin errors are logged and skipped (fail-open),
+ * but PluginFatalError causes the entire init to fail.
+ */
+export declare class PluginFatalError extends Error {
+    readonly pluginName: string;
+    constructor(pluginName: string, message: string);
+}

package/src/lib/plugin-runner.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Plugin Runner
+ *
+ * Orchestrates plugin lifecycle: init → ready → shutdown.
+ * Plugins execute in array order; shutdown runs in reverse.
+ * Errors are logged and skipped unless PluginFatalError is thrown.
+ */
+import type { CollectionConfig, MomentumConfig } from '@momentumcms/core';
+import type { MomentumAPI, MomentumPlugin, PluginMiddlewareDescriptor, PluginProviderDescriptor } from './plugin.types';
+/**
+ * Options for creating a PluginRunner.
+ */
+export interface PluginRunnerOptions {
+    /** The Momentum config */
+    config: MomentumConfig;
+    /** Mutable collections array */
+    collections: CollectionConfig[];
+    /** Plugins to run */
+    plugins: MomentumPlugin[];
+}
+/**
+ * Manages plugin lifecycle execution.
+ */
+export declare class PluginRunner {
+    private readonly plugins;
+    private readonly config;
+    private readonly collections;
+    private readonly logger;
+    private readonly middlewareDescriptors;
+    private readonly providerDescriptors;
+    private initialized;
+    private ready;
+    constructor(options: PluginRunnerOptions);
+    /**
+     * Create a plugin-scoped context.
+     */
+    private createContext;
+    /**
+     * Run onInit for all plugins (in order).
+     * Call this before API initialization.
+     */
+    runInit(): Promise<void>;
+    /**
+     * Run onReady for all plugins (in order).
+     * Call this after API + seeding complete.
+     */
+    runReady(api: MomentumAPI): Promise<void>;
+    /**
+     * Run onShutdown for all plugins (in reverse order).
+     * Call this during graceful shutdown.
+     */
+    runShutdown(): Promise<void>;
+    /**
+     * Get the list of registered plugin names.
+     */
+    getPluginNames(): string[];
+    /**
+     * Get middleware descriptors registered by plugins during onInit.
+     * Returns descriptors in the order they were registered.
+     */
+    getMiddleware(): PluginMiddlewareDescriptor[];
+    /**
+     * Get provider descriptors registered by plugins during onInit.
+     * Returns descriptors in the order they were registered.
+     */
+    getProviders(): PluginProviderDescriptor[];
+}

package/src/lib/plugin.types.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Plugin System Types — Re-exported from @momentumcms/core
+ *
+ * Canonical definitions now live in @momentumcms/core.
+ * This file re-exports them for backward compatibility.
+ */
+export type { MomentumPlugin, PluginContext, PluginReadyContext, MomentumAPI, CollectionEvent, CollectionEventType, PluginMiddlewareDescriptor, PluginProviderDescriptor, PluginAdminRouteDescriptor, PluginLogger, } from '@momentumcms/core';