open_blog 0.1.0

data/app/models/open_blog/redirect.rb

@@ -0,0 +1,16 @@
+module OpenBlog
+  class Redirect < ApplicationRecord
+    belongs_to :post, optional: true
+    validates :old_path, :occurred_on, presence: true
+    validates :old_path, uniqueness: true, format: { with: /\A\/(?!\/)/ }
+    validates :source, inclusion: { in: %w[slug_change removal unpublish adoption manual] }
+    validate :preserve_history, on: :update
+
+    private
+      def preserve_history
+        if (changed - %w[new_path updated_at]).any?
+          errors.add(:base, "Only the redirect target can change")
+        end
+      end
+  end
+end

data/app/models/open_blog/revision.rb

@@ -0,0 +1,12 @@
+module OpenBlog
+  class Revision < ApplicationRecord
+    include Immutable
+    belongs_to :post
+    has_many :approvals, dependent: :restrict_with_exception
+    has_many :publications, dependent: :restrict_with_exception
+
+    validates :identifier, presence: true, uniqueness: { scope: :post_id }, format: { with: /\A[0-9a-f]{64}\z/ }
+    validates :payload, presence: true
+    validates :made_by_ai, inclusion: { in: [ true, false ] }, allow_nil: true
+  end
+end

data/app/models/open_blog/series.rb

@@ -0,0 +1,10 @@
+module OpenBlog
+  class Series < ApplicationRecord
+    self.table_name = "open_blog_series"
+    has_many :posts, dependent: :nullify
+
+    before_validation { self.slug = name.to_s.parameterize if slug.blank? }
+    validates :name, :slug, presence: true
+    validates :slug, uniqueness: true, format: { with: /\A[a-z0-9]+(?:[-_][a-z0-9]+)*\z/ }
+  end
+end

data/app/models/open_blog/tag.rb

@@ -0,0 +1,11 @@
+module OpenBlog
+  class Tag < ApplicationRecord
+    has_many :taggings, dependent: :destroy
+    has_many :posts, through: :taggings
+
+    before_validation { self.slug = name.to_s.parameterize if slug.blank? }
+    validates :name, :slug, presence: true
+    validates :name, uniqueness: { case_sensitive: false }
+    validates :slug, uniqueness: true, format: { with: /\A[a-z0-9]+(?:[-_][a-z0-9]+)*\z/ }
+  end
+end

data/app/models/open_blog/tagging.rb

@@ -0,0 +1,7 @@
+module OpenBlog
+  class Tagging < ApplicationRecord
+    belongs_to :post
+    belongs_to :tag
+    validates :tag_id, uniqueness: { scope: :post_id }
+  end
+end

data/app/queries/open_blog/api_post_query.rb

@@ -0,0 +1,54 @@
+module OpenBlog
+  class ApiPostQuery
+    FILTERS = ApiFields::POST_LIST
+
+    def self.call(filters, base_url: nil)
+      new(filters, base_url: base_url).call
+    end
+
+    def initialize(filters, base_url:)
+      @filters, @base_url = filters, base_url
+    end
+
+    def call
+      page = positive_integer(:page, 1)
+      per_page = [ positive_integer(:per_page, 25), 100 ].min
+      relation = Post.all
+      if @filters.key?(:status)
+        invalid(:status) unless Post.statuses.key?(@filters[:status])
+        relation = relation.where(status: @filters[:status])
+      end
+      { category: :category, tag: :tags, author: :author, series: :series }.each do |field, association|
+        next unless @filters.key?(field)
+        value = @filters[field]
+        invalid(field) unless value.is_a?(String) && value.present?
+        model = Post.reflect_on_association(association).klass
+        matches = model.where(slug: value).or(model.where(name: value))
+        matches = matches.or(model.where(id: value.to_i)) if value.match?(/\A[1-9]\d*\z/)
+        relation = relation.where(id: Post.joins(association).merge(matches).select(:id))
+      end
+      if @filters.key?(:q)
+        query = @filters[:q]
+        invalid(:q) unless query.is_a?(String)
+        relation = Search.call(query, scope: relation)
+      end
+      total = relation.count
+      posts = relation.order(created_at: :desc, id: :desc).offset((page - 1) * per_page).limit(per_page)
+        .includes(:author, :category, :tags, :public_revision)
+      { posts: posts.map { |post| PostSerializer.call(post, card: true, base_url: @base_url) }, page: page, per_page: per_page, total: total }
+    end
+
+    private
+
+    def positive_integer(field, default)
+      return default unless @filters.key?(field)
+      value = @filters[field]
+      invalid(field) unless (value.is_a?(Integer) || value.is_a?(String)) && value.to_s.match?(/\A[1-9]\d*\z/) && value.to_s.length <= 9
+      value.to_i
+    end
+
+    def invalid(field)
+      raise Error::ValidationFailed.new(details: [ field.to_s ])
+    end
+  end
+end

