@oktis-works/plugin-runtime 0.5.10 → 0.7.0

package/dist/bootstrap.d.ts

@@ -1,42 +1,43 @@
+import { type PluginJobHandler, type AdminExtensionsState, type PluginBlockManifest, type PluginPatternManifest, type EnqueuedAsset, type PluginHealthCheck } from '@oktis-works/plugin-sdk';
 import { type HookRegistry } from './hook-registry.js';
 import type { PluginApiDependencies, RouteDefinition } from './plugin-api.js';
 export interface BootstrapPluginsSql {
     unsafe(text: string, params?: unknown[]): Promise<unknown>;
 }
 export interface BootstrapPluginsOptions {
-    /** Diretório de plugins (o chamador resolve — plugin-runtime não conhece o core). */
+    /** Plugins directory (the caller resolves it — plugin-runtime doesn't know the core). */
     pluginsDir: string;
-    /** Cliente postgres para ler os habilitados; omitido = estado desconhecido (no-op). */
+    /** Postgres client to read enabled plugins; omitted = unknown state (no-op). */
     sql?: BootstrapPluginsSql;
-    /** Registry alvo (default: registry do escopo — platform ou `tenantId`). */
+    /** Target registry (default: the scope registry — platform or `tenantId`). */
     registry?: HookRegistry;
-    /** Statuses considerados habilitados (default: ACTIVATED, RUNNING). */
+    /** Statuses considered enabled (default: ACTIVATED, RUNNING). */
     enabledStatuses?: string[];
     /**
-     * Escopo de carga: `null`/omitido → platform (`plugins.tenant_id IS NULL`);
-     * string → tenant (`plugin_tenants` com status ENABLED).
+     * Load scope: `null`/omitted → platform (`plugins.tenant_id IS NULL`);
+     * string → tenant (`plugin_tenants` with ENABLED status).
      */
     tenantId?: string | null;
     /**
-     * Política de permissões concedidas (allowlist). Default: catálogo completo
-     * de permissões do CMS. Nunca é preenchida com as permissões do manifesto.
+     * Granted permission policy (allowlist). Default: the full CMS permission
+     * catalog. Never filled with the manifest's own permissions.
      */
     permissionPolicy?: string[];
-    /** Timeout de callbacks de hook em ms (0 = sem timeout). Default 5000. */
+    /** Hook callback timeout in ms (0 = no timeout). Default 5000. */
     hookTimeoutMs?: number;
     /**
-     * Dependências reais para a PluginAPI (settings, eventBus, db, etc.).
-     * Se omitido, usa apenas o Hooks API legado (compatibilidade).
-     * O core injeta isto com serviços reais.
+     * Real dependencies for the PluginAPI (settings, eventBus, db, etc.).
+     * When omitted, only the legacy Hooks API is used (compatibility).
+     * The core injects this with real services.
      */
     apiDeps?: Partial<PluginApiDependencies>;
 }
 export interface PluginBootstrapResult {
     /** Nomes habilitados no banco (vazio quando o banco falhou = estado desconhecido). */
     enabled: string[];
-    /** Registrados nesta sincronização. */
+    /** Loaded in this sync. */
     loaded: string[];
-    /** Hooks removidos nesta sincronização (saíram dos habilitados). */
+    /** Hooks removed in this sync (left the enabled list). */
     unloaded: string[];
     /** Falhas isoladas por plugin (nunca abortam o lote). */
     failed: Array<{
@@ -44,31 +45,95 @@ export interface PluginBootstrapResult {
         error: string;
     }>;
 }
-/** Escopo com carga registrada (para inspeção/estado de runtime). */
+/** Scope with registered loads (for inspection/runtime state). */
 export declare function listLoadedScopes(): Array<{
     scope: string;
     registry: HookRegistry;
     plugins: string[];
 }>;
-/** Obtém as rotas registradas pelos plugins em um escopo. */
+/** Gets the routes registered by plugins in a scope. */
 export declare function getLoadedPluginRoutes(scopeKey: string): Array<{
     pluginName: string;
     routes: RouteDefinition[];
+    /** Route rate-limit rpm (manifest rateLimit.rpm, Item 17). */
+    rpm?: number;
 }>;
 /**
- * Remove todos os hooks dos escopos carregados e limpa o estado.
- * Útil em testes e em shutdown. Quando `registry` é informado, os hooks são
- * removidos dele; caso contrário, do registry em que foram registrados.
+ * Handlers de jobs dos plugins em um escopo (dispatch pelo worker:
+ * `plugin:{tenant}:{plugin}:{jobName}` → handler).
+ */
+export declare function getLoadedPluginJobHandlers(scopeKey: string): Array<{
+    pluginName: string;
+    handlers: Map<string, PluginJobHandler>;
+}>;
+/**
+ * Runtime `api.admin` state of the plugins loaded in a scope (slots
+ * registered at runtime) — consumed by GET /api/v1/plugins/extensions, which
+ * merges it with `manifest.admin`. Only states with at least one entry are
+ * returned.
+ */
+export declare function getLoadedPluginAdminExtensions(scopeKey: string): Array<{
+    pluginName: string;
+    state: AdminExtensionsState;
+}>;
+/**
+ * Blocks registered at runtime via `api.registerBlock` by the plugins loaded
+ * in a scope — consumed by GET /api/v1/blocks, which merges them with
+ * `manifest.blocks`. Only plugins with at least one block are returned.
+ */
+export declare function getLoadedPluginBlocks(scopeKey: string): Array<{
+    pluginName: string;
+    blocks: Array<PluginBlockManifest & {
+        pluginName: string;
+    }>;
+}>;
+/**
+ * Patterns registered at runtime via `api.registerPattern` by the plugins
+ * loaded in a scope — consumed by GET /api/v1/patterns, which merges them
+ * with `manifest.patterns`. Only plugins with at least one pattern are
+ * returned.
+ */
+export declare function getLoadedPluginPatterns(scopeKey: string): Array<{
+    pluginName: string;
+    patterns: Array<PluginPatternManifest & {
+        pluginName: string;
+    }>;
+}>;
+/**
+ * Assets enqueued at runtime via `api.assets` by the plugins loaded in a
+ * scope — consumed by the public renderer (theme:head pipeline, Item 8).
+ * Only plugins with at least one asset are returned.
+ */
+export declare function getLoadedPluginAssets(scopeKey: string): Array<{
+    pluginName: string;
+    assets: EnqueuedAsset[];
+}>;
+/**
+ * Health checks registered at runtime via `api.health` by the plugins loaded
+ * in a scope — aggregated by GET /api/v1/health (Item 14). Only plugins with
+ * at least one check are returned.
+ */
+export declare function getLoadedPluginHealthChecks(scopeKey: string): Array<{
+    pluginName: string;
+    checks: Array<{
+        name: string;
+        check: PluginHealthCheck;
+    }>;
+}>;
+/**
+ * Removes all hooks from the loaded scopes and clears the state.
+ * Useful in tests and shutdown. When `registry` is given, hooks are removed
+ * from it; otherwise from the registry where they were registered.
  */
 export declare function resetLoadedPlugins(registry?: HookRegistry): void;
 /** Descarrega todos os plugins de um escopo (tenant desativado / LRU). */
 export declare function unloadScope(scopeKey: string): boolean;
-/** Descarrega um tenant (chave `tenant:<id>` ou o próprio id). */
+/** Unloads a tenant (key `tenant:<id>` or the id itself). */
 export declare function unloadTenant(tenantId: string): boolean;
 /**
  * Sincroniza o registry de um escopo com os plugins habilitados no banco.
  * Seguro para chamar no boot de qualquer processo e em re-syncs (ex.: logo
- * após ativar/desativar pela API).
+ * after enabling/disabling through the API).
  */
 export declare function bootstrapPlugins(options: BootstrapPluginsOptions): Promise<PluginBootstrapResult>;
 //# sourceMappingURL=bootstrap.d.ts.map

package/dist/bootstrap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bootstrap.d.ts","sourceRoot":"","sources":["../src/bootstrap.ts"],"names":[],"mappings":"AAuBA,OAAO,EAAyC,KAAK,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAC9F,OAAO,KAAK,EAAE,qBAAqB,EAAqB,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAEjG,MAAM,WAAW,mBAAmB;IAClC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CAC5D;AAED,MAAM,WAAW,uBAAuB;IACtC,qFAAqF;IACrF,UAAU,EAAE,MAAM,CAAC;IACnB,uFAAuF;IACvF,GAAG,CAAC,EAAE,mBAAmB,CAAC;IAC1B,4EAA4E;IAC5E,QAAQ,CAAC,EAAE,YAAY,CAAC;IACxB,uEAAuE;IACvE,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB;;;OAGG;IACH,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC5B,0EAA0E;IAC1E,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;;OAIG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC,qBAAqB,CAAC,CAAC;CAC1C;AAED,MAAM,WAAW,qBAAqB;IACpC,sFAAsF;IACtF,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,uCAAuC;IACvC,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,oEAAoE;IACpE,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,yDAAyD;IACzD,MAAM,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAChD;AAoCD,qEAAqE;AACrE,wBAAgB,gBAAgB,IAAI,KAAK,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,YAAY,CAAC;IAAC,OAAO,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,CAMtG;AAED,6DAA6D;AAC7D,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,KAAK,CAAC;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,eAAe,EAAE,CAAA;CAAE,CAAC,CAahH;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,CAAC,EAAE,YAAY,GAAG,IAAI,CAWhE;AAED,0EAA0E;AAC1E,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAWrD;AAED,kEAAkE;AAClE,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAEtD;AA6DD;;;;GAIG;AACH,wBAAsB,gBAAgB,CAAC,OAAO,EAAE,uBAAuB,GAAG,OAAO,CAAC,qBAAqB,CAAC,CA4HvG"}
+{"version":3,"file":"bootstrap.d.ts","sourceRoot":"","sources":["../src/bootstrap.ts"],"names":[],"mappings":"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"}

package/dist/bootstrap.js

@@ -1,21 +1,22 @@
-// @oktis-works/plugin-runtime - Bootstrap de plugins em runtime
+// @oktis-works/plugin-runtime - Plugin runtime bootstrap
 //
-// O PLUGIN.md promete: "`register(registry)` é chamado quando o plugin é
-// carregado". Este módulo cumpre a promessa: descobre os plugins habilitados
-// no banco (escopo **platform** = `tenant_id IS NULL`; escopo **tenant** =
-// `plugin_tenants` habilitados), importa o entrypoint, chama
-// `register(registry)` com uma API de hooks atribuída ao plugin (BUSI-032/033)
-// e sincroniza o registry do escopo.
+// PLUGIN.md promises: "`register(registry)` is called when the plugin is
+// loaded". This module honors it: discovers enabled plugins in the database
+// (**platform** scope = `tenant_id IS NULL`; **tenant** scope = enabled
+// `plugin_tenants`), imports the entrypoint, calls `register(registry)` with
+// a hook API attributed to the plugin (BUSI-032/033) and syncs the scope
+// registry.
 //
-// Regras:
-//   - **nunca lança**: plugin quebrado, manifesto inválido, incompatibilidade
-//     semântica ou banco indisponível não derrubam o boot (isolamento de falha);
-//   - **sincroniza com o banco**: quem saiu da lista de habilitados tem os
-//     hooks removidos do registry (unload);
-//   - **idempotente**: plugin já carregado não é recarregado (sem hooks
-//     duplicados) — chamadas repetidas carregam só o que é novo;
-//   - **por escopo**: o estado de carga é indexado por escopo (platform ou um
-//     tenant), então ativar/desativar num tenant não afeta outro.
+// Rules:
+//   - **never throws**: a broken plugin, invalid manifest, semantic
+//     incompatibility or an unavailable database never break the boot
+//     (failure isolation);
+//   - **syncs with the database**: anything that left the enabled list has
+//     its hooks removed from the registry (unload);
+//   - **idempotent**: an already-loaded plugin is not reloaded (no duplicate
+//     hooks) — repeated calls load only what is new;
+//   - **per scope**: load state is indexed by scope (platform or a tenant),
+//     so enabling/disabling in one tenant does not affect another.
 import { createPluginHooksApi } from '@oktis-works/plugin-sdk';
 import { PLUGIN_PERMISSION_DEFAULT } from '@oktis-works/validation';
 import { PluginLoader } from './loader.js';
@@ -23,8 +24,10 @@ import { PluginSandbox } from './sandbox.js';
 import { getHookRegistry, getHookRegistryStore } from './hook-registry.js';
 /** Estado de carga por escopo (`''` = platform, `tenant:<id>` = tenant). */
 const loadedScopes = new Map();
+/** Platform scope uses the same key as the core ('platform') — external lookups match. */
+const PLATFORM_SCOPE = 'platform';
 function scopeKeyOf(tenantId) {
-    return tenantId ? `tenant:${tenantId}` : '';
+    return tenantId ? `tenant:${tenantId}` : PLATFORM_SCOPE;
 }
 function getScope(scopeKey, registry) {
     let scope = loadedScopes.get(scopeKey);
@@ -34,7 +37,7 @@ function getScope(scopeKey, registry) {
     }
     return scope;
 }
-/** Escopo com carga registrada (para inspeção/estado de runtime). */
+/** Scope with registered loads (for inspection/runtime state). */
 export function listLoadedScopes() {
     return [...loadedScopes.entries()].map(([scope, entry]) => ({
         scope,
@@ -42,7 +45,7 @@ export function listLoadedScopes() {
         plugins: [...entry.plugins.keys()],
     }));
 }
-/** Obtém as rotas registradas pelos plugins em um escopo. */
+/** Gets the routes registered by plugins in a scope. */
 export function getLoadedPluginRoutes(scopeKey) {
     const scope = loadedScopes.get(scopeKey);
     if (!scope)
@@ -52,16 +55,134 @@ export function getLoadedPluginRoutes(scopeKey) {
         if (entry.internal) {
             const routes = entry.internal.getRoutes();
             if (routes.length > 0) {
-                result.push({ pluginName, routes });
+                const rpm = entry.manifest?.rateLimit?.rpm;
+                result.push({ pluginName, routes, ...(typeof rpm === 'number' && rpm > 0 ? { rpm } : {}) });
             }
         }
     }
     return result;
 }
 /**
- * Remove todos os hooks dos escopos carregados e limpa o estado.
- * Útil em testes e em shutdown. Quando `registry` é informado, os hooks são
- * removidos dele; caso contrário, do registry em que foram registrados.
+ * Handlers de jobs dos plugins em um escopo (dispatch pelo worker:
+ * `plugin:{tenant}:{plugin}:{jobName}` → handler).
+ */
+export function getLoadedPluginJobHandlers(scopeKey) {
+    const scope = loadedScopes.get(scopeKey);
+    if (!scope)
+        return [];
+    const result = [];
+    for (const [pluginName, entry] of scope.plugins) {
+        if (entry.internal) {
+            const handlers = entry.internal.getJobHandlers?.();
+            if (handlers && handlers.size > 0) {
+                result.push({ pluginName, handlers });
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Runtime `api.admin` state of the plugins loaded in a scope (slots
+ * registered at runtime) — consumed by GET /api/v1/plugins/extensions, which
+ * merges it with `manifest.admin`. Only states with at least one entry are
+ * returned.
+ */
+export function getLoadedPluginAdminExtensions(scopeKey) {
+    const scope = loadedScopes.get(scopeKey);
+    if (!scope)
+        return [];
+    const result = [];
+    for (const [pluginName, entry] of scope.plugins) {
+        const state = entry.internal?.getAdminState?.();
+        if (!state)
+            continue;
+        const hasEntries = state.menuPages.length > 0 ||
+            state.submenuPages.length > 0 ||
+            state.dashboardWidgets.length > 0 ||
+            state.metaBoxes.length > 0 ||
+            state.notices.length > 0 ||
+            state.actionLinks.length > 0 ||
+            (state.editors?.length ?? 0) > 0 ||
+            Object.keys(state.columns).length > 0 ||
+            Object.keys(state.columnRenderers).length > 0;
+        if (hasEntries)
+            result.push({ pluginName, state });
+    }
+    return result;
+}
+/**
+ * Blocks registered at runtime via `api.registerBlock` by the plugins loaded
+ * in a scope — consumed by GET /api/v1/blocks, which merges them with
+ * `manifest.blocks`. Only plugins with at least one block are returned.
+ */
+export function getLoadedPluginBlocks(scopeKey) {
+    const scope = loadedScopes.get(scopeKey);
+    if (!scope)
+        return [];
+    const result = [];
+    for (const [pluginName, entry] of scope.plugins) {
+        const blocks = entry.internal?.getBlocks?.();
+        if (blocks && blocks.length > 0)
+            result.push({ pluginName, blocks });
+    }
+    return result;
+}
+/**
+ * Patterns registered at runtime via `api.registerPattern` by the plugins
+ * loaded in a scope — consumed by GET /api/v1/patterns, which merges them
+ * with `manifest.patterns`. Only plugins with at least one pattern are
+ * returned.
+ */
+export function getLoadedPluginPatterns(scopeKey) {
+    const scope = loadedScopes.get(scopeKey);
+    if (!scope)
+        return [];
+    const result = [];
+    for (const [pluginName, entry] of scope.plugins) {
+        const patterns = entry.internal?.getPatterns?.();
+        if (patterns && patterns.length > 0)
+            result.push({ pluginName, patterns });
+    }
+    return result;
+}
+/**
+ * Assets enqueued at runtime via `api.assets` by the plugins loaded in a
+ * scope — consumed by the public renderer (theme:head pipeline, Item 8).
+ * Only plugins with at least one asset are returned.
+ */
+export function getLoadedPluginAssets(scopeKey) {
+    const scope = loadedScopes.get(scopeKey);
+    if (!scope)
+        return [];
+    const result = [];
+    for (const [pluginName, entry] of scope.plugins) {
+        const assets = entry.internal?.getEnqueuedAssets?.();
+        if (assets && assets.length > 0)
+            result.push({ pluginName, assets });
+    }
+    return result;
+}
+/**
+ * Health checks registered at runtime via `api.health` by the plugins loaded
+ * in a scope — aggregated by GET /api/v1/health (Item 14). Only plugins with
+ * at least one check are returned.
+ */
+export function getLoadedPluginHealthChecks(scopeKey) {
+    const scope = loadedScopes.get(scopeKey);
+    if (!scope)
+        return [];
+    const result = [];
+    for (const [pluginName, entry] of scope.plugins) {
+        const checks = entry.internal?.getHealthChecks?.();
+        if (checks && checks.length > 0)
+            result.push({ pluginName, checks });
+    }
+    return result;
+}
+/**
+ * Removes all hooks from the loaded scopes and clears the state.
+ * Useful in tests and shutdown. When `registry` is given, hooks are removed
+ * from it; otherwise from the registry where they were registered.
  */
 export function resetLoadedPlugins(registry) {
     for (const [scopeKey, scope] of loadedScopes) {
@@ -93,7 +214,7 @@ export function unloadScope(scopeKey) {
     loadedScopes.delete(scopeKey);
     return true;
 }
-/** Descarrega um tenant (chave `tenant:<id>` ou o próprio id). */
+/** Unloads a tenant (key `tenant:<id>` or the id itself). */
 export function unloadTenant(tenantId) {
     return unloadScope(scopeKeyOf(tenantId));
 }
@@ -112,9 +233,9 @@ function unloadPlugin(scope, name) {
 }
 /**
  * Registry que grava cada registro num sink (para poder descarregar depois),
- * delega ao registry real com `sourceId` atribuído pelo SDK e **aplica o
- * timeout do sandbox** no callback registrado (WP5 — proteção real contra hook
- * pendurado; documentada como limitada a trabalho assíncrono).
+ * delegates to the real registry with the SDK-attributed `sourceId` and
+ * **applies the sandbox timeout** to the registered callback (WP5 — real
+ * protection against a hanging hook; documented as limited to async work).
  */
 function recordingRegistry(registry, sink, sandbox) {
     const acceptedArgsOf = (callback, explicit) => explicit ?? callback.length;
@@ -153,7 +274,7 @@ function enabledQuery(tenantId) {
 /**
  * Sincroniza o registry de um escopo com os plugins habilitados no banco.
  * Seguro para chamar no boot de qualquer processo e em re-syncs (ex.: logo
- * após ativar/desativar pela API).
+ * after enabling/disabling through the API).
  */
 export async function bootstrapPlugins(options) {
     const scopeKey = scopeKeyOf(options.tenantId);
@@ -161,7 +282,7 @@ export async function bootstrapPlugins(options) {
         (options.tenantId ? getHookRegistryStore().tenant(options.tenantId) : getHookRegistry());
     const statuses = options.enabledStatuses ?? ['ACTIVATED', 'RUNNING'];
     const result = { enabled: [], loaded: [], unloaded: [], failed: [] };
-    // 1) Quem está habilitado no banco? Falha = estado desconhecido → não toca em nada.
+    // 1) Who is enabled in the database? Failure = unknown state → touch nothing.
     let enabled = null;
     if (options.sql) {
         try {
@@ -178,7 +299,7 @@ export async function bootstrapPlugins(options) {
     result.enabled = enabled ?? [];
     if (enabled === null)
         return result;
-    // 2) Descobre no diretório (diretório ausente = nenhum plugin, não é erro)
+    // 2) Discovers in the directory (missing directory = no plugins, not an error)
     const loader = new PluginLoader(options.pluginsDir);
     let discovered = [];
     try {
@@ -194,16 +315,16 @@ export async function bootstrapPlugins(options) {
             result.unloaded.push(name);
         }
     }
-    // 4) Carrega habilitados ainda não carregados, respeitando ordem de dependência
+    // 4) Loads enabled-but-not-yet-loaded plugins, honoring dependency order
     const enabledDiscovered = discovered.filter((entry) => enabled.includes(entry.manifest.name));
     let levels;
     try {
         levels = loader.resolveDependencies(enabledDiscovered);
     }
     catch {
-        levels = enabledDiscovered.map((entry) => [entry]); // ordenação falhou: ordem arbitrária
+        levels = enabledDiscovered.map((entry) => [entry]); // ordering failed: arbitrary order
     }
-    // Política de permissões: allowlist de configuração (ou catálogo completo).
+    // Permission policy: configuration allowlist (or the full catalog).
     const policy = options.permissionPolicy ?? PLUGIN_PERMISSION_DEFAULT;
     const timeoutMs = options.hookTimeoutMs ?? 5000;
     for (const level of levels) {
@@ -213,21 +334,31 @@ export async function bootstrapPlugins(options) {
                 continue;
             try {
                 const loaded = await loader.loadPlugin(entry.manifest, entry.path);
-                // O sandbox valida o manifesto contra a POLÍTICA (nunca contra si mesmo)
+                // The sandbox validates the manifest against the POLICY (never against itself)
                 const sandbox = new PluginSandbox({ allowedPermissions: [...policy], timeoutMs });
                 sandbox.loadPlugin(entry.manifest, loaded.api);
                 // Contrato do PLUGIN.md: module.exports.register(registry)
                 const register = loaded.api.register;
                 if (typeof register !== 'function') {
-                    throw new Error('não exporta register(registry)');
+                    throw new Error('does not export register(registry)');
+                }
+                // Item 20: plugin schema migrations (manifest.migrations[]) run
+                // BEFORE register(), once per plugin (global registry in
+                // plugin_schema_migrations). Checksum drift fails the plugin isolated.
+                if (options.sql && Array.isArray(entry.manifest.migrations) && entry.manifest.migrations.length > 0) {
+                    const { applyPluginMigrations } = await import('./plugin-migrations.js');
+                    const migrationResult = await applyPluginMigrations(options.sql, name, entry.path, entry.manifest.migrations);
+                    if (migrationResult.drift.length > 0) {
+                        throw new Error(`Plugin migration drift: ${migrationResult.drift.join('; ')}`);
+                    }
                 }
                 const registrations = [];
                 // Se o core forneceu apiDeps, cria a API completa (hooks + settings + query + routes + ...)
-                // Caso contrário, usa apenas o Hooks API legado (compatibilidade).
+                // Otherwise, only the legacy Hooks API is used (compatibility).
                 let apiToPass;
                 let internal;
                 if (options.apiDeps) {
-                    // Mescla os deps do core com os específicos do plugin/runtime
+                    // Merges the core deps with the plugin/runtime-specific ones
                     const deps = {
                         hooks: recordingRegistry(registry, registrations, sandbox),
                         manifest: entry.manifest,
@@ -241,28 +372,109 @@ export async function bootstrapPlugins(options) {
                         getUserById: options.apiDeps.getUserById ?? (async () => null),
                         registerRoutes: options.apiDeps.registerRoutes ?? (() => { }),
                         registerContentFields: options.apiDeps.registerContentFields ?? (() => { }),
+                        registerFieldTypes: options.apiDeps.registerFieldTypes ?? (() => { }),
+                        registerPostTypes: options.apiDeps.registerPostTypes ?? (() => { }),
+                        registerTaxonomies: options.apiDeps.registerTaxonomies ?? (() => { }),
+                        // Core cache backend; absent → in-memory fallback in the factory
+                        cache: options.apiDeps.cache,
+                        // Backend de jobs do core; ausente → schedule/enqueue retornam false
+                        jobs: options.apiDeps.jobs,
                         allowedPermissions: [...policy],
                     };
-                    // Cria a API completa usando a fábrica interna
+                    // Creates the full API using the internal factory
                     const { createPluginApi } = await import('./plugin-api.js');
                     const apiResult = createPluginApi(deps);
                     apiToPass = apiResult.api;
                     internal = apiResult.internal;
+                    // Item 9: loads the manifest `locales[]` files before register()
+                    // — translations already available during boot. File failure is
+                    // silent (fallback = the key itself).
+                    try {
+                        const { loadPluginLocales } = await import('./i18n.js');
+                        const i18n = apiResult.api.i18n;
+                        if (i18n)
+                            await loadPluginLocales(entry.path, entry.manifest, i18n);
+                    }
+                    catch {
+                        // i18n unavailable — boot continues
+                    }
                 }
                 else {
                     apiToPass = createPluginHooksApi(name, recordingRegistry(registry, registrations, sandbox));
                 }
-                register(apiToPass);
+                // register() may be async — we await it (with the same hook timeout)
+                // so rejections become an isolated failure instead of an unhandled
+                // rejection: previously a throwing async register escaped the
+                // try/catch and became an unhandled process error.
+                await Promise.race([
+                    Promise.resolve(register(apiToPass)),
+                    new Promise((_, reject) => {
+                        const timer = setTimeout(() => reject(new Error(`register() excedeu ${timeoutMs}ms`)), timeoutMs);
+                        timer.unref?.();
+                    }),
+                ]);
                 if (internal) {
-                    scope.plugins.set(name, { registrations, internal });
+                    scope.plugins.set(name, { registrations, internal, manifest: entry.manifest });
+                    // Declarative manifest registration (v2): postTypes/taxonomies go
+                    // through the same API validation (permission, slug, conflict) and
+                    // the factory persists via the core registerPostTypes/registerTaxonomies.
+                    if (entry.manifest.postTypes?.length || entry.manifest.taxonomies?.length) {
+                        try {
+                            const typedApi = apiToPass;
+                            for (const postType of entry.manifest.postTypes ?? []) {
+                                typedApi.addPostType(postType);
+                            }
+                            for (const taxonomy of entry.manifest.taxonomies ?? []) {
+                                typedApi.addTaxonomy(taxonomy);
+                            }
+                        }
+                        catch (e) {
+                            console.warn(`[plugins] Failed to register declared post types/taxonomies for ${name}:`, e);
+                        }
+                    }
+                    // Jobs declarados no manifesto (v2): agenda recorrente via api.jobs
+                    // (same validation/permission/ceiling as the imperative path).
+                    if (entry.manifest.scheduleJobs?.length) {
+                        const typedApi = apiToPass;
+                        for (const job of entry.manifest.scheduleJobs) {
+                            try {
+                                await typedApi.jobs.schedule(job.name, { every: job.every, cron: job.cron });
+                            }
+                            catch (e) {
+                                console.warn(`[plugins] Failed to schedule declared job "${job.name}" for ${name}:`, e);
+                            }
+                        }
+                    }
+                    // Persist field types registered by this plugin
+                    if (internal.getFieldTypes && internal.getFieldTypes().length > 0) {
+                        const fieldTypes = internal.getFieldTypes();
+                        try {
+                            // Import fieldTypeExtensionService dynamically to avoid circular deps:
+                            // core depends on plugin-runtime, so plugin-runtime cannot declare core
+                            // as a dependency (and packages/core/dist does not exist yet when this
+                            // package is built). A non-literal specifier keeps TypeScript from
+                            // resolving the module at compile time; resolution happens at runtime.
+                            const coreModuleId = '@oktis-works/core';
+                            const core = (await import(coreModuleId));
+                            const { fieldTypeExtensionService } = core;
+                            for (const ft of fieldTypes) {
+                                await fieldTypeExtensionService.register(ft);
+                            }
+                            // Sync to in-memory registry
+                            await fieldTypeExtensionService.syncToRegistry();
+                        }
+                        catch (e) {
+                            console.warn(`[plugins] Failed to persist field types for ${name}:`, e);
+                        }
+                    }
                 }
                 else {
-                    scope.plugins.set(name, { registrations });
+                    scope.plugins.set(name, { registrations, manifest: entry.manifest });
                 }
                 result.loaded.push(name);
             }
             catch (error) {
-                // Isolamento de falha: plugin quebrado não impede os demais nem o boot
+                // Failure isolation: a broken plugin never blocks the others or the boot
                 result.failed.push({ name, error: error instanceof Error ? error.message : String(error) });
             }
         }