@newcms/core 0.1.0 → 0.3.0

package/dist/index.js

@@ -1,5 +1,1212 @@
-export { HookEngine } from './hook-engine.js';
-export { PostTypeRegistry, BUILTIN_POST_TYPES } from './post-type-registry.js';
-export { TaxonomyRegistry, BUILTIN_TAXONOMIES } from './taxonomy-registry.js';
-export { POST_STATUS, USER_ROLES, HOOK_PRIORITY } from './types.js';
+// src/hook-engine.ts
+var anonymousCounter = 0;
+function generateCallbackId(callback, priority) {
+  if (callback.name && callback.name !== "") {
+    return `${callback.name}::${priority}`;
+  }
+  anonymousCounter++;
+  return `__anonymous_${anonymousCounter}::${priority}`;
+}
+var HookEngine = class {
+  /**
+   * Map of hook name → array of handlers, kept sorted by priority.
+   */
+  hooks = /* @__PURE__ */ new Map();
+  /**
+   * Stack of hooks currently being executed (supports recursion).
+   */
+  currentStack = [];
+  /**
+   * Counter of how many times each hook has been fired.
+   */
+  fireCount = /* @__PURE__ */ new Map();
+  /**
+   * Register a callback for a hook.
+   *
+   * @param hookName - The hook identifier
+   * @param callback - The function to execute
+   * @param options - Priority and accepted args configuration
+   * @returns The generated handler ID
+   */
+  addHook(hookName, callback, options = {}) {
+    const priority = options.priority ?? 10;
+    const acceptedArgs = options.acceptedArgs ?? 1;
+    const id = generateCallbackId(callback, priority);
+    const handler = {
+      callback,
+      priority,
+      acceptedArgs,
+      id
+    };
+    const existing = this.hooks.get(hookName) ?? [];
+    existing.push(handler);
+    existing.sort((a, b) => a.priority - b.priority);
+    this.hooks.set(hookName, existing);
+    return id;
+  }
+  /**
+   * Remove a specific callback from a hook.
+   *
+   * Both the callback reference AND priority must match for removal.
+   *
+   * @param hookName - The hook identifier
+   * @param callback - The callback to remove
+   * @param priority - The priority it was registered with (default: 10)
+   * @returns true if a handler was removed
+   */
+  removeHook(hookName, callback, priority = 10) {
+    const handlers = this.hooks.get(hookName);
+    if (!handlers) return false;
+    const initialLength = handlers.length;
+    const filtered = handlers.filter(
+      (h) => !(h.callback === callback && h.priority === priority)
+    );
+    if (filtered.length === initialLength) return false;
+    if (filtered.length === 0) {
+      this.hooks.delete(hookName);
+    } else {
+      this.hooks.set(hookName, filtered);
+    }
+    return true;
+  }
+  /**
+   * Remove all callbacks from a hook, optionally only for a specific priority.
+   *
+   * @param hookName - The hook identifier
+   * @param priority - If provided, only remove handlers at this priority
+   * @returns true if any handlers were removed
+   */
+  removeAllHooks(hookName, priority) {
+    if (priority === void 0) {
+      return this.hooks.delete(hookName);
+    }
+    const handlers = this.hooks.get(hookName);
+    if (!handlers) return false;
+    const filtered = handlers.filter((h) => h.priority !== priority);
+    if (filtered.length === handlers.length) return false;
+    if (filtered.length === 0) {
+      this.hooks.delete(hookName);
+    } else {
+      this.hooks.set(hookName, filtered);
+    }
+    return true;
+  }
+  /**
+   * Check if a hook has registered handlers.
+   *
+   * @param hookName - The hook identifier
+   * @param callback - If provided, check for this specific callback
+   * @returns false if no handlers, or the priority of the matching handler
+   */
+  hasHook(hookName, callback) {
+    const handlers = this.hooks.get(hookName);
+    if (!handlers || handlers.length === 0) return false;
+    if (callback === void 0) {
+      return handlers[0].priority;
+    }
+    const found = handlers.find((h) => h.callback === callback);
+    return found ? found.priority : false;
+  }
+  /**
+   * Execute an action hook. All registered callbacks are called in priority order.
+   * The "all" universal hook fires before the specific hook.
+   *
+   * @param hookName - The hook identifier
+   * @param args - Arguments to pass to callbacks
+   */
+  async doAction(hookName, ...args) {
+    if (hookName !== "all") {
+      await this.fireUniversalHook(hookName, args);
+    }
+    const handlers = this.hooks.get(hookName);
+    this.incrementFireCount(hookName);
+    if (!handlers || handlers.length === 0) return;
+    const stackEntry = { name: hookName, currentIndex: 0 };
+    this.currentStack.push(stackEntry);
+    try {
+      for (let i = 0; i < handlers.length; i++) {
+        stackEntry.currentIndex = i;
+        const handler = handlers[i];
+        const slicedArgs = args.slice(0, handler.acceptedArgs);
+        await handler.callback(...slicedArgs);
+      }
+    } finally {
+      this.currentStack.pop();
+    }
+  }
+  /**
+   * Execute an action hook synchronously.
+   */
+  doActionSync(hookName, ...args) {
+    if (hookName !== "all") {
+      this.fireUniversalHookSync(hookName, args);
+    }
+    const handlers = this.hooks.get(hookName);
+    this.incrementFireCount(hookName);
+    if (!handlers || handlers.length === 0) return;
+    const stackEntry = { name: hookName, currentIndex: 0 };
+    this.currentStack.push(stackEntry);
+    try {
+      for (let i = 0; i < handlers.length; i++) {
+        stackEntry.currentIndex = i;
+        const handler = handlers[i];
+        const slicedArgs = args.slice(0, handler.acceptedArgs);
+        handler.callback(...slicedArgs);
+      }
+    } finally {
+      this.currentStack.pop();
+    }
+  }
+  /**
+   * Execute a filter hook. The first argument is the value being filtered.
+   * Each callback receives the (possibly modified) value and returns a new value.
+   * The "all" universal hook fires before the specific hook.
+   *
+   * @param hookName - The hook identifier
+   * @param value - The initial value to filter
+   * @param args - Additional arguments passed to each callback
+   * @returns The filtered value after all callbacks have processed it
+   */
+  async applyFilters(hookName, value, ...args) {
+    if (hookName !== "all") {
+      await this.fireUniversalHook(hookName, [value, ...args]);
+    }
+    const handlers = this.hooks.get(hookName);
+    this.incrementFireCount(hookName);
+    if (!handlers || handlers.length === 0) return value;
+    const stackEntry = { name: hookName, currentIndex: 0 };
+    this.currentStack.push(stackEntry);
+    let filteredValue = value;
+    try {
+      for (let i = 0; i < handlers.length; i++) {
+        stackEntry.currentIndex = i;
+        const handler = handlers[i];
+        const callArgs = [filteredValue, ...args].slice(0, handler.acceptedArgs);
+        filteredValue = await handler.callback(filteredValue, ...callArgs.slice(1));
+      }
+    } finally {
+      this.currentStack.pop();
+    }
+    return filteredValue;
+  }
+  /**
+   * Execute a filter hook synchronously.
+   */
+  applyFiltersSync(hookName, value, ...args) {
+    if (hookName !== "all") {
+      this.fireUniversalHookSync(hookName, [value, ...args]);
+    }
+    const handlers = this.hooks.get(hookName);
+    this.incrementFireCount(hookName);
+    if (!handlers || handlers.length === 0) return value;
+    const stackEntry = { name: hookName, currentIndex: 0 };
+    this.currentStack.push(stackEntry);
+    let filteredValue = value;
+    try {
+      for (let i = 0; i < handlers.length; i++) {
+        stackEntry.currentIndex = i;
+        const handler = handlers[i];
+        const callArgs = [filteredValue, ...args].slice(0, handler.acceptedArgs);
+        filteredValue = handler.callback(filteredValue, ...callArgs.slice(1));
+      }
+    } finally {
+      this.currentStack.pop();
+    }
+    return filteredValue;
+  }
+  /**
+   * Get how many times a hook has been fired.
+   */
+  getFireCount(hookName) {
+    return this.fireCount.get(hookName) ?? 0;
+  }
+  /**
+   * Check if a specific hook is currently being executed.
+   */
+  isDoingHook(hookName) {
+    if (hookName === void 0) {
+      return this.currentStack.length > 0;
+    }
+    return this.currentStack.some((entry) => entry.name === hookName);
+  }
+  /**
+   * Get the name of the hook currently being executed (top of stack).
+   * Returns undefined if no hook is executing.
+   */
+  currentHook() {
+    if (this.currentStack.length === 0) return void 0;
+    return this.currentStack[this.currentStack.length - 1].name;
+  }
+  /**
+   * Get a snapshot of the current execution stack.
+   */
+  getExecutionStack() {
+    return [...this.currentStack];
+  }
+  /**
+   * Check if a hook has ever been fired (fire count > 0).
+   */
+  didHook(hookName) {
+    return this.getFireCount(hookName) > 0;
+  }
+  /**
+   * Get the number of handlers registered for a hook.
+   */
+  getHandlerCount(hookName) {
+    return this.hooks.get(hookName)?.length ?? 0;
+  }
+  /**
+   * Reset the engine — useful for testing.
+   */
+  reset() {
+    this.hooks.clear();
+    this.currentStack = [];
+    this.fireCount.clear();
+    anonymousCounter = 0;
+  }
+  // --- Convenience aliases matching WordPress API names ---
+  addAction(hookName, callback, options) {
+    return this.addHook(hookName, callback, options);
+  }
+  addFilter(hookName, callback, options) {
+    return this.addHook(hookName, callback, options);
+  }
+  removeAction(hookName, callback, priority) {
+    return this.removeHook(hookName, callback, priority);
+  }
+  removeFilter(hookName, callback, priority) {
+    return this.removeHook(hookName, callback, priority);
+  }
+  hasAction(hookName, callback) {
+    return this.hasHook(hookName, callback);
+  }
+  hasFilter(hookName, callback) {
+    return this.hasHook(hookName, callback);
+  }
+  didAction(hookName) {
+    return this.didHook(hookName);
+  }
+  didFilter(hookName) {
+    return this.didHook(hookName);
+  }
+  // --- Private helpers ---
+  incrementFireCount(hookName) {
+    this.fireCount.set(hookName, (this.fireCount.get(hookName) ?? 0) + 1);
+  }
+  async fireUniversalHook(hookName, args) {
+    const allHandlers = this.hooks.get("all");
+    if (!allHandlers || allHandlers.length === 0) return;
+    const stackEntry = { name: "all", currentIndex: 0 };
+    this.currentStack.push(stackEntry);
+    try {
+      for (let i = 0; i < allHandlers.length; i++) {
+        stackEntry.currentIndex = i;
+        const handler = allHandlers[i];
+        await handler.callback(hookName, ...args);
+      }
+    } finally {
+      this.currentStack.pop();
+    }
+  }
+  fireUniversalHookSync(hookName, args) {
+    const allHandlers = this.hooks.get("all");
+    if (!allHandlers || allHandlers.length === 0) return;
+    const stackEntry = { name: "all", currentIndex: 0 };
+    this.currentStack.push(stackEntry);
+    try {
+      for (let i = 0; i < allHandlers.length; i++) {
+        stackEntry.currentIndex = i;
+        const handler = allHandlers[i];
+        handler.callback(hookName, ...args);
+      }
+    } finally {
+      this.currentStack.pop();
+    }
+  }
+};
+
+// src/post-type-registry.ts
+var PostTypeRegistry = class {
+  types = /* @__PURE__ */ new Map();
+  /**
+   * Register a new post type.
+   *
+   * @throws If a type with the same name is already registered
+   */
+  register(definition) {
+    if (this.types.has(definition.name)) {
+      throw new Error(`Post type "${definition.name}" is already registered.`);
+    }
+    this.types.set(definition.name, definition);
+  }
+  /**
+   * Get a post type definition by name.
+   */
+  get(name) {
+    return this.types.get(name);
+  }
+  /**
+   * Check if a post type is registered.
+   */
+  has(name) {
+    return this.types.has(name);
+  }
+  /**
+   * Get all registered post types.
+   */
+  getAll() {
+    return [...this.types.values()];
+  }
+  /**
+   * Get only public post types (for REST API, search, etc).
+   */
+  getPublic() {
+    return this.getAll().filter((t) => t.public !== false);
+  }
+  /**
+   * Get post types that are exposed via REST API.
+   */
+  getRestVisible() {
+    return this.getAll().filter((t) => t.showInRest === true);
+  }
+  /**
+   * Unregister a post type. Only custom types can be unregistered.
+   */
+  unregister(name) {
+    return this.types.delete(name);
+  }
+  /**
+   * Reset registry — for testing only.
+   */
+  reset() {
+    this.types.clear();
+  }
+};
+var BUILTIN_POST_TYPES = [
+  {
+    name: "post",
+    label: "Posts",
+    labels: { singular: "Post", plural: "Posts" },
+    public: true,
+    hierarchical: false,
+    showInRest: true,
+    restBase: "posts",
+    supports: [
+      "title",
+      "editor",
+      "author",
+      "thumbnail",
+      "excerpt",
+      "trackbacks",
+      "custom-fields",
+      "comments",
+      "revisions",
+      "post-formats"
+    ],
+    taxonomies: ["category", "post_tag"],
+    hasArchive: true,
+    rewrite: { slug: "", withFront: true },
+    menuPosition: 5,
+    capability_type: "post"
+  },
+  {
+    name: "page",
+    label: "Pages",
+    labels: { singular: "Page", plural: "Pages" },
+    public: true,
+    hierarchical: true,
+    showInRest: true,
+    restBase: "pages",
+    supports: [
+      "title",
+      "editor",
+      "author",
+      "thumbnail",
+      "page-attributes",
+      "custom-fields",
+      "comments",
+      "revisions"
+    ],
+    taxonomies: [],
+    hasArchive: false,
+    rewrite: { slug: "", withFront: false },
+    menuPosition: 20,
+    capability_type: "page"
+  },
+  {
+    name: "attachment",
+    label: "Media",
+    labels: { singular: "Media", plural: "Media" },
+    public: true,
+    hierarchical: false,
+    showInRest: true,
+    restBase: "media",
+    supports: ["title", "author", "comments"],
+    taxonomies: [],
+    hasArchive: false,
+    rewrite: false,
+    capability_type: "post"
+  },
+  {
+    name: "revision",
+    label: "Revisions",
+    labels: { singular: "Revision", plural: "Revisions" },
+    public: false,
+    hierarchical: false,
+    showInRest: false,
+    supports: ["author"],
+    taxonomies: [],
+    hasArchive: false,
+    rewrite: false,
+    capability_type: "post"
+  },
+  {
+    name: "nav_menu_item",
+    label: "Navigation Menu Items",
+    labels: { singular: "Navigation Menu Item", plural: "Navigation Menu Items" },
+    public: false,
+    hierarchical: false,
+    showInRest: false,
+    supports: [],
+    taxonomies: ["nav_menu"],
+    hasArchive: false,
+    rewrite: false,
+    capability_type: "post"
+  }
+];
+
+// src/taxonomy-registry.ts
+var TaxonomyRegistry = class {
+  taxonomies = /* @__PURE__ */ new Map();
+  register(definition) {
+    if (this.taxonomies.has(definition.name)) {
+      throw new Error(`Taxonomy "${definition.name}" is already registered.`);
+    }
+    this.taxonomies.set(definition.name, definition);
+  }
+  get(name) {
+    return this.taxonomies.get(name);
+  }
+  has(name) {
+    return this.taxonomies.has(name);
+  }
+  getAll() {
+    return [...this.taxonomies.values()];
+  }
+  /**
+   * Get taxonomies assigned to a specific object type (e.g., 'post').
+   */
+  getForObjectType(objectType) {
+    return this.getAll().filter((t) => t.objectTypes.includes(objectType));
+  }
+  getRestVisible() {
+    return this.getAll().filter((t) => t.showInRest === true);
+  }
+  unregister(name) {
+    return this.taxonomies.delete(name);
+  }
+  reset() {
+    this.taxonomies.clear();
+  }
+};
+var BUILTIN_TAXONOMIES = [
+  {
+    name: "category",
+    objectTypes: ["post"],
+    label: "Categories",
+    labels: { singular: "Category", plural: "Categories" },
+    public: true,
+    hierarchical: true,
+    showInRest: true,
+    restBase: "categories",
+    rewrite: { slug: "category", withFront: true, hierarchical: true }
+  },
+  {
+    name: "post_tag",
+    objectTypes: ["post"],
+    label: "Tags",
+    labels: { singular: "Tag", plural: "Tags" },
+    public: true,
+    hierarchical: false,
+    showInRest: true,
+    restBase: "tags",
+    rewrite: { slug: "tag", withFront: true }
+  },
+  {
+    name: "nav_menu",
+    objectTypes: ["nav_menu_item"],
+    label: "Navigation Menus",
+    labels: { singular: "Navigation Menu", plural: "Navigation Menus" },
+    public: false,
+    hierarchical: false,
+    showInRest: false,
+    rewrite: false
+  }
+];
+
+// src/extension-registry.ts
+var ExtensionRegistry = class {
+  extensions = /* @__PURE__ */ new Map();
+  /**
+   * Register an extension manifest (discovery phase).
+   */
+  register(manifest, path, status) {
+    this.extensions.set(manifest.slug, {
+      manifest,
+      status,
+      path,
+      activatedAt: status === "active" ? /* @__PURE__ */ new Date() : void 0
+    });
+  }
+  get(slug) {
+    return this.extensions.get(slug);
+  }
+  has(slug) {
+    return this.extensions.has(slug);
+  }
+  /**
+   * Get all extensions by status.
+   */
+  getByStatus(status) {
+    return [...this.extensions.values()].filter((e) => e.status === status);
+  }
+  getAll() {
+    return [...this.extensions.values()];
+  }
+  getActive() {
+    return this.getByStatus("active");
+  }
+  getMustUse() {
+    return this.getByStatus("must-use");
+  }
+  getPaused() {
+    return this.getByStatus("paused");
+  }
+  /**
+   * Activate an extension. Checks dependencies first.
+   *
+   * @throws If dependencies are not met
+   */
+  activate(slug) {
+    const entry = this.extensions.get(slug);
+    if (!entry) throw new Error(`Extension "${slug}" not found`);
+    if (entry.status === "active") return;
+    const unmet = this.getUnmetDependencies(slug);
+    if (unmet.length > 0) {
+      throw new Error(
+        `Cannot activate "${slug}": missing dependencies: ${unmet.join(", ")}`
+      );
+    }
+    entry.status = "active";
+    entry.activatedAt = /* @__PURE__ */ new Date();
+    entry.pauseReason = void 0;
+  }
+  /**
+   * Deactivate an extension. Checks if other extensions depend on it.
+   *
+   * @throws If other active extensions depend on this one
+   */
+  deactivate(slug) {
+    const entry = this.extensions.get(slug);
+    if (!entry) throw new Error(`Extension "${slug}" not found`);
+    if (entry.status === "inactive") return;
+    if (entry.status === "must-use") {
+      throw new Error(`Cannot deactivate must-use extension "${slug}"`);
+    }
+    const dependents = this.getDependents(slug);
+    if (dependents.length > 0) {
+      throw new Error(
+        `Cannot deactivate "${slug}": required by: ${dependents.map((d) => d.manifest.slug).join(", ")}`
+      );
+    }
+    entry.status = "inactive";
+    entry.activatedAt = void 0;
+  }
+  /**
+   * Pause an extension due to a fatal error (recovery mode).
+   */
+  pause(slug, reason) {
+    const entry = this.extensions.get(slug);
+    if (!entry) return;
+    entry.status = "paused";
+    entry.pauseReason = reason;
+  }
+  /**
+   * Unpause an extension (resume from recovery mode).
+   */
+  unpause(slug) {
+    const entry = this.extensions.get(slug);
+    if (!entry || entry.status !== "paused") return;
+    entry.status = "active";
+    entry.pauseReason = void 0;
+  }
+  /**
+   * Remove an extension from the registry entirely.
+   */
+  unregister(slug) {
+    return this.extensions.delete(slug);
+  }
+  /**
+   * Get dependencies that are not active.
+   */
+  getUnmetDependencies(slug) {
+    const entry = this.extensions.get(slug);
+    if (!entry) return [];
+    const deps = entry.manifest.dependencies ?? [];
+    return deps.filter((dep) => {
+      const depEntry = this.extensions.get(dep);
+      return !depEntry || depEntry.status !== "active" && depEntry.status !== "must-use";
+    });
+  }
+  /**
+   * Get active extensions that depend on the given extension.
+   */
+  getDependents(slug) {
+    return this.getActive().filter(
+      (entry) => entry.manifest.dependencies?.includes(slug)
+    );
+  }
+  /**
+   * Check for circular dependencies starting from a slug.
+   */
+  hasCircularDependency(slug, visited = /* @__PURE__ */ new Set()) {
+    if (visited.has(slug)) return true;
+    visited.add(slug);
+    const entry = this.extensions.get(slug);
+    if (!entry) return false;
+    for (const dep of entry.manifest.dependencies ?? []) {
+      if (this.hasCircularDependency(dep, new Set(visited))) return true;
+    }
+    return false;
+  }
+  reset() {
+    this.extensions.clear();
+  }
+};
+
+// src/theme-registry.ts
+var ThemeRegistry = class {
+  themes = /* @__PURE__ */ new Map();
+  activeSlug = null;
+  register(manifest, path) {
+    this.themes.set(manifest.slug, { manifest, path, active: false });
+  }
+  get(slug) {
+    return this.themes.get(slug);
+  }
+  getAll() {
+    return [...this.themes.values()];
+  }
+  getActive() {
+    if (!this.activeSlug) return void 0;
+    return this.themes.get(this.activeSlug);
+  }
+  /**
+   * Activate a theme. Resolves parent theme for child themes.
+   */
+  activate(slug) {
+    const theme = this.themes.get(slug);
+    if (!theme) throw new Error(`Theme "${slug}" not found`);
+    if (this.activeSlug) {
+      const current = this.themes.get(this.activeSlug);
+      if (current) current.active = false;
+    }
+    if (theme.manifest.parent) {
+      const parent = this.themes.get(theme.manifest.parent);
+      if (!parent) {
+        throw new Error(
+          `Parent theme "${theme.manifest.parent}" not found for child theme "${slug}"`
+        );
+      }
+      theme.parentTheme = parent;
+    }
+    theme.active = true;
+    this.activeSlug = slug;
+  }
+  /**
+   * Check if the active theme supports a feature.
+   */
+  supports(feature) {
+    const active = this.getActive();
+    if (!active) return false;
+    const supports = active.manifest.supports;
+    if (!supports) return false;
+    const value = supports[feature];
+    if (value === void 0 || value === false) return false;
+    return true;
+  }
+  reset() {
+    this.themes.clear();
+    this.activeSlug = null;
+  }
+};
+function resolveTemplateHierarchy(ctx) {
+  switch (ctx.type) {
+    case "single":
+      return [
+        ctx.postType && ctx.slug ? `${ctx.postType}-${ctx.slug}` : null,
+        ctx.postType ?? null,
+        "singular",
+        "index"
+      ].filter(Boolean);
+    case "page":
+      return [
+        ctx.customTemplate ?? null,
+        ctx.slug ? `page-${ctx.slug}` : null,
+        ctx.id ? `page-${ctx.id}` : null,
+        "page",
+        "singular",
+        "index"
+      ].filter(Boolean);
+    case "category":
+      return [
+        ctx.slug ? `category-${ctx.slug}` : null,
+        ctx.id ? `category-${ctx.id}` : null,
+        "category",
+        "archive",
+        "index"
+      ].filter(Boolean);
+    case "tag":
+      return [
+        ctx.slug ? `tag-${ctx.slug}` : null,
+        ctx.id ? `tag-${ctx.id}` : null,
+        "tag",
+        "archive",
+        "index"
+      ].filter(Boolean);
+    case "taxonomy":
+      return [
+        ctx.taxonomy && ctx.term ? `taxonomy-${ctx.taxonomy}-${ctx.term}` : null,
+        ctx.taxonomy && ctx.id ? `taxonomy-${ctx.taxonomy}-${ctx.id}` : null,
+        ctx.taxonomy ? `taxonomy-${ctx.taxonomy}` : null,
+        "taxonomy",
+        "archive",
+        "index"
+      ].filter(Boolean);
+    case "author":
+      return [
+        ctx.nicename ? `author-${ctx.nicename}` : null,
+        ctx.id ? `author-${ctx.id}` : null,
+        "author",
+        "archive",
+        "index"
+      ].filter(Boolean);
+    case "date":
+      return ["date", "archive", "index"];
+    case "search":
+      return ["search", "index"];
+    case "404":
+      return ["404", "index"];
+    case "home":
+      return ["front-page", "home", "index"];
+    case "archive":
+      return ["archive", "index"];
+    case "attachment":
+      return [
+        ctx.mimeType && ctx.mimeSubtype ? `${ctx.mimeType}-${ctx.mimeSubtype}` : null,
+        ctx.mimeSubtype ?? null,
+        ctx.mimeType ?? null,
+        "attachment",
+        "single",
+        "index"
+      ].filter(Boolean);
+    default:
+      return ["index"];
+  }
+}
+
+// src/bootstrap.ts
+var BOOTSTRAP_PHASES = [
+  "entry_point",
+  // 1. HTTP request received
+  "configuration",
+  // 2. Load config (DB, keys, flags)
+  "initial_constants",
+  // 3. Define constants, memory limits
+  "environment_check",
+  // 4. Validate runtime versions
+  "error_handling",
+  // 5. Register fatal error handler + recovery mode
+  "core_functions",
+  // 6. Load core utility modules
+  "database_connect",
+  // 7. Connect to database (+ drop-in check)
+  "object_cache",
+  // 8. Initialize cache system (+ drop-in check)
+  "default_filters",
+  // 9. Register all core hooks/filters
+  "must_use_extensions",
+  // 10. Load must-use extensions (alphabetical)
+  "regular_extensions",
+  // 11. Load active extensions (skip paused)
+  "overridable_functions",
+  // 12. Load auth/hash/nonce functions (skip if overridden)
+  "extensions_loaded",
+  // 13. Fire "extensions_loaded" hook
+  "global_objects",
+  // 14. Create query engine, rewrite, widgets, roles
+  "theme",
+  // 15. Load active theme (child → parent)
+  "init",
+  // 16. Fire "init" hook (register types, taxonomies, etc.)
+  "system_loaded"
+  // 17. Fire "cms_loaded" hook
+];
+var BootstrapManager = class {
+  constructor(hooks) {
+    this.hooks = hooks;
+    for (const phase of BOOTSTRAP_PHASES) {
+      this.phaseHandlers.set(phase, []);
+    }
+  }
+  hooks;
+  phaseHandlers = /* @__PURE__ */ new Map();
+  completedPhases = /* @__PURE__ */ new Set();
+  currentPhase = null;
+  /**
+   * Register a handler for a bootstrap phase.
+   */
+  on(phase, handler) {
+    const handlers = this.phaseHandlers.get(phase);
+    if (!handlers) throw new Error(`Unknown bootstrap phase: "${phase}"`);
+    handlers.push(handler);
+  }
+  /**
+   * Execute all 17 bootstrap phases in order.
+   * For short-init mode, pass a phase to stop at.
+   */
+  async run(stopAfter) {
+    for (const phase of BOOTSTRAP_PHASES) {
+      this.currentPhase = phase;
+      const handlers = this.phaseHandlers.get(phase) ?? [];
+      for (const handler of handlers) {
+        await handler();
+      }
+      await this.hooks.doAction(`bootstrap:${phase}`);
+      this.completedPhases.add(phase);
+      this.currentPhase = null;
+      if (stopAfter === phase) break;
+    }
+    if (!stopAfter || stopAfter === "system_loaded") {
+      await this.hooks.doAction("cms_loaded");
+    }
+  }
+  /**
+   * Check if a phase has been completed.
+   */
+  isPhaseComplete(phase) {
+    return this.completedPhases.has(phase);
+  }
+  /**
+   * Get the phase currently being executed.
+   */
+  getCurrentPhase() {
+    return this.currentPhase;
+  }
+  /**
+   * Get all completed phases.
+   */
+  getCompletedPhases() {
+    return [...this.completedPhases];
+  }
+  /**
+   * Reset — for testing.
+   */
+  reset() {
+    this.completedPhases.clear();
+    this.currentPhase = null;
+    for (const phase of BOOTSTRAP_PHASES) {
+      this.phaseHandlers.set(phase, []);
+    }
+  }
+};
+
+// src/types.ts
+var POST_STATUS = {
+  PUBLISH: "publish",
+  DRAFT: "draft",
+  PENDING: "pending",
+  PRIVATE: "private",
+  TRASH: "trash",
+  AUTO_DRAFT: "auto-draft",
+  INHERIT: "inherit",
+  FUTURE: "future"
+};
+var USER_ROLES = {
+  ADMINISTRATOR: "administrator",
+  EDITOR: "editor",
+  AUTHOR: "author",
+  CONTRIBUTOR: "contributor",
+  SUBSCRIBER: "subscriber"
+};
+var HOOK_PRIORITY = {
+  EARLIEST: 1,
+  EARLY: 5,
+  DEFAULT: 10,
+  LATE: 15,
+  LATEST: 20
+};
+
+// src/shortcode.ts
+var ShortcodeRegistry = class {
+  handlers = /* @__PURE__ */ new Map();
+  register(tag, callback) {
+    this.handlers.set(tag, callback);
+  }
+  unregister(tag) {
+    return this.handlers.delete(tag);
+  }
+  has(tag) {
+    return this.handlers.has(tag);
+  }
+  /**
+   * Process a string, replacing all registered shortcodes with their output.
+   * Supports nesting: inner shortcodes are processed first.
+   */
+  process(content) {
+    if (this.handlers.size === 0) return content;
+    const tagPattern = [...this.handlers.keys()].map(escRegex).join("|");
+    const selfClosingRe = new RegExp(
+      `\\[(${tagPattern})(\\s[^\\]]*?)?\\s*\\/\\]`,
+      "g"
+    );
+    const enclosingRe = new RegExp(
+      `\\[(${tagPattern})(\\s[^\\]]*?)?\\]([\\s\\S]*?)\\[\\/\\1\\]`,
+      "g"
+    );
+    let result = content;
+    let prevResult = "";
+    let iterations = 0;
+    while (result !== prevResult && iterations < 10) {
+      prevResult = result;
+      result = result.replace(enclosingRe, (full, tag, attrStr, inner) => {
+        const handler = this.handlers.get(tag);
+        if (!handler) return full;
+        const attrs = parseShortcodeAttributes(attrStr?.trim() ?? "");
+        return handler(attrs, inner, tag);
+      });
+      iterations++;
+    }
+    result = result.replace(selfClosingRe, (full, tag, attrStr) => {
+      const handler = this.handlers.get(tag);
+      if (!handler) return full;
+      const attrs = parseShortcodeAttributes(attrStr?.trim() ?? "");
+      return handler(attrs, "", tag);
+    });
+    return result;
+  }
+  /**
+   * Strip all shortcodes from content (remove tags, keep content).
+   */
+  strip(content) {
+    const tagPattern = [...this.handlers.keys()].map(escRegex).join("|");
+    if (!tagPattern) return content;
+    let result = content;
+    result = result.replace(
+      new RegExp(`\\[(${tagPattern})(\\s[^\\]]*?)?\\]([\\s\\S]*?)\\[\\/\\1\\]`, "g"),
+      "$3"
+    );
+    result = result.replace(
+      new RegExp(`\\[(${tagPattern})(\\s[^\\]]*?)?\\s*\\/\\]`, "g"),
+      ""
+    );
+    return result;
+  }
+  getAll() {
+    return [...this.handlers.keys()];
+  }
+  reset() {
+    this.handlers.clear();
+  }
+};
+function parseShortcodeAttributes(attrStr) {
+  const attrs = {};
+  if (!attrStr) return attrs;
+  const re = /([a-zA-Z_][-a-zA-Z0-9_]*)\s*=\s*(?:"([^"]*)"|'([^']*)'|(\S+))|([a-zA-Z_][-a-zA-Z0-9_]*)/g;
+  let match;
+  while ((match = re.exec(attrStr)) !== null) {
+    if (match[1]) {
+      attrs[match[1]] = match[2] ?? match[3] ?? match[4] ?? "";
+    } else if (match[5]) {
+      attrs[match[5]] = "";
+    }
+  }
+  return attrs;
+}
+function escRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/menu-registry.ts
+var MenuRegistry = class {
+  locations = /* @__PURE__ */ new Map();
+  /**
+   * Register a menu location (e.g., "primary", "footer").
+   */
+  registerLocation(name, description) {
+    this.locations.set(name, { name, description });
+  }
+  /**
+   * Unregister a menu location.
+   */
+  unregisterLocation(name) {
+    return this.locations.delete(name);
+  }
+  /**
+   * Get all registered locations.
+   */
+  getLocations() {
+    return [...this.locations.values()];
+  }
+  /**
+   * Check if a location is registered.
+   */
+  hasLocation(name) {
+    return this.locations.has(name);
+  }
+  /**
+   * Build a tree from a flat list of menu items using parentId.
+   */
+  static buildTree(items) {
+    const map = /* @__PURE__ */ new Map();
+    const roots = [];
+    const sorted = [...items].sort((a, b) => a.menuOrder - b.menuOrder);
+    for (const item of sorted) {
+      map.set(item.id, { ...item, children: [] });
+    }
+    for (const item of sorted) {
+      const node = map.get(item.id);
+      if (item.parentId === 0) {
+        roots.push(node);
+      } else {
+        const parent = map.get(item.parentId);
+        if (parent) {
+          parent.children = parent.children ?? [];
+          parent.children.push(node);
+        } else {
+          roots.push(node);
+        }
+      }
+    }
+    return roots;
+  }
+  reset() {
+    this.locations.clear();
+  }
+};
+
+// src/url-rewrite.ts
+var STRUCTURE_TAGS = {
+  "%year%": { regex: "(?<year>\\d{4})", queryVar: "year" },
+  "%monthnum%": { regex: "(?<monthnum>\\d{2})", queryVar: "monthnum" },
+  "%day%": { regex: "(?<day>\\d{2})", queryVar: "day" },
+  "%hour%": { regex: "(?<hour>\\d{2})", queryVar: "hour" },
+  "%minute%": { regex: "(?<minute>\\d{2})", queryVar: "minute" },
+  "%second%": { regex: "(?<second>\\d{2})", queryVar: "second" },
+  "%postname%": { regex: "(?<postname>[^/]+)", queryVar: "name" },
+  "%post_id%": { regex: "(?<post_id>\\d+)", queryVar: "p" },
+  "%category%": { regex: "(?<category>[^/]+)", queryVar: "category_name" },
+  "%tag%": { regex: "(?<tag>[^/]+)", queryVar: "tag" },
+  "%author%": { regex: "(?<author>[^/]+)", queryVar: "author_name" },
+  "%pagename%": { regex: "(?<pagename>[^/]+)", queryVar: "pagename" }
+};
+var UrlRewriter = class {
+  rules = [];
+  /**
+   * Add a rewrite rule.
+   */
+  addRule(pattern, queryVars, source, priority = 10) {
+    this.rules.push({ pattern, queryVars, source, priority });
+    this.rules.sort((a, b) => a.priority - b.priority);
+  }
+  /**
+   * Generate rules from a permalink structure string.
+   * E.g., "/%year%/%monthnum%/%postname%/"
+   */
+  addPermalinkStructure(structure, source = "post_permalink") {
+    let regexStr = structure;
+    const queryVars = [];
+    for (const [tag, def] of Object.entries(STRUCTURE_TAGS)) {
+      if (regexStr.includes(tag)) {
+        regexStr = regexStr.replace(tag, def.regex);
+        queryVars.push(def.queryVar);
+      }
+    }
+    regexStr = regexStr.replace(/^\//, "").replace(/\/$/, "");
+    const pattern = new RegExp(`^${regexStr}/?$`);
+    this.addRule(pattern, queryVars, source, 5);
+  }
+  /**
+   * Add default rules for categories, tags, authors, search, pages, feeds.
+   */
+  addDefaultRules() {
+    this.addRule(/^category\/(?<category>[^/]+)\/?$/, ["category_name"], "category", 10);
+    this.addRule(/^tag\/(?<tag>[^/]+)\/?$/, ["tag"], "tag", 10);
+    this.addRule(/^author\/(?<author>[^/]+)\/?$/, ["author_name"], "author", 10);
+    this.addRule(/^search\/(?<s>.+)\/?$/, ["s"], "search", 10);
+    this.addRule(/^page\/(?<paged>\d+)\/?$/, ["paged"], "paging", 10);
+    this.addRule(/^feed\/?(?<feed>rss2?|atom|rdf)?\/?$/, ["feed"], "feed", 10);
+    this.addRule(/^(?<pagename>[^/]+)\/?$/, ["pagename"], "page", 99);
+  }
+  /**
+   * Resolve a URL path to query variables.
+   */
+  resolve(path) {
+    const cleanPath = path.replace(/^\//, "").replace(/\/$/, "");
+    for (const rule of this.rules) {
+      const match = cleanPath.match(rule.pattern);
+      if (match?.groups) {
+        const queryVars = {};
+        for (const [key, value] of Object.entries(match.groups)) {
+          if (value !== void 0) {
+            const tag = Object.entries(STRUCTURE_TAGS).find(
+              ([_, def]) => def.regex.includes(`<${key}>`)
+            );
+            queryVars[tag ? tag[1].queryVar : key] = value;
+          }
+        }
+        return { matched: true, rule, queryVars };
+      }
+    }
+    return { matched: false, queryVars: {} };
+  }
+  /**
+   * Build a permalink URL from a structure and values.
+   * E.g., buildPermalink("/%year%/%monthnum%/%postname%/", { year: "2026", monthnum: "04", postname: "hello" })
+   * → "/2026/04/hello/"
+   */
+  static buildPermalink(structure, values) {
+    let result = structure;
+    for (const [tag, def] of Object.entries(STRUCTURE_TAGS)) {
+      if (result.includes(tag) && values[def.queryVar]) {
+        result = result.replace(tag, values[def.queryVar]);
+      }
+    }
+    return result;
+  }
+  getRules() {
+    return [...this.rules];
+  }
+  reset() {
+    this.rules = [];
+  }
+};
+export {
+  BOOTSTRAP_PHASES,
+  BUILTIN_POST_TYPES,
+  BUILTIN_TAXONOMIES,
+  BootstrapManager,
+  ExtensionRegistry,
+  HOOK_PRIORITY,
+  HookEngine,
+  MenuRegistry,
+  POST_STATUS,
+  PostTypeRegistry,
+  ShortcodeRegistry,
+  TaxonomyRegistry,
+  ThemeRegistry,
+  USER_ROLES,
+  UrlRewriter,
+  resolveTemplateHierarchy
+};
 //# sourceMappingURL=index.js.map