@fayz-ai/plugin-blog 0.9.0 → 0.11.0

package/dist/index.js

@@ -1,5 +1,5 @@
 import { createContext, useContext, useState, useEffect, createElement } from 'react';
-import { useSeo, createSafeDataProvider, getActiveTenantId, getSupabaseClientOptional, organizationJsonLd, absoluteUrl, breadcrumbJsonLd } from '@fayz-ai/core';
+import { absoluteUrl, organizationJsonLd, breadcrumbJsonLd, useSeo, hasLoader, defineLoader, createSafeDataProvider, getActiveTenantId, getSupabaseClientOptional } from '@fayz-ai/core';
 import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
 import { Link, useParams } from 'react-router-dom';
 import { Clock } from 'lucide-react';
@@ -200,11 +200,17 @@ function PostCard({ post, basePath = "/blog" }) {
     }
   );
 }
-function postUrl(basePath, slug) {
-  return absoluteUrl(`${basePath}/${slug}`);
+function blogUrl(basePath, path, origin) {
+  const joined = `${basePath}${path}`.replace(/\/+/g, "/");
+  if (origin) return `${origin.replace(/\/$/, "")}${joined.startsWith("/") ? joined : `/${joined}`}`;
+  const ambient = absoluteUrl(joined);
+  return ambient.startsWith("http") ? ambient : void 0;
+}
+function postUrl(basePath, slug, origin) {
+  return blogUrl(basePath, `/${slug}`, origin);
 }
 function articleJsonLd(post, opts) {
-  const url = postUrl(opts.basePath, post.slug);
+  const url = postUrl(opts.basePath, post.slug, opts.origin);
   const posting = {
     "@context": "https://schema.org",
     "@type": "BlogPosting",
@@ -212,7 +218,7 @@ function articleJsonLd(post, opts) {
     description: post.excerpt,
     image: post.image ? [post.image] : void 0,
     articleSection: post.tag,
-    mainEntityOfPage: { "@type": "WebPage", "@id": url },
+    ...url ? { mainEntityOfPage: { "@type": "WebPage", "@id": url } } : {},
     author: {
       "@type": "Person",
       name: post.author.name,
@@ -221,11 +227,9 @@ function articleJsonLd(post, opts) {
     ...post.publishedAt ? { datePublished: post.publishedAt, dateModified: post.publishedAt } : {},
     ...opts.siteName ? { publisher: organizationJsonLd(opts.siteName) } : {}
   };
-  const breadcrumb = breadcrumbJsonLd([
-    { name: "Blog", url: absoluteUrl(opts.basePath) },
-    { name: post.title, url }
-  ]);
-  return [posting, breadcrumb];
+  const listUrl = blogUrl(opts.basePath, "", opts.origin);
+  if (!url || !listUrl) return [posting];
+  return [posting, breadcrumbJsonLd([{ name: "Blog", url: listUrl }, { name: post.title, url }])];
 }
 function blogJsonLd(posts, opts) {
   return [
@@ -233,12 +237,12 @@ function blogJsonLd(posts, opts) {
       "@context": "https://schema.org",
       "@type": "Blog",
       name: opts.title,
-      url: absoluteUrl(opts.basePath),
+      ...blogUrl(opts.basePath, "", opts.origin) ? { url: blogUrl(opts.basePath, "", opts.origin) } : {},
       ...opts.siteName ? { publisher: organizationJsonLd(opts.siteName) } : {},
       blogPost: posts.map((p) => ({
         "@type": "BlogPosting",
         headline: p.title,
-        url: postUrl(opts.basePath, p.slug),
+        ...postUrl(opts.basePath, p.slug, opts.origin) ? { url: postUrl(opts.basePath, p.slug, opts.origin) } : {},
         image: p.image,
         author: { "@type": "Person", name: p.author.name },
         ...p.publishedAt ? { datePublished: p.publishedAt } : {}
@@ -246,6 +250,28 @@ function blogJsonLd(posts, opts) {
     }
   ];
 }
+function postSeo(post, opts) {
+  return {
+    title: opts.siteName ? `${post.title} \u2014 ${opts.siteName}` : post.title,
+    description: post.excerpt?.slice(0, 160),
+    canonical: postUrl(opts.basePath, post.slug, opts.origin),
+    image: post.image,
+    // 'article', not 'website': it is what tells a share card to show the author
+    // and published date rather than treating the post as a site landing page.
+    type: "article",
+    jsonLd: articleJsonLd(post, opts)
+  };
+}
+function blogListSeo(posts, opts) {
+  return {
+    title: opts.siteName ? `${opts.title} \u2014 ${opts.siteName}` : opts.title,
+    description: opts.description,
+    canonical: blogUrl(opts.basePath, "", opts.origin),
+    image: posts.find((p) => p.image)?.image,
+    type: "website",
+    jsonLd: blogJsonLd(posts, opts)
+  };
+}
 function BlogList() {
   const { config } = useBlogContext();
   const { posts, loading, error } = useBlogPosts();
@@ -468,19 +494,863 @@ FROM public.plg_blog_posts p
 LEFT JOIN public.plg_blog_categories c ON c.id = p.category_id
 WHERE p.status = 'published';
 
+GRANT SELECT ON public.v_public_blog_posts TO anon, authenticated, service_role;
+`;
+var MIGRATION_002_EXTERNAL_POSTS = `-- ============================================================================
+-- plugin-blog 002: the ingest seam \u2014 per-post SEO, external identity, and the
+-- single function an outside publisher passes through.
+--
+-- 001 gave the blog a content model written by one hand: the backoffice, behind
+-- a session, through RLS. RankLayer publishes INTO the tenant instead, so the
+-- write arrives from a machine we do not run, carrying HTML we did not author
+-- and an identity that lives in someone else's database. Three things follow,
+-- and each is a section here.
+--
+--   \xA71  columns    per-post SEO + the external identity (external_ref, source\u2026)
+--   \xA72  identity   partial unique index on (tenant_id, external_ref)
+--   \xA73  sanitiser  plg_blog_sanitize_html \u2014 a tag allowlist, in SQL
+--   \xA74  ingest     blog_upsert_external_post(p_payload jsonb)
+--   \xA75  agent      agent_blog_draft_post \u2014 the assistant's write, guarded
+--   \xA76  facts      blog.post.{created,updated,published,deleted}
+--   \xA77  view       v_public_blog_posts extended with the SEO the site renders
+--
+-- Additive and idempotent: no table is created, no policy is rewritten, the
+-- existing tenant RLS from 001 already covers every column added here.
+-- ============================================================================
+
+-- \xA71 \u2500\u2500 columns \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+-- Per-post SEO. The blog already had site-level SEO (lib/seo.ts builds the
+-- descriptors), but an organic-SEO product's whole output is per-ARTICLE: the
+-- title it wants in the SERP is not the title on the page, and a syndicated
+-- post has a canonical that points somewhere else entirely.
+ALTER TABLE public.plg_blog_posts ADD COLUMN IF NOT EXISTS meta_title       text;
+ALTER TABLE public.plg_blog_posts ADD COLUMN IF NOT EXISTS meta_description text;
+ALTER TABLE public.plg_blog_posts ADD COLUMN IF NOT EXISTS canonical_url    text;
+ALTER TABLE public.plg_blog_posts ADD COLUMN IF NOT EXISTS og_image         text;
+ALTER TABLE public.plg_blog_posts ADD COLUMN IF NOT EXISTS noindex          boolean NOT NULL DEFAULT false;
+
+-- The external identity. \`external_ref\` is the publisher's id for the article \u2014
+-- ours is a uuid it has never seen, so re-delivery can only be recognised by
+-- theirs. \`source\` is the anti-loop field: it names who WROTE the post, and a
+-- connector reads it to avoid echoing an article back to the system it came
+-- from. Defaulting to 'admin' is not a placeholder \u2014 every row that exists
+-- today was written by a person in the backoffice, and saying so is what makes
+-- the field usable from the first event.
+ALTER TABLE public.plg_blog_posts ADD COLUMN IF NOT EXISTS external_ref     text;
+ALTER TABLE public.plg_blog_posts ADD COLUMN IF NOT EXISTS source           text NOT NULL DEFAULT 'admin';
+ALTER TABLE public.plg_blog_posts ADD COLUMN IF NOT EXISTS language         text;
+ALTER TABLE public.plg_blog_posts ADD COLUMN IF NOT EXISTS tags             text[];
+ALTER TABLE public.plg_blog_posts ADD COLUMN IF NOT EXISTS author_member_id uuid
+  REFERENCES public.tenant_members(id) ON DELETE SET NULL;
+
+-- \xA72 \u2500\u2500 identity \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+-- This index is the whole of idempotency. Without it the same article delivered
+-- twice \u2014 a retry, a redeployed connector, a replayed queue \u2014 lands as two
+-- posts with two slugs, and the tenant's blog grows duplicates nobody ordered.
+-- Partial because the backoffice's own posts have no external ref and must not
+-- collide with each other on NULL.
+CREATE UNIQUE INDEX IF NOT EXISTS uq_plg_blog_posts_tenant_external_ref
+  ON public.plg_blog_posts (tenant_id, external_ref)
+  WHERE external_ref IS NOT NULL;
+
+-- "What did this source publish here?" is the connector's own reconciliation
+-- query, and the ledger's.
+CREATE INDEX IF NOT EXISTS idx_plg_blog_posts_source
+  ON public.plg_blog_posts (tenant_id, source, updated_at DESC);
+
+-- \xA73 \u2500\u2500 sanitiser \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+-- The sanitising happens HERE, in the function, and not in the client that
+-- renders the post. The RPC below is the only door an external publisher passes
+-- through; a browser-side sanitiser protects the one reader whose browser runs
+-- it and nothing else \u2014 the row is already poisoned, the RSS feed, the sitemap
+-- and every server-rendered page still carry the script. A control has to sit
+-- where the data enters, not where it is displayed.
+
+-- Extract one attribute from a tag, tolerating the three ways HTML quotes a
+-- value. \`p_name\` is always a literal this file controls, never caller input.
+CREATE OR REPLACE FUNCTION public.plg_blog_html_attr(p_tag text, p_name text)
+RETURNS text
+LANGUAGE sql
+IMMUTABLE
+AS $fn$
+  SELECT coalesce(
+    substring(p_tag from '(?i)\\s' || p_name || '\\s*=\\s*"([^"]*)"'),
+    substring(p_tag from '(?i)\\s' || p_name || '\\s*=\\s*''([^'']*)'''),
+    substring(p_tag from '(?i)\\s' || p_name || '\\s*=\\s*([^\\s">]+)')
+  );
+$fn$;
+
+CREATE OR REPLACE FUNCTION public.plg_blog_html_escape(p_text text)
+RETURNS text
+LANGUAGE sql
+IMMUTABLE
+AS $fn$
+  SELECT replace(replace(replace(coalesce(p_text, ''), '<', '&lt;'), '>', '&gt;'), '"', '&quot;');
+$fn$;
+
+-- A URL we are willing to put back into the document.
+CREATE OR REPLACE FUNCTION public.plg_blog_safe_url(p_url text)
+RETURNS text
+LANGUAGE plpgsql
+IMMUTABLE
+AS $fn$
+DECLARE
+  v text;
+BEGIN
+  IF p_url IS NULL THEN RETURN NULL; END IF;
+  -- Whitespace and control characters go BEFORE the scheme test: \`java\\tscript:\`
+  -- is a working URL in every browser and would pass a naive prefix check.
+  v := regexp_replace(btrim(p_url), '[[:space:][:cntrl:]]', '', 'g');
+  IF v = '' THEN RETURN NULL; END IF;
+  -- Allowlist of schemes. \`data:\` is absent on purpose: a data URL is a way to
+  -- ship a whole document \u2014 including an SVG that scripts \u2014 inside an href.
+  IF v ~* '^(https?://|mailto:|/|#)' THEN
+    RETURN public.plg_blog_html_escape(v);
+  END IF;
+  RETURN NULL;
+END;
+$fn$;
+
+CREATE OR REPLACE FUNCTION public.plg_blog_sanitize_html(p_html text)
+RETURNS text
+LANGUAGE plpgsql
+IMMUTABLE
+SET search_path = public
+AS $fn$
+DECLARE
+  -- The allowlist is what an ARTICLE is made of. Layout tags (div, span,
+  -- section, main) are deliberately out: they carry nothing a blog post needs
+  -- and every one of them is a place to hang an attribute. Anything not listed
+  -- loses its tag and keeps its text, so a stripped wrapper degrades to prose
+  -- rather than to a hole in the article.
+  c_allowed constant text[] := ARRAY[
+    'p','br','hr','h1','h2','h3','h4','h5','h6',
+    'strong','b','em','i','u','s','sup','sub','code','pre','blockquote','q','cite',
+    'ul','ol','li','dl','dt','dd',
+    'a','img','figure','figcaption',
+    'table','thead','tbody','tfoot','tr','th','td','caption'
+  ];
+  c_void constant text[] := ARRAY['br','hr','img'];
+  -- Elements whose CONTENT is code rather than text.
+  c_active constant text :=
+    'script|style|iframe|object|embed|applet|form|noscript|svg|math|template|frameset|frame';
+  v       text;
+  v_rest  text;
+  v_out   text := '';
+  v_lt    int;
+  v_gt    int;
+  v_tag   text;
+  v_name  text;
+  v_val   text;
+  v_attrs text;
+BEGIN
+  IF p_html IS NULL OR btrim(p_html) = '' THEN RETURN ''; END IF;
+  v := p_html;
+
+  -- Comments first: a conditional comment is executable markup in older
+  -- engines, and \`<!-- <script>\u2026 -->\` would otherwise reach the pass below
+  -- already commented out and survive it.
+  v := regexp_replace(v, '<!--.*?-->', '', 'g');
+  v := regexp_replace(v, '<!\\[CDATA\\[.*?\\]\\]>', '', 'g');
+  v := regexp_replace(v, '<\\?.*?\\?>', '', 'g');
+
+  -- Active elements go whole. Dropping only the tag would leave the script body
+  -- standing as visible page text \u2014 the article would read as vandalised even
+  -- though nothing executed.
+  -- Two Postgres regex traps, both of which fail OPEN and were caught by
+  -- running this against a container rather than by reading it:
+  --   \`\\y\`, not \`\\b\` \u2014 in a Postgres RE \`\\b\` is the BACKSPACE character, so
+  --   \`<script\\b\` matches nothing and the script body survives as page text.
+  --   Every quantifier non-greedy \u2014 a Postgres RE takes its greediness from its
+  --   FIRST quantifier, so one greedy \`\\s*\` at the front makes the trailing
+  --   \`.*?\` greedy too, and the first <script> swallows the article down to the
+  --   last closing tag in the document.
+  v := regexp_replace(v, '<\\s*?(' || c_active || ')\\y[^>]*?>.*?<\\s*?/\\s*?\\1\\s*?>', '', 'gi');
+  -- \u2026and the unbalanced halves of the same set, plus the document-level tags
+  -- that have no business inside an article body.
+  v := regexp_replace(
+    v,
+    '<\\s*/?\\s*(' || c_active || '|link|meta|base|title|head|body|html)\\y[^>]*>',
+    '', 'gi');
+
+  -- Walk the remaining tags. A rewrite rather than a filter: every tag that
+  -- comes out the other side was BUILT here from a name and an allowlisted
+  -- attribute, so nothing an attacker wrote is copied through by accident.
+  v_rest := v;
+  LOOP
+    v_lt := position('<' in v_rest);
+    IF v_lt = 0 THEN
+      v_out := v_out || v_rest;
+      EXIT;
+    END IF;
+    v_out  := v_out || substr(v_rest, 1, v_lt - 1);
+    v_rest := substr(v_rest, v_lt);
+
+    v_gt := position('>' in v_rest);
+    IF v_gt = 0 THEN
+      -- An unterminated '<' is text. It is escaped so it cannot open a tag when
+      -- something is concatenated after this body.
+      v_out := v_out || replace(v_rest, '<', '&lt;');
+      EXIT;
+    END IF;
+    v_tag  := substr(v_rest, 1, v_gt);
+    v_rest := substr(v_rest, v_gt + 1);
+
+    v_name := lower(coalesce(substring(v_tag from '^<\\s*/?\\s*([a-zA-Z][a-zA-Z0-9]*)'), ''));
+    IF v_name = '' OR NOT (v_name = ANY (c_allowed)) THEN
+      CONTINUE; -- tag dropped, its text kept
+    END IF;
+
+    IF v_tag ~ '^<\\s*/' THEN
+      IF NOT (v_name = ANY (c_void)) THEN v_out := v_out || '</' || v_name || '>'; END IF;
+      CONTINUE;
+    END IF;
+
+    -- Attributes are an allowlist too, and a per-tag one: \`href\` on <a>,
+    -- \`src\`/\`alt\` on <img>. Everything else \u2014 style, on*, srcset, class,
+    -- data-* \u2014 is dropped rather than inspected, because inspecting means
+    -- maintaining a list of what is dangerous, and that list is never finished.
+    v_attrs := '';
+    IF v_name = 'a' THEN
+      v_val := public.plg_blog_safe_url(public.plg_blog_html_attr(v_tag, 'href'));
+      IF v_val IS NOT NULL THEN
+        -- An external publisher's outbound links are not the tenant's
+        -- endorsement, and an unmarked link farm is precisely the SEO damage
+        -- this seam could otherwise cause on the tenant's own domain.
+        v_attrs := ' href="' || v_val || '" rel="nofollow noopener"';
+      END IF;
+    ELSIF v_name = 'img' THEN
+      v_val := public.plg_blog_safe_url(public.plg_blog_html_attr(v_tag, 'src'));
+      IF v_val IS NULL THEN CONTINUE; END IF; -- an <img> with no safe src is nothing
+      v_attrs := ' src="' || v_val || '" alt="'
+                 || public.plg_blog_html_escape(public.plg_blog_html_attr(v_tag, 'alt')) || '"';
+    END IF;
+
+    v_out := v_out || '<' || v_name || v_attrs
+             || CASE WHEN v_name = ANY (c_void) THEN ' />' ELSE '>' END;
+  END LOOP;
+
+  RETURN v_out;
+END;
+$fn$;
+
+-- Accents are transliterated rather than stripped: 'sa\xFAde-bucal' beats
+-- 'sa-de-bucal', and a slug is a URL somebody will read out loud.
+CREATE OR REPLACE FUNCTION public.plg_blog_slugify(p_text text)
+RETURNS text
+LANGUAGE sql
+IMMUTABLE
+AS $fn$
+  SELECT btrim(
+    regexp_replace(
+      translate(lower(coalesce(p_text, '')),
+                '\xE1\xE0\xE2\xE3\xE4\xE5\xE9\xE8\xEA\xEB\xED\xEC\xEE\xEF\xF3\xF2\xF4\xF5\xF6\xF8\xFA\xF9\xFB\xFC\xE7\xF1\xFD\xFF',
+                'aaaaaaeeeeiiiioooooouuuucnyy'),
+      '[^a-z0-9]+', '-', 'g'),
+    '-');
+$fn$;
+
+REVOKE ALL ON FUNCTION public.plg_blog_html_attr(text, text)   FROM public, anon;
+REVOKE ALL ON FUNCTION public.plg_blog_html_escape(text)       FROM public, anon;
+REVOKE ALL ON FUNCTION public.plg_blog_safe_url(text)          FROM public, anon;
+REVOKE ALL ON FUNCTION public.plg_blog_sanitize_html(text)     FROM public, anon;
+REVOKE ALL ON FUNCTION public.plg_blog_slugify(text)           FROM public, anon;
+GRANT EXECUTE ON FUNCTION public.plg_blog_html_attr(text, text) TO authenticated, service_role;
+GRANT EXECUTE ON FUNCTION public.plg_blog_html_escape(text)     TO authenticated, service_role;
+GRANT EXECUTE ON FUNCTION public.plg_blog_safe_url(text)        TO authenticated, service_role;
+GRANT EXECUTE ON FUNCTION public.plg_blog_sanitize_html(text)   TO authenticated, service_role;
+GRANT EXECUTE ON FUNCTION public.plg_blog_slugify(text)         TO authenticated, service_role;
+
+-- \xA74 \u2500\u2500 ingest \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+-- The one door. Takes a single jsonb so the caller never has to know a column
+-- list, and returns what it did so a connector can reconcile without a second
+-- read.
+--
+-- Payload: external_ref, title, slug, excerpt, body_html, status, source,
+-- language, tags[], author_member_id, published_at, cover_image, meta_title,
+-- meta_description, canonical_url, og_image, noindex.
+CREATE OR REPLACE FUNCTION public.blog_upsert_external_post(p_payload jsonb)
+RETURNS jsonb
+LANGUAGE plpgsql
+SECURITY DEFINER
+SET search_path = public
+AS $fn$
+DECLARE
+  v_tenants     uuid[];
+  v_tenant      uuid;
+  v_claimed     uuid;
+  v_ref         text;
+  v_title       text;
+  v_base        text;
+  v_slug        text;
+  v_status      text;
+  v_source      text;
+  v_lang        text;
+  v_body        text;
+  v_excerpt     text;
+  v_tags        text[];
+  v_author      uuid;
+  v_pub         timestamptz;
+  v_cover       text;
+  v_existing_id   uuid;
+  v_existing_pub  timestamptz;
+  v_existing_slug text;
+  v_n           int := 1;
+  v_id          uuid;
+  v_created     boolean := false;
+BEGIN
+  -- \u2500\u2500 tenant: from the credential, never from the payload \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+  -- A tenant id the caller supplies is how one tenant writes into another's
+  -- blog, and the caller is a machine outside our trust boundary. The only
+  -- statement about identity we can believe is the one the credential makes.
+  SELECT array_agg(t) INTO v_tenants FROM public.user_tenant_ids() AS t;
+  IF v_tenants IS NULL OR array_length(v_tenants, 1) <> 1 THEN
+    RAISE EXCEPTION
+      'blog_upsert_external_post: the caller must present a credential scoped to exactly one tenant'
+      USING ERRCODE = 'insufficient_privilege';
+  END IF;
+  v_tenant := v_tenants[1];
+
+  -- Refusing beats ignoring: a publisher that believes it is writing into
+  -- another tenant must be told so, not silently redirected into this one.
+  IF nullif(btrim(p_payload->>'tenant_id'), '') IS NOT NULL THEN
+    BEGIN
+      v_claimed := (p_payload->>'tenant_id')::uuid;
+    EXCEPTION WHEN OTHERS THEN
+      v_claimed := NULL;
+    END;
+    IF v_claimed IS DISTINCT FROM v_tenant THEN
+      RAISE EXCEPTION 'blog_upsert_external_post: payload names another tenant; the tenant comes from the credential'
+        USING ERRCODE = 'insufficient_privilege';
+    END IF;
+  END IF;
+
+  -- \u2500\u2500 the article \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+  v_ref   := nullif(btrim(p_payload->>'external_ref'), '');
+  v_title := nullif(btrim(p_payload->>'title'), '');
+  IF v_title IS NULL THEN
+    RAISE EXCEPTION 'blog_upsert_external_post: title is required'
+      USING ERRCODE = 'invalid_parameter_value';
+  END IF;
+
+  v_status := lower(coalesce(nullif(btrim(p_payload->>'status'), ''), 'draft'));
+  IF v_status NOT IN ('draft', 'published') THEN
+    RAISE EXCEPTION 'blog_upsert_external_post: unknown status %; expected draft or published', v_status
+      USING ERRCODE = 'invalid_parameter_value';
+  END IF;
+
+  -- Never taken as 'admin' by default: a post that arrived through this door is
+  -- external by definition, and mislabelling it is what makes a connector echo
+  -- it back to the system that sent it.
+  v_source  := lower(coalesce(nullif(btrim(p_payload->>'source'), ''), 'external'));
+  v_lang    := nullif(btrim(p_payload->>'language'), '');
+  v_body    := public.plg_blog_sanitize_html(p_payload->>'body_html');
+  v_excerpt := left(btrim(regexp_replace(coalesce(p_payload->>'excerpt', ''), '<[^>]*>', '', 'g')), 500);
+
+  IF jsonb_typeof(p_payload->'tags') = 'array' THEN
+    SELECT array_agg(btrim(x)) INTO v_tags
+    FROM jsonb_array_elements_text(p_payload->'tags') AS x
+    WHERE btrim(x) <> '';
+  END IF;
+
+  -- An author id is a claim about a person in THIS tenant. Unverified, it would
+  -- let an external publisher put a real employee's name on anything it writes.
+  IF nullif(btrim(p_payload->>'author_member_id'), '') IS NOT NULL THEN
+    BEGIN
+      SELECT tm.id INTO v_author
+      FROM public.tenant_members tm
+      WHERE tm.tenant_id = v_tenant AND tm.id = (p_payload->>'author_member_id')::uuid;
+    EXCEPTION WHEN OTHERS THEN
+      v_author := NULL;
+    END;
+  END IF;
+
+  v_cover := public.plg_blog_safe_url(
+    coalesce(nullif(btrim(p_payload->>'cover_image'), ''), nullif(btrim(p_payload->>'og_image'), '')));
+
+  -- \u2500\u2500 identity + slug \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+  IF v_ref IS NOT NULL THEN
+    SELECT p.id, p.published_at, p.slug INTO v_existing_id, v_existing_pub, v_existing_slug
+    FROM public.plg_blog_posts p
+    WHERE p.tenant_id = v_tenant AND p.external_ref = v_ref;
+  END IF;
+
+  -- On re-delivery the existing slug WINS over one re-derived from the title.
+  -- A published post's slug is its URL: silently re-slugging it because the
+  -- publisher fixed a typo in the headline breaks every inbound link \u2014 on an
+  -- SEO product's own articles, of all things. Changing it stays possible, but
+  -- only by saying so explicitly in \`slug\`.
+  v_base := coalesce(
+    nullif(public.plg_blog_slugify(p_payload->>'slug'), ''),
+    nullif(v_existing_slug, ''),
+    nullif(public.plg_blog_slugify(v_title), ''),
+    'post-' || left(md5(coalesce(v_ref, gen_random_uuid()::text)), 8));
+  v_base := left(v_base, 120);
+
+  -- Slug is unique per tenant (001). Two different articles that slugify the
+  -- same must not make the second delivery fail \u2014 a suffixed slug is a smaller
+  -- surprise than a rejected publish.
+  v_slug := v_base;
+  WHILE EXISTS (
+    SELECT 1 FROM public.plg_blog_posts p
+    WHERE p.tenant_id = v_tenant AND p.slug = v_slug
+      AND (v_existing_id IS NULL OR p.id <> v_existing_id)
+  ) LOOP
+    v_n := v_n + 1;
+    IF v_n > 50 THEN
+      RAISE EXCEPTION 'blog_upsert_external_post: cannot derive a free slug from %', v_base
+        USING ERRCODE = 'invalid_parameter_value';
+    END IF;
+    v_slug := left(v_base, 112) || '-' || v_n;
+  END LOOP;
+
+  BEGIN
+    v_pub := nullif(btrim(p_payload->>'published_at'), '')::timestamptz;
+  EXCEPTION WHEN OTHERS THEN
+    v_pub := NULL;
+  END;
+  -- A post that goes back to draft keeps the date it first went out; the public
+  -- view filters on status, so nothing leaks, and the history stays true.
+  v_pub := coalesce(v_pub, v_existing_pub, CASE WHEN v_status = 'published' THEN now() END);
+
+  -- \u2500\u2500 write \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+  IF v_existing_id IS NOT NULL THEN
+    UPDATE public.plg_blog_posts SET
+      slug             = v_slug,
+      title            = v_title,
+      excerpt          = v_excerpt,
+      body             = v_body,
+      status           = v_status,
+      published_at     = v_pub,
+      source           = v_source,
+      language         = v_lang,
+      tags             = v_tags,
+      author_member_id = coalesce(v_author, author_member_id),
+      cover_image      = coalesce(v_cover, cover_image),
+      meta_title       = nullif(btrim(p_payload->>'meta_title'), ''),
+      meta_description = nullif(btrim(p_payload->>'meta_description'), ''),
+      canonical_url    = public.plg_blog_safe_url(p_payload->>'canonical_url'),
+      og_image         = public.plg_blog_safe_url(p_payload->>'og_image'),
+      noindex          = coalesce((p_payload->>'noindex')::boolean, false),
+      updated_at       = now()
+    WHERE id = v_existing_id;
+    v_id := v_existing_id;
+  ELSE
+    -- ON CONFLICT on the partial index, not just the SELECT above: two
+    -- deliveries of the same article racing each other would both find nothing
+    -- and both insert. The index is what makes the second one an update.
+    INSERT INTO public.plg_blog_posts (
+      tenant_id, slug, title, excerpt, body, status, published_at,
+      external_ref, source, language, tags, author_member_id, cover_image,
+      meta_title, meta_description, canonical_url, og_image, noindex, updated_at)
+    VALUES (
+      v_tenant, v_slug, v_title, v_excerpt, v_body, v_status, v_pub,
+      v_ref, v_source, v_lang, v_tags, v_author, v_cover,
+      nullif(btrim(p_payload->>'meta_title'), ''),
+      nullif(btrim(p_payload->>'meta_description'), ''),
+      public.plg_blog_safe_url(p_payload->>'canonical_url'),
+      public.plg_blog_safe_url(p_payload->>'og_image'),
+      coalesce((p_payload->>'noindex')::boolean, false),
+      now())
+    ON CONFLICT (tenant_id, external_ref) WHERE external_ref IS NOT NULL
+    DO UPDATE SET
+      title            = excluded.title,
+      excerpt          = excluded.excerpt,
+      body             = excluded.body,
+      status           = excluded.status,
+      published_at     = coalesce(excluded.published_at, plg_blog_posts.published_at),
+      source           = excluded.source,
+      language         = excluded.language,
+      tags             = excluded.tags,
+      cover_image      = coalesce(excluded.cover_image, plg_blog_posts.cover_image),
+      meta_title       = excluded.meta_title,
+      meta_description = excluded.meta_description,
+      canonical_url    = excluded.canonical_url,
+      og_image         = excluded.og_image,
+      noindex          = excluded.noindex,
+      updated_at       = now()
+    RETURNING id, (xmax = 0) INTO v_id, v_created;
+  END IF;
+
+  RETURN jsonb_build_object(
+    'ok', true,
+    'id', v_id,
+    'slug', v_slug,
+    'status', v_status,
+    'source', v_source,
+    'external_ref', v_ref,
+    'created', coalesce(v_created, false));
+END;
+$fn$;
+
+REVOKE ALL ON FUNCTION public.blog_upsert_external_post(jsonb) FROM public, anon;
+GRANT EXECUTE ON FUNCTION public.blog_upsert_external_post(jsonb) TO authenticated, service_role;
+
+-- \xA75 \u2500\u2500 agent \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+-- The assistant's write, in the shape the broker calls (p_tenant_id,
+-- p_actor_user_id, p_payload) \u2014 a different signature from \xA74 on purpose: the
+-- broker injects a verified actor and agent_guard runs role \u2192 plan \u2192 the
+-- blog_posts cap before anything is written. A draft, never a publish: an agent
+-- that can put a page on the public site without anyone reading it first is a
+-- worse product than one that cannot.
+CREATE OR REPLACE FUNCTION public.agent_blog_draft_post(
+  p_tenant_id uuid,
+  p_actor_user_id uuid,
+  p_payload jsonb
+) RETURNS jsonb
+LANGUAGE plpgsql
+SECURITY DEFINER
+SET search_path = public
+AS $fn$
+DECLARE
+  v_denial jsonb;
+  v_used   int;
+  v_title  text;
+  v_base   text;
+  v_slug   text;
+  v_n      int := 1;
+  v_id     uuid;
+BEGIN
+  v_title := nullif(btrim(p_payload->>'title'), '');
+  IF v_title IS NULL THEN
+    RETURN jsonb_build_object('ok', false, 'error', 'title is required to draft a post');
+  END IF;
+
+  SELECT count(*) INTO v_used FROM public.plg_blog_posts p WHERE p.tenant_id = p_tenant_id;
+  v_denial := public.agent_guard(p_tenant_id, p_actor_user_id, 'blog', 'create', 'blog_posts', v_used, 1);
+  IF v_denial IS NOT NULL THEN
+    RETURN jsonb_build_object('ok', false, 'denial', v_denial);
+  END IF;
+
+  v_base := coalesce(nullif(public.plg_blog_slugify(v_title), ''), 'post-' || left(md5(v_title), 8));
+  v_slug := left(v_base, 120);
+  WHILE EXISTS (SELECT 1 FROM public.plg_blog_posts p
+                WHERE p.tenant_id = p_tenant_id AND p.slug = v_slug) LOOP
+    v_n := v_n + 1;
+    IF v_n > 50 THEN
+      RETURN jsonb_build_object('ok', false, 'error', format('cannot derive a free slug from %L', v_base));
+    END IF;
+    v_slug := left(v_base, 112) || '-' || v_n;
+  END LOOP;
+
+  INSERT INTO public.plg_blog_posts (
+    tenant_id, slug, title, excerpt, body, status, source, language, tags, updated_at)
+  VALUES (
+    p_tenant_id, v_slug, v_title,
+    left(btrim(regexp_replace(coalesce(p_payload->>'excerpt', ''), '<[^>]*>', '', 'g')), 500),
+    -- Same sanitiser as the external door: the model's output is not more
+    -- trustworthy than a partner's, it is just closer to home.
+    public.plg_blog_sanitize_html(p_payload->>'body_html'),
+    'draft', 'agent',
+    nullif(btrim(p_payload->>'language'), ''),
+    CASE WHEN jsonb_typeof(p_payload->'tags') = 'array'
+         THEN ARRAY(SELECT btrim(x) FROM jsonb_array_elements_text(p_payload->'tags') AS x WHERE btrim(x) <> '')
+    END,
+    now())
+  RETURNING id INTO v_id;
+
+  INSERT INTO public.audit_logs (tenant_id, user_id, action, entity_type, entity_id, metadata)
+  VALUES (p_tenant_id, p_actor_user_id, 'agent.draftBlogPost', 'blog_post', v_id::text,
+          jsonb_build_object('title', v_title, 'slug', v_slug));
+
+  RETURN jsonb_build_object(
+    'ok', true,
+    'id', v_id,
+    'record', jsonb_build_object(
+      'ref', jsonb_build_object('id', v_id, 'resource', 'plg_blog_posts', 'entityKey', 'blog:posts'),
+      'name', v_title,
+      'slug', v_slug,
+      'status', 'draft'));
+END;
+$fn$;
+
+REVOKE ALL ON FUNCTION public.agent_blog_draft_post(uuid, uuid, jsonb) FROM public, anon;
+GRANT EXECUTE ON FUNCTION public.agent_blog_draft_post(uuid, uuid, jsonb) TO authenticated, service_role;
+
+-- \xA76 \u2500\u2500 facts \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+-- One trigger on the table rather than an emit call inside each writer. The
+-- backoffice, this file's two RPCs and a hand-run SQL fix all end up in the
+-- same place, so a connector hears the same four facts no matter who wrote \u2014
+-- which is the entire reason the row-level emitter exists (packages/db/
+-- migrations/027_domain_events.sql).
+--
+-- \`published\` is not a row action, which is why the generic
+-- plg_attach_event_source trigger cannot produce it: it is a TRANSITION, and
+-- only something holding OLD and NEW can see it happen.
+CREATE OR REPLACE FUNCTION public.plg_blog_emit_post_event()
+RETURNS trigger
+LANGUAGE plpgsql
+SECURITY DEFINER
+SET search_path = public
+AS $fn$
+DECLARE
+  v_row     jsonb;
+  v_tenant  uuid;
+  v_id      text;
+  v_payload jsonb;
+BEGIN
+  -- A save that changed nothing is not a fact; without this any bulk re-save
+  -- buries the real updates.
+  IF TG_OP = 'UPDATE' AND OLD IS NOT DISTINCT FROM NEW THEN
+    RETURN NULL;
+  END IF;
+
+  IF TG_OP = 'DELETE' THEN
+    v_row := to_jsonb(OLD);
+  ELSE
+    v_row := to_jsonb(NEW);
+  END IF;
+  v_tenant := nullif(v_row->>'tenant_id', '')::uuid;
+  v_id     := v_row->>'id';
+  -- The contract every consumer reads. Not the row: a whole-row payload puts
+  -- the article body inside every webhook by default, and whoever needs it
+  -- fetches by id.
+  v_payload := jsonb_build_object(
+    'post_id',      v_id,
+    'slug',         v_row->>'slug',
+    'title',        v_row->>'title',
+    'status',       v_row->>'status',
+    'source',       coalesce(v_row->>'source', 'admin'),
+    'external_ref', v_row->>'external_ref',
+    'language',     v_row->>'language');
+
+  BEGIN
+    IF TG_OP = 'INSERT' THEN
+      PERFORM public.plg_emit_event('blog.post.created', v_payload, 'blog_post', v_id, v_tenant, NULL);
+      IF NEW.status = 'published' THEN
+        PERFORM public.plg_emit_event('blog.post.published', v_payload, 'blog_post', v_id, v_tenant, NULL);
+      END IF;
+    ELSIF TG_OP = 'UPDATE' THEN
+      PERFORM public.plg_emit_event('blog.post.updated', v_payload, 'blog_post', v_id, v_tenant, NULL);
+      IF NEW.status = 'published' AND OLD.status IS DISTINCT FROM 'published' THEN
+        PERFORM public.plg_emit_event('blog.post.published', v_payload, 'blog_post', v_id, v_tenant, NULL);
+      END IF;
+    ELSE
+      PERFORM public.plg_emit_event('blog.post.deleted', v_payload, 'blog_post', v_id, v_tenant, NULL);
+    END IF;
+  EXCEPTION WHEN OTHERS THEN
+    -- Observability must never be able to reject the write that caused it.
+    RAISE WARNING '[plg_blog_emit_post_event] % on %: %', TG_OP, TG_TABLE_NAME, SQLERRM;
+  END;
+
+  RETURN NULL;
+END;
+$fn$;
+
+REVOKE ALL ON FUNCTION public.plg_blog_emit_post_event() FROM public, anon;
+
+DROP TRIGGER IF EXISTS plg_blog_posts_emit_facts ON public.plg_blog_posts;
+CREATE TRIGGER plg_blog_posts_emit_facts
+  AFTER INSERT OR UPDATE OR DELETE ON public.plg_blog_posts
+  FOR EACH ROW EXECUTE FUNCTION public.plg_blog_emit_post_event();
+
+-- \xA77 \u2500\u2500 view \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+-- The public site runs anon and reads only this view, so per-post SEO that the
+-- view does not carry cannot be rendered \u2014 the columns would exist and no page
+-- would ever show them.
+--
+-- \`source\` and \`external_ref\` stay out: they are operational facts about who
+-- writes this tenant's blog, and the anon surface is the open internet.
+-- New columns are appended, never reordered \u2014 CREATE OR REPLACE VIEW only
+-- tolerates additions at the end.
+CREATE OR REPLACE VIEW public.v_public_blog_posts AS
+SELECT
+  p.id,
+  p.tenant_id,
+  p.slug,
+  p.title,
+  p.excerpt,
+  p.body,
+  COALESCE(c.name, '')  AS tag,
+  p.cover_image,
+  p.author_name,
+  p.author_role,
+  p.author_avatar_url,
+  p.author_bio,
+  p.read_time,
+  p.published_at,
+  p.meta_title,
+  p.meta_description,
+  p.canonical_url,
+  p.og_image,
+  p.noindex,
+  p.language,
+  p.tags
+FROM public.plg_blog_posts p
+LEFT JOIN public.plg_blog_categories c ON c.id = p.category_id
+WHERE p.status = 'published';
+
 GRANT SELECT ON public.v_public_blog_posts TO anon, authenticated, service_role;
 `;
 var MIGRATIONS = [
-  { id: "001_blog", sql: MIGRATION_001_BLOG }
+  { id: "001_blog", sql: MIGRATION_001_BLOG },
+  { id: "002_external_posts", sql: MIGRATION_002_EXTERNAL_POSTS }
 ];
 
+// src/data/runtime.ts
+var _provider = null;
+function setBlogProvider(provider) {
+  _provider = provider;
+}
+function getBlogProvider() {
+  if (!_provider) {
+    throw new Error(
+      "[plugin-blog] no blog provider registered \u2014 call createBlogPlugin() before resolving blog loaders, and mount its Provider at the app root."
+    );
+  }
+  return _provider;
+}
+function hasBlogProvider() {
+  return _provider !== null;
+}
+function resetBlogProvider() {
+  _provider = null;
+}
+var BLOG_POSTS_LOADER = "blog.posts";
+var BLOG_POST_LOADER = "blog.post";
+async function blogPosts(params) {
+  const { limit, tag } = params;
+  return getBlogProvider().listPosts({ limit, tag });
+}
+async function blogPost(params) {
+  const slug = typeof params.slug === "string" ? params.slug : void 0;
+  if (!slug) return null;
+  return getBlogProvider().getPost(slug);
+}
+function registerBlogLoaders() {
+  if (!hasLoader(BLOG_POSTS_LOADER)) {
+    defineLoader(BLOG_POSTS_LOADER, blogPosts, {
+      source: "plugin",
+      title: "Blog posts",
+      description: 'Published posts, newest first. The read behind a blog index, a "latest articles" rail, or a tag archive.',
+      output: "Array of BlogPost (slug, title, excerpt, body, image, tag, author, publishedAt \u2026).",
+      settings: [
+        {
+          id: "limit",
+          type: "number",
+          label: "How many",
+          help: "Empty means every published post.",
+          min: 1,
+          max: 100
+        },
+        {
+          id: "tag",
+          type: "text",
+          label: "Tag",
+          help: "Only posts carrying this tag. Empty means all posts."
+        }
+      ]
+    });
+  }
+  if (!hasLoader(BLOG_POST_LOADER)) {
+    defineLoader(BLOG_POST_LOADER, blogPost, {
+      source: "plugin",
+      title: "Blog post",
+      description: "One post by slug. The read behind a post page.",
+      output: "A BlogPost, or null when no post has that slug.",
+      settings: [
+        {
+          id: "slug",
+          type: "text",
+          label: "Slug",
+          help: 'Usually bound to the route param, e.g. `{ $param: "slug" }`.'
+        }
+      ]
+    });
+  }
+}
+
+// src/lib/blog-events.ts
+var BLOG_POST_EVENT_FIELDS = [
+  { name: "post_id", label: "ID do post", type: "id", example: "8f14e45f-\u2026" },
+  { name: "slug", label: "Endere\xE7o", type: "string", example: "saude-bucal-na-terceira-idade" },
+  { name: "title", label: "T\xEDtulo", type: "string", example: "Sa\xFAde bucal na terceira idade" },
+  { name: "status", label: "Situa\xE7\xE3o", type: "string", example: "published" },
+  { name: "source", label: "Origem", type: "string", example: "ranklayer" },
+  { name: "external_ref", label: "Refer\xEAncia externa", type: "string", example: "rl-article-77" },
+  { name: "language", label: "Idioma", type: "string", example: "pt-BR" }
+];
+var PAYLOAD_SCHEMA = {
+  type: "object",
+  properties: {
+    post_id: { type: "string", format: "uuid", description: "Post id in the tenant" },
+    slug: { type: "string", description: "URL segment under the blog base path" },
+    title: { type: "string" },
+    status: { type: "string", enum: ["draft", "published"] },
+    source: {
+      type: "string",
+      description: "Who wrote the post \u2014 'admin', 'ranklayer', 'agent'. A connector compares it against its own id to avoid echoing a post back to the system it came from."
+    },
+    external_ref: { type: "string", description: "The writing system's own id for the article, when it has one" },
+    language: { type: "string", description: "BCP-47 tag, when the writer declares one" }
+  },
+  required: ["post_id", "slug", "title", "status", "source"],
+  additionalProperties: false
+};
+function buildBlogDomainEvents() {
+  return [
+    {
+      name: "blog.post.created",
+      title: "Post criado",
+      description: "Um artigo novo entrou no blog",
+      trigger: "Quando um post \xE9 criado \u2014 pelo painel, pelo assistente ou por um publicador externo",
+      icon: "FilePlus",
+      audit: true,
+      fields: BLOG_POST_EVENT_FIELDS,
+      payloadSchema: PAYLOAD_SCHEMA
+    },
+    {
+      name: "blog.post.updated",
+      title: "Post alterado",
+      description: "O conte\xFAdo ou os metadados do artigo mudaram",
+      trigger: "Quando um post \xE9 salvo com alguma altera\xE7\xE3o de verdade",
+      icon: "FilePen",
+      audit: false,
+      fields: BLOG_POST_EVENT_FIELDS,
+      payloadSchema: PAYLOAD_SCHEMA
+    },
+    {
+      name: "blog.post.published",
+      title: "Post publicado",
+      description: "O artigo ficou vis\xEDvel no site",
+      trigger: "Quando o post passa a publicado \u2014 na cria\xE7\xE3o ou saindo de rascunho",
+      icon: "Globe",
+      audit: true,
+      fields: BLOG_POST_EVENT_FIELDS,
+      payloadSchema: PAYLOAD_SCHEMA
+    },
+    {
+      name: "blog.post.deleted",
+      title: "Post exclu\xEDdo",
+      description: "O artigo saiu do ar",
+      trigger: "Quando um post \xE9 exclu\xEDdo",
+      icon: "FileX",
+      audit: true,
+      fields: BLOG_POST_EVENT_FIELDS,
+      payloadSchema: PAYLOAD_SCHEMA
+    }
+  ];
+}
+
 // src/index.ts
+var MIGRATION_META = {
+  "001_blog": {
+    version: "1.0.0",
+    description: "Blog content model (plg_blog_categories, plg_blog_posts) + anon-read view"
+  },
+  "002_external_posts": {
+    version: "1.1.0",
+    description: "Per-post SEO, external identity (external_ref/source/language/tags), blog_upsert_external_post + agent_blog_draft_post, and the blog.post.* triggers"
+  }
+};
 function createBlogPlugin(options) {
   const config = resolveConfig(options);
   const provider = options?.dataProvider ?? createSafeDataProvider(
     () => createSupabaseBlogProvider({ tenantId: options?.tenantId }),
     () => createMockBlogProvider({ seed: options?.seed, defaultAuthor: options?.defaultAuthor })
   );
+  setBlogProvider(provider);
+  registerBlogLoaders();
   const value = { provider, config };
   const Provider = ({ children }) => createElement(BlogProvider, { value, children });
   Provider.displayName = "BlogPluginProvider";
@@ -488,7 +1358,10 @@ function createBlogPlugin(options) {
     id: "blog",
     name: "Blog",
     icon: "Newspaper",
-    version: "0.1.0",
+    // Tracks package.json. It sat at '0.1.0' for nine minor releases, and a
+    // partner reading the manifest concluded the plugin was a stub.
+    version: "0.10.0",
+    apiVersion: 1,
     scope: options?.scope ?? "universal",
     verticalId: options?.verticalId,
     scaffolds: ["website", "landing_page"],
@@ -498,6 +1371,98 @@ function createBlogPlugin(options) {
     // Blog posts count against the plan cap. The create UI lives in the
     // marketing "Blog" backoffice, which writes to this plugin's posts table.
     declaredLimits: [{ key: "blog_posts", label: "Blog posts", table: "plg_blog_posts" }],
+    // The facts. Emitted by a trigger on the posts table (migration 002 §6), so
+    // an external publisher's write produces the same event as the backoffice's.
+    events: buildBlogDomainEvents(),
+    // The generic row-level ledger coverage (registry.blog_post.*), which is a
+    // different vocabulary from the four above on purpose: it says a ROW
+    // changed, the events say what happened to a POST. Nothing attaches this
+    // yet — plg_attach_event_source is wired in a later milestone.
+    emitsFrom: [{ table: "plg_blog_posts", entityKey: "blog_post" }],
+    declaredRpcs: [
+      {
+        name: "blog_upsert_external_post",
+        kind: "write",
+        description: "Ingest door for an external publisher (RankLayer). Tenant pinned from the caller credential, idempotent on (tenant_id, external_ref), body_html sanitised against a tag allowlist in SQL.",
+        audits: false
+      },
+      {
+        name: "agent_blog_draft_post",
+        kind: "write",
+        description: "Guarded blog draft: agent_guard (role \u2192 plan \u2192 blog_posts cap), body sanitised by the same allowlist, always status draft, audited.",
+        audits: true
+      }
+    ],
+    // Without this the blog is invisible to the agent: it carries its own data
+    // provider, and only queryEntities reaches the server-plane executor.
+    queryEntities: [
+      {
+        key: "blog:posts",
+        entity: {
+          name: "Post",
+          namePlural: "Posts",
+          icon: "Newspaper",
+          permission: { feature: "blog", action: "read" },
+          fields: [
+            { key: "title", label: "T\xEDtulo", type: "text", searchable: true },
+            { key: "slug", label: "Endere\xE7o", type: "text", searchable: true },
+            { key: "status", label: "Situa\xE7\xE3o", type: "text" },
+            { key: "source", label: "Origem", type: "text" },
+            { key: "language", label: "Idioma", type: "text" },
+            { key: "published_at", label: "Publicado em", type: "text" },
+            { key: "updated_at", label: "Atualizado em", type: "text" }
+          ],
+          data: {
+            table: "plg_blog_posts",
+            tenantScoped: true,
+            searchColumns: ["title", "slug"]
+          }
+        }
+      }
+    ],
+    aiTools: [
+      {
+        id: "blog.list-posts",
+        name: "listBlogPosts",
+        description: "Lists the blog posts of this tenant \u2014 title, slug, status, source and dates. Use it to answer what has been published, what is still a draft, and what came from an external publisher.",
+        icon: "Newspaper",
+        mode: "read",
+        execution: { plane: "server", kind: "entity_read", entity: "blog:posts" },
+        category: "Blog",
+        parameters: {
+          type: "object",
+          properties: {
+            status: { type: "string", enum: ["draft", "published"] },
+            search: { type: "string", description: "Match against title or slug" }
+          }
+        },
+        suggestions: [{ label: "Quais posts est\xE3o em rascunho?" }, { label: "O que foi publicado no blog este m\xEAs?" }],
+        permission: { feature: "blog", action: "read" }
+      },
+      {
+        id: "blog.draft-post",
+        name: "draftBlogPost",
+        description: "Creates a blog post as a DRAFT \u2014 it never goes live from here; a person publishes it from the blog backoffice. Takes a title and the article body as simple HTML (headings, paragraphs, lists, links).",
+        icon: "FilePlus",
+        mode: "persist",
+        limitKey: "blog_posts",
+        execution: { plane: "server", kind: "rpc", rpc: "agent_blog_draft_post" },
+        category: "Blog",
+        parameters: {
+          type: "object",
+          properties: {
+            title: { type: "string", description: "Post title" },
+            body_html: { type: "string", description: "Article body as simple HTML" },
+            excerpt: { type: "string", description: "One-line summary shown on cards" },
+            language: { type: "string", description: "BCP-47 tag, e.g. pt-BR" },
+            tags: { type: "array", items: { type: "string" }, description: "Topic tags" }
+          },
+          required: ["title"]
+        },
+        suggestions: [{ label: "Escreve um rascunho de post sobre clareamento dental" }],
+        permission: { feature: "blog", action: "create" }
+      }
+    ],
     // Host owns website nav; no admin nav in M1.
     navigation: [],
     routes: [
@@ -505,18 +1470,20 @@ function createBlogPlugin(options) {
       { path: `${config.basePath}/:slug`, component: PostDetail, guard: "public" }
     ],
     widgets: [],
+    // Measuring what the posts brought in, and pushing a new one anywhere else.
+    integrations: ["google-analytics", "zapier"],
     // Owns the blog domain tables (categories + posts + anon-read view). The
     // marketing "Blog" backoffice writes to these; the website reads them.
     migrations: MIGRATIONS.map((m) => ({
       id: `blog-${m.id}`,
-      version: "1.0.0",
+      version: MIGRATION_META[m.id]?.version ?? "1.0.0",
       sql: m.sql,
-      description: "Blog content model (plg_blog_categories, plg_blog_posts) + anon-read view"
+      description: MIGRATION_META[m.id]?.description ?? m.id
     }))
   };
   return { manifest, Provider, dataProvider: provider };
 }
 
-export { AuthorAvatar, BlogList, BlogProvider, PostCard, PostDetail, createBlogPlugin, createMockBlogProvider, createSupabaseBlogProvider, useBlogContext, useBlogPosts, usePost };
+export { AuthorAvatar, BLOG_POSTS_LOADER, BLOG_POST_EVENT_FIELDS, BLOG_POST_LOADER, BlogList, BlogProvider, PostCard, PostDetail, articleJsonLd, blogJsonLd, blogListSeo, blogUrl, buildBlogDomainEvents, createBlogPlugin, createMockBlogProvider, createSupabaseBlogProvider, getBlogProvider, hasBlogProvider, postSeo, postUrl, registerBlogLoaders, resetBlogProvider, setBlogProvider, useBlogContext, useBlogPosts, usePost };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map