data/app/serializers/open_blog/adoption_result_serializer.rb

@@ -0,0 +1,9 @@
+module OpenBlog
+  class AdoptionResultSerializer
+    def self.call(result, base_url: nil)
+      { post: PostSerializer.call(result.post, base_url: base_url, label: result.label), created: result.created,
+        records: result.records.slice(:revision, :publication, :approval, :baseline, :redirects),
+        findings: FindingsSerializer.entries(result.findings), dry_run: result.dry_run }
+    end
+  end
+end

data/app/serializers/open_blog/author_serializer.rb

@@ -0,0 +1,10 @@
+module OpenBlog
+  class AuthorSerializer
+    def self.call(record)
+      image = ImageResolution.image_for_attachment(record.avatar.blob) if record.avatar.attached?
+      { id: record.id, name: record.name, slug: record.slug, type: record.author_type, bio: record.bio,
+        url: record.url, profile_urls: record.profile_urls, avatar: ImageSerializer.call(image),
+        host_reference: record.host_reference, posts_count: record.posts.count }
+    end
+  end
+end

data/app/serializers/open_blog/category_serializer.rb

@@ -0,0 +1,7 @@
+module OpenBlog
+  class CategorySerializer
+    def self.call(record)
+      { id: record.id, name: record.name, slug: record.slug, description: record.description, position: record.position, posts_count: record.posts.count }
+    end
+  end
+end

data/app/serializers/open_blog/doctor_serializer.rb

@@ -0,0 +1,7 @@
+module OpenBlog
+  class DoctorSerializer
+    def self.call(checks)
+      { checks: checks.map { |check| { name: check[:name], status: check[:status], message: check[:message] } } }
+    end
+  end
+end

data/app/serializers/open_blog/error_serializer.rb

@@ -0,0 +1,7 @@
+module OpenBlog
+  class ErrorSerializer
+    def self.call(error)
+      { error: { code: error.code, message: error.message, details: error.details } }
+    end
+  end
+end

data/app/serializers/open_blog/extraction_result_serializer.rb

@@ -0,0 +1,7 @@
+module OpenBlog
+  class ExtractionResultSerializer
+    def self.call(result)
+      result.slice(:pairs, :cut, :body_after, :leftover, :class, :reasons, :source_body_sha256)
+    end
+  end
+end

data/app/serializers/open_blog/findings_serializer.rb

@@ -0,0 +1,13 @@
+module OpenBlog
+  class FindingsSerializer
+    def self.call(findings)
+      { findings: entries(findings) }
+    end
+
+    def self.entries(findings)
+      findings.map do |finding|
+        { code: finding[:code], rule: finding[:rule], message: finding[:message], location: finding[:location] }
+      end
+    end
+  end
+end

data/app/serializers/open_blog/image_serializer.rb

@@ -0,0 +1,9 @@
+module OpenBlog
+  class ImageSerializer
+    def self.call(image)
+      return unless image
+      { image_id: image.id, url: image.path, sha256: image.sha256, filename: image.filename,
+        content_type: image.content_type, byte_size: image.byte_size, width: image.width, height: image.height }
+    end
+  end
+end

data/app/serializers/open_blog/page_serializer.rb

@@ -0,0 +1,9 @@
+module OpenBlog
+  class PageSerializer
+    def self.call(page, base_url: nil)
+      { kind: page.kind, slug: page.slug, url: page.url(base: OpenBlog.config.public_base_url || base_url),
+        title: page.title, body: page.body_markdown, status: page.status,
+        approved_by: page.approved_by, approved_on: page.approved_on, updated_at: page.updated_at&.iso8601 }
+    end
+  end
+end

data/app/serializers/open_blog/post_serializer.rb

@@ -0,0 +1,59 @@
+module OpenBlog
+  class PostSerializer
+    def self.call(post, base_url: nil, card: false, label: nil)
+      new(post, base_url: base_url, label: label).call(card: card)
+    end
+
+    def initialize(post, base_url:, label: nil)
+      @post, @base_url, @label = post, OpenBlog.config.public_base_url || base_url, label
+    end
+
+    def call(card: false)
+      result = {
+        id: @post.id, slug: @post.slug, url: @post.url(base: @base_url), status: @post.status,
+        title: @post.title, description: @post.description, author: author,
+        category: taxonomy(@post.category), tags: @post.tags.map(&:name),
+        published_at: timestamp(@post.published_at), modified_at: timestamp(@post.modified_at),
+        revision_identifier: @post.current_revision_identifier, label: (@label || LabelPolicy.for(@post)).to_s
+      }
+      return result if card
+
+      result.merge(search_title: @post.search_title, search_description: @post.search_description,
+        body_format: @post.body_format, body: @post.body_for_payload,
+        series: @post.series && taxonomy(@post.series).merge(position: @post.series_position),
+        featured: @post.featured, canonical_url: @post.canonical_url,
+        cover_image: ImageSerializer.call(@post.cover_image), cover_alt: @post.cover_alt,
+        social_image: ImageSerializer.call(@post.social_image), faq: @post.faq_list,
+        provenance: @post.provenance, provenance_evidence: @post.provenance_evidence,
+        external_id: @post.external_id, publish_at: timestamp(@post.publish_at),
+        public_revision_identifier: @post.public_revision&.identifier,
+        approved: approved?,
+        preview_url: @post.previewable? ? PreviewSerializer.call(@post, base_url: @base_url)[:preview_url] : nil, reading_time_minutes: @post.reading_time_minutes, word_count: @post.word_count,
+        created_at: timestamp(@post.created_at), updated_at: timestamp(@post.updated_at))
+    end
+
+    private
+
+    def approved?
+      return false unless @post.public_revision_id
+      if @post.association(:approvals).loaded?
+        @post.approvals.any? { |approval| approval.revision_id == @post.public_revision_id && approval.facts_checked }
+      else
+        @post.approvals.exists?(revision_id: @post.public_revision_id, facts_checked: true)
+      end
+    end
+
+    def author
+      record = @post.author
+      { id: record.id, name: record.name, slug: record.slug, type: record.author_type, url: record.url }
+    end
+
+    def taxonomy(record)
+      { id: record.id, name: record.name, slug: record.slug } if record
+    end
+
+    def timestamp(value)
+      value&.iso8601
+    end
+  end
+end

data/app/serializers/open_blog/preview_serializer.rb

@@ -0,0 +1,11 @@
+module OpenBlog
+  class PreviewSerializer
+    def self.call(post, base_url: nil)
+      credentials = post.preview_credentials
+      origin = OpenBlog.config.public_base_url || base_url
+      path = "#{OpenBlog.mount_path.chomp('/')}/preview/#{ERB::Util.url_encode(credentials.fetch(:token))}"
+      { preview_url: "#{origin.to_s.chomp('/')}#{path}", revision_identifier: post.current_revision_identifier,
+        expires_at: credentials.fetch(:expires_at).iso8601 }
+    end
+  end
+end

data/app/serializers/open_blog/records_serializer.rb

@@ -0,0 +1,28 @@
+module OpenBlog
+  class RecordsSerializer
+    BASELINE_FIELDS = %i[post_id adopted_at adopted_revision_id provenance provenance_evidence first_published_at
+      first_published_evidence declared_first_published_at last_modified_at last_modified_evidence
+      source_system source_id source_body_sha256 adopted_by].freeze
+    CONNECTION_FIELDS = %i[post_id connections third_party_paid declared_by declared_on recorded_by].freeze
+
+    def self.call(post)
+      {
+        revisions: post.revisions.order(:id).map { |row| fields(row, %i[identifier actor made_by_ai created_at]) },
+        approvals: post.approvals.includes(:revision).order(:id).map do |row|
+          fields(row, %i[kind reviewer_name facts_checked approved_at declared_on declared_by confirmed_by evidence recorded_by])
+            .merge(revision_identifier: row.revision.identifier)
+        end,
+        publications: post.publications.includes(:revision).order(:id).map do |row|
+          fields(row, %i[entry_type occurred_at released_by description note]).merge(revision_identifier: row.revision&.identifier)
+        end,
+        baseline: post.baseline && fields(post.baseline, BASELINE_FIELDS),
+        connections: post.connection_declarations.order(:id).map { |row| fields(row, CONNECTION_FIELDS) }
+      }
+    end
+
+    def self.fields(record, names)
+      names.to_h { |name| [ name, record.public_send(name) ] }
+    end
+    private_class_method :fields
+  end
+end

data/app/serializers/open_blog/redirect_serializer.rb

@@ -0,0 +1,7 @@
+module OpenBlog
+  class RedirectSerializer
+    def self.call(record)
+      { id: record.id, old_path: record.old_path, new_path: record.new_path, source: record.source, occurred_on: record.occurred_on, post_id: record.post_id }
+    end
+  end
+end

data/app/serializers/open_blog/series_serializer.rb

@@ -0,0 +1,7 @@
+module OpenBlog
+  class SeriesSerializer
+    def self.call(record)
+      { id: record.id, name: record.name, slug: record.slug, description: record.description, posts: record.posts.order(:series_position, :id).map { |post| { id: post.id, slug: post.slug, title: post.title, position: post.series_position } } }
+    end
+  end
+end

data/app/serializers/open_blog/tag_serializer.rb

@@ -0,0 +1,7 @@
+module OpenBlog
+  class TagSerializer
+    def self.call(record)
+      { id: record.id, name: record.name, slug: record.slug, posts_count: record.posts.count }
+    end
+  end
+end

data/app/serializers/open_blog/write_result_serializer.rb

@@ -0,0 +1,9 @@
+module OpenBlog
+  class WriteResultSerializer
+    def self.call(result, base_url: nil)
+      { post: PostSerializer.call(result.post, base_url: base_url), created: result.created,
+        records: result.records.slice(:revision, :publication, :approval), label: result.label.to_s,
+        findings: FindingsSerializer.entries(result.findings) }
+    end
+  end
+end

data/app/views/open_blog/attachments/_blob.html.erb

@@ -0,0 +1 @@
+<img src="<%= image.path %>" alt="<%= alt %>" title="<%= caption %>"<% if image.width %> width="<%= image.width %>"<% end %><% if image.height %> height="<%= image.height %>"<% end %>>

data/app/views/open_blog/feeds/atom.xml.builder

@@ -0,0 +1,27 @@
+xml.instruct! :xml, version: "1.0", encoding: "UTF-8"
+xml.feed xmlns: "http://www.w3.org/2005/Atom" do
+  xml.id "#{@base_url}#{OpenBlog.mount_path}"
+  xml.title @feed_title
+  xml.updated @feed_updated_at.iso8601
+  xml.author { xml.name(OpenBlog.config.publisher&.fetch(:name, nil) || OpenBlog.config.site_name) }
+  xml.link href: "#{@base_url}#{request.path}", rel: "self", type: "application/atom+xml"
+  xml.link href: "#{@base_url}#{OpenBlog.mount_path}", rel: "alternate", type: "text/html"
+  @posts.each do |post|
+    xml.entry do
+      xml.id post.url(base: @base_url)
+      xml.title post.title
+      xml.link href: post.url(base: @base_url), rel: "alternate", type: "text/html"
+      xml.published OpenBlog::ReaderDates.published_at(post).iso8601 if OpenBlog::ReaderDates.published_at(post)
+      xml.updated OpenBlog::ReaderDates.feed_updated_at(post).iso8601
+      xml.author do
+        xml.name post.author_name
+        xml.uri "#{@base_url}#{OpenBlog::ReaderQueries.author_path(post.author)}"
+      end
+      if OpenBlog.config.feed_content == :full
+        xml.content OpenBlog::Renderer.render(post), type: "html"
+      else
+        xml.summary post.description, type: "text"
+      end
+    end
+  end
+end

data/app/views/open_blog/sitemaps/show.xml.builder

@@ -0,0 +1,9 @@
+xml.instruct! :xml, version: "1.0", encoding: "UTF-8"
+xml.urlset xmlns: "http://www.sitemaps.org/schemas/sitemap/0.9" do
+  @entries.each do |entry|
+    xml.url do
+      xml.loc entry.fetch(:loc)
+      xml.lastmod entry[:lastmod].iso8601 if entry[:lastmod]
+    end
+  end
+end

data/config/locales/open_blog.en.yml

@@ -0,0 +1,95 @@
+en:
+  open_blog:
+    search:
+      heading: "Search articles"
+      label: "Search the blog"
+      submit: "Search"
+      suggestions: "Suggested articles"
+      description: "Find articles by their title, text, or frequently asked questions."
+      empty: "No matching articles. Try another word or phrase."
+    notices:
+      ai_assisted: "AI helped to make this post."
+      ai_unknown: "The use of AI for this post is not known."
+      paid: "A third party paid for this post."
+      disclosure: "Disclosure"
+      connections_none: "The author declared no relevant connections."
+      correction: "Correction"
+    dates:
+      published: "Published"
+      updated: "Updated"
+    reading_time:
+      one: "%{count} minute read"
+      other: "%{count} minute read"
+    navigation:
+      blog: "Blog navigation"
+      footer: "Blog resources"
+      breadcrumbs: "Breadcrumbs"
+      categories: "Categories"
+      all_posts: "All posts"
+      popular: "Popular articles"
+      tags: "Tags"
+      feed: "Atom feed"
+      responsible_party: "Responsible party"
+      toc: "On this page"
+      pagination: "Pagination"
+      series: "In this series"
+      previous_post: "Previous post"
+      next_post: "Next post"
+      page: "Page %{page}"
+    titles:
+      preview_expired: "This preview link has stopped"
+      page: "%{title} — Page %{page}"
+      tag: "Tagged: %{name}"
+      not_found: "Page not found"
+      gone: "This page has been removed"
+    descriptions:
+      index: "The blog of %{site_name}."
+      index_page: "Page %{page} of the blog of %{site_name}."
+      category: "Posts about %{name} — %{site_name}."
+      category_page: "Page %{page} of the posts about %{name} — %{site_name}."
+      tag: "Posts tagged %{name} — %{site_name}."
+      tag_page: "Page %{page} of the posts tagged %{name} — %{site_name}."
+      author: "Posts by %{name} — %{site_name}."
+      author_page: "Page %{page} of the posts by %{name} — %{site_name}."
+      series: "Posts in %{name} — %{site_name}."
+      series_page: "Page %{page} of the posts in %{name} — %{site_name}."
+    headings:
+      link: "Link to %{heading}"
+      highlights: "Article highlights"
+      about_author: "About the author"
+      related: "Related posts"
+      recent: "Recent posts"
+    cards:
+      featured: "Featured"
+    faq:
+      heading: "Frequently asked questions"
+    lists:
+      empty: "There are no posts here yet."
+    share:
+      heading: "Share this post"
+      x: "Share on X"
+      linkedin: "Share on LinkedIn"
+      device: "Share"
+      copy: "Copy link"
+      copied: "Copied!"
+      failed: "Sharing failed. Please try again."
+    theme:
+      system: "Theme: System"
+      light: "Theme: Light"
+      dark: "Theme: Dark"
+    code:
+      copy: "Copy"
+      copy_label: "Copy code"
+      copied: "Copied"
+      copy_failed: "Copy failed"
+    policies:
+      responsible_party: "Responsible party"
+      corrections: "Corrections policy"
+      editorial: "Editorial policy"
+      ai_use: "AI use policy"
+    errors:
+      not_found: "We could not find this page. Browse the latest posts below."
+      gone: "This page is no longer available. Browse the latest posts below."
+    preview:
+      heading: "Draft preview"
+      stopped: "Ask the author for a new preview link."

data/config/routes.rb

@@ -0,0 +1,52 @@
+OpenBlog::Engine.routes.draw do
+  match "/mcp", to: "mcp#create", via: [ :post, :get, :delete ]
+  get "/preview/:token", to: "previews#show", as: :preview
+  get "/policies/:slug", to: "pages#show", as: :policy_page, format: false
+  namespace :api do
+    namespace :v1 do
+      patch "posts/:id", to: "posts#update"
+      resources :posts, only: [ :index, :show, :create, :destroy ] do
+        post :publish, on: :member
+        post :unpublish, on: :member
+        resources :approvals, only: :create
+        resources :connections, only: :create
+        resource :views, only: :show, controller: "views"
+        resource :preview, only: :show, controller: "previews"
+        resource :records, only: :show, controller: "records"
+        resource :findings, only: :show, controller: "findings"
+      end
+      resources :images, only: :create
+      %i[categories authors series].each do |resource|
+        resources resource, only: [ :index, :create ]
+        patch "#{resource}/:id", to: "#{resource}#update"
+      end
+      resources :tags, only: :index
+      resources :redirects, only: [ :index, :create, :destroy ]
+      resources :adoptions, only: :create
+      resources :faq_extractions, only: :create
+      get "pages", to: "pages#index"
+      get "pages/:kind", to: "pages#show"
+      put "pages/:kind", to: "pages#update"
+      get "views/top", to: "views#top"
+      get "report", to: "report#show"
+      get "doctor", to: "doctor#show"
+    end
+  end
+  root "posts#index"
+  get "/search", to: "search#show", as: :search
+  get "/#{OpenBlog.config.route_segments.fetch(:series)}/:slug", to: "series#show", as: :series
+  get "/feed.json", to: "feeds#show", as: :feed_json, format: false, defaults: { format: :json }
+  get "/feed.xml", to: "feeds#show", as: :feed, format: false, defaults: { format: :xml }
+  get "/sitemap.xml", to: "sitemaps#show", as: :sitemap, format: false, defaults: { format: :xml }
+  get "/media/:sha256/:filename", to: "media#show", as: :media, format: false, constraints: { sha256: /[0-9a-f]{64}/, filename: /[^\/]+/ }
+  get "/#{OpenBlog.config.route_segments.fetch(:category)}/:slug/feed.json", to: "feeds#show", as: :category_feed_json, format: false, defaults: { format: :json }
+  get "/#{OpenBlog.config.route_segments.fetch(:category)}/:slug/feed.xml", to: "feeds#show", as: :category_feed, format: false, defaults: { format: :xml }
+  get "/#{OpenBlog.config.route_segments.fetch(:category)}/:slug", to: "categories#show", as: :category
+  get "/#{OpenBlog.config.route_segments.fetch(:tag)}/:slug", to: "tags#show", as: :tag
+  get "/#{OpenBlog.config.route_segments.fetch(:author)}/:slug", to: "authors#show", as: :author
+  get "/:slug", to: "posts#show", as: :post, constraints: ->(request) {
+    slug = request.path_parameters[:slug]
+    slug.match?(/\A[a-z0-9]+(?:[-_][a-z0-9]+)*\z/) && !(OpenBlog::Post::RESERVED_SLUGS + OpenBlog.config.route_segments.values).include?(slug)
+  }
+  get "/*path", to: "errors#not_found"
+end

data/db/migrate/20261003012512_create_open_blog_authors.rb

@@ -0,0 +1,16 @@
+class CreateOpenBlogAuthors < ActiveRecord::Migration[8.0]
+  def change
+    create_table :open_blog_authors do |t|
+      t.string :name, null: false
+      t.string :slug, null: false
+      t.string :author_type, null: false, default: "person"
+      t.text :bio
+      t.string :url
+      t.public_send(connection.adapter_name == "PostgreSQL" ? :jsonb : :json, :profile_urls, null: false, default: [])
+      t.string :host_reference
+      t.timestamps
+    end
+    add_index :open_blog_authors, :slug, unique: true
+    add_check_constraint :open_blog_authors, "author_type IN ('person', 'organization')", name: "open_blog_authors_type"
+  end
+end

data/db/migrate/20261003012513_create_open_blog_categories.rb

@@ -0,0 +1,13 @@
+class CreateOpenBlogCategories < ActiveRecord::Migration[8.0]
+  def change
+    create_table :open_blog_categories do |t|
+      t.string :name, null: false
+      t.string :slug, null: false
+      t.text :description
+      t.integer :position, null: false, default: 0
+      t.timestamps
+    end
+    add_index :open_blog_categories, :name, unique: true
+    add_index :open_blog_categories, :slug, unique: true
+  end
+end

data/db/migrate/20261003012514_create_open_blog_series.rb

@@ -0,0 +1,11 @@
+class CreateOpenBlogSeries < ActiveRecord::Migration[8.0]
+  def change
+    create_table :open_blog_series do |t|
+      t.string :name, null: false
+      t.string :slug, null: false
+      t.text :description
+      t.timestamps
+    end
+    add_index :open_blog_series, :slug, unique: true
+  end
+end

data/db/migrate/20261003012515_create_open_blog_images.rb

@@ -0,0 +1,17 @@
+class CreateOpenBlogImages < ActiveRecord::Migration[8.0]
+  def change
+    create_table :open_blog_images do |t|
+      t.string :sha256, limit: 64, null: false
+      t.string :filename, null: false
+      t.string :content_type, null: false
+      t.bigint :byte_size, null: false
+      t.integer :width
+      t.integer :height
+      t.string :source_url
+      t.string :uploaded_by
+      t.datetime :created_at, null: false
+    end
+    add_index :open_blog_images, :sha256, unique: true
+    add_check_constraint :open_blog_images, "byte_size >= 0", name: "open_blog_images_size"
+  end
+end

data/db/migrate/20261003012516_create_open_blog_posts.rb

@@ -0,0 +1,47 @@
+class CreateOpenBlogPosts < ActiveRecord::Migration[8.0]
+  def change
+    create_table :open_blog_posts do |t|
+      t.string :slug, null: false
+      t.string :title, null: false
+      t.text :description, null: false, default: ""
+      t.string :search_title, null: false, default: ""
+      t.text :search_description, null: false, default: ""
+      t.string :body_format, null: false
+      t.text :body_markdown
+      t.references :author, null: false, foreign_key: { to_table: :open_blog_authors }
+      t.string :author_name, null: false
+      t.references :category, foreign_key: { to_table: :open_blog_categories }
+      t.references :series, foreign_key: { to_table: :open_blog_series }
+      t.integer :series_position
+      t.string :status, null: false, default: "draft"
+      t.datetime :published_at
+      t.datetime :modified_at
+      t.datetime :publish_at
+      t.string :provenance, null: false, default: "unknown"
+      t.text :provenance_evidence
+      t.boolean :featured, null: false, default: false
+      t.string :canonical_url, limit: 2048
+      t.string :external_id
+      t.references :cover_image, foreign_key: { to_table: :open_blog_images }
+      t.string :cover_alt, null: false, default: ""
+      t.references :social_image, foreign_key: { to_table: :open_blog_images }
+      t.string :current_revision_identifier, limit: 64
+      t.references :public_revision
+      t.integer :word_count, null: false, default: 0
+      t.integer :reading_time_minutes, null: false, default: 1
+      t.text :search_text
+      t.timestamps
+    end
+    add_index :open_blog_posts, :slug, unique: true
+    add_index :open_blog_posts, :external_id, unique: true
+    add_index :open_blog_posts, [ :status, :published_at ]
+    add_index :open_blog_posts, [ :status, :publish_at ]
+    add_index :open_blog_posts, [ :series_id, :series_position ], unique: true
+    if connection.adapter_name == "PostgreSQL"
+      add_index :open_blog_posts, "to_tsvector('simple', search_text)", using: :gin, name: "index_open_blog_posts_search"
+    end
+    add_check_constraint :open_blog_posts, "body_format IN ('markdown', 'rich_text')", name: "open_blog_posts_body_format"
+    add_check_constraint :open_blog_posts, "status IN ('draft', 'scheduled', 'published', 'archived')", name: "open_blog_posts_status"
+    add_check_constraint :open_blog_posts, "provenance IN ('ai_assisted', 'human_written', 'unknown')", name: "open_blog_posts_provenance"
+  end
+end