@happyvertical/smrt-content

STI content types (Article, ContentDocument, Mirror) with governance workflows, contribution intake, fact-checking, AI reviews, transparency reports, and thumbnail generation.

Fact-audit repair uses transactional replacement. repairFactAudit() stages a complete audit, then removes older generated links, evidence, and source provenance for that content and tenant. repairFactEvidence() applies the same contract only to the selected sources. Both methods preserve manual and other-content provenance, and a failed extraction rolls back the staged repair.

Installation

pnpm add @happyvertical/smrt-content

Usage

import { Content, Contents, Article, Mirror } from '@happyvertical/smrt-content';
import { contentToString, stringToContent } from '@happyvertical/smrt-content';

// Initialize collection
const contents = await Contents.create({
  db: { url: 'sqlite:./content.db' },
});

// Create and save content
const article = new Article({
  title: 'AI in Content Processing',
  body: 'Large language models have revolutionized...',
  status: 'published',
  tags: ['ai', 'nlp'],
  category: 'technology/ai',
});
await article.initialize();
await article.save();

// Mirror content from a URL (idempotent -- returns existing if already mirrored)
const mirrored = await contents.mirror({
  url: 'https://example.com/article.html',
  context: 'research',
  mirrorDir: './cache',
});

// Upsert by slug + context
const doc = await contents.getOrUpsert({
  slug: 'project-notes',
  context: 'docs',
  title: 'Project Notes',
  body: 'Notes content...',
});

// Thumbnail generation (three strategies)
await contents.generateMissingThumbnails({
  strategy: 'headline-card',
  db: { url: 'sqlite:./content.db' },
});

// Export to markdown with YAML frontmatter
const markdown = contentToString(article);
const parsed = stringToContent(markdown);

// Batch export articles as markdown files
await contents.syncContentDir({ contentDir: './blog-posts' });

Content Governance

import {
  Content,
  ContentGovernanceAssignment,
  ContentGovernanceManager,
  GovernedContentEditor,
  configureContentGovernance,
} from '@happyvertical/smrt-content';

configureContentGovernance({
  policies: [
    {
      key: 'editorial',
      label: 'Editorial Review',
      kind: 'custom',
      instructions: 'Check tone, sourcing, and local publication standards.',
    },
  ],
  profiles: [
    {
      key: 'publication',
      label: 'Publication',
      requirements: [
        { policyKey: 'safety', blocking: true },
        { policyKey: 'facts', blocking: true },
        { policyKey: 'editorial', blocking: false },
      ],
    },
  ],
  assignments: [
    {
      contentType: 'article',
      enabled: true,
      factLinkingEnabled: true,
      transparencyEnabled: true,
      publicationProfileKey: 'publication',
      correctionProfileKey: 'correction',
      enforcePublishReadiness: true,
    },
  ],
});

const article = new Content({
  title: 'Transit service changes',
  body: 'Weekend service will resume on April 3.',
  type: 'article',
  metadata: {
    generation: {
      publicPrompt: 'Summarize the service change for riders.',
      aiAssisted: true,
      model: 'gpt-5.4',
    },
  },
});

await article.initialize();
await article.save();
await article.addFact('fact_123', 'supports');
await article.runReviewAction({ kind: 'facts', policyKey: 'facts' });
await article.runReviewAction({ kind: 'safety', policyKey: 'safety' });

article.status = 'published';
await article.save();

Governance stays opt-in. Plain Content records behave like legacy smrt-content unless an assignment matches their type and optional exact variant.

Persisted governance definitions are modeled as first-class s-m-r-t objects:

• ContentGovernancePolicy
• ContentGovernanceProfile
• ContentGovernanceAssignment

Reviews & Corrections

Content reviews are AI-driven quality checks tied to governance policies. Corrections track post-publication changes with accountability.

// Run an AI review against a policy
const review = await article.runReviewAction({
  kind: 'facts',
  policyKey: 'facts',
});
console.log(review.status); // 'accepted' | 'flagged' | 'rejected'
console.log(review.findings); // Array of issues found

// List all reviews for content
const reviews = await article.listReviews();

// Evaluate readiness against a profile
const profiles = await article.listReviewProfilesAction();
const evaluation = await article.evaluateReviewProfile('publication');
console.log(evaluation.ready); // true if all blocking requirements met

// Issue a correction
await article.issueCorrectionAction({
  type: 'correction',
  summary: 'Updated figures to reflect Q4 data',
  note: 'Previous values were from Q3',
});
const corrections = await article.listCorrections();

Versioning

Content versions track snapshots of content state. Publication versions are created automatically when governed content is published.

// Manual version snapshot
await article.mutateVersionAction({
  kind: 'manual',
  summary: 'Before the editorial rewrite.',
});

// Snapshot created by an ingestion or generation worker
await article.mutateVersionAction({
  kind: 'auto-generated',
  summary: 'Planning asset extracted.',
  metadata: { source: 'planning-asset-ingestion' },
});

// List version history
const versions = await article.listVersions();

// Restore a previous version
await versions.restoreIntoContent(versionId);

Migrating automated producers

Automated producers should use kind: 'auto-generated' instead of encoding generation as kind: 'draft' plus metadata.generated = 'auto'. Keep source-specific metadata such as metadata.source when it provides useful provenance.

References & Drift Detection

References are (source_id, target_id) edges between Content rows. They can optionally pin a targetVersion captured at citation time. When the target is later re-synced (a new ContentVersion is created), callers can detect drift between what was cited and what the target now says.

// Pin to the target's current version when citing
const latest = await citedArticle.listVersions();
const currentVersion = latest[latest.length - 1]?.version ?? null;
await article.addReference(citedArticle, { targetVersion: currentVersion });

// Or leave it unpinned — no version is recorded and `isDrifted` will
// always be false for this edge regardless of how the target evolves.
await article.addReference(otherArticle);

// Detect drift across all references
const drift = await article.getReferenceDrift();
// → [{ targetId, citedVersion, currentVersion, isDrifted }, ...]
// `isDrifted` is true only when both versions are present and differ.

// Re-link with a new pin to acknowledge drift (idempotent on source+target,
// mutable on the version column).
await article.addReference(citedArticle, { targetVersion: 2 });

serializeContent includes per-reference citedVersion, currentVersion, and isDrifted fields so SvelteKit load functions can pass them through to consumers without an extra round-trip. The fields surface in the serialized payload; rendering them (e.g. a drift badge in ContentReferencesPanel) is left to the consumer.

getReferenceDrift compares against the target's latest ContentVersion of any kind (manual or publication), so a manual snapshot of the target will trigger isDrifted: true. Consumers that only care about published drift can filter further using ContentVersion.kind.

Typical use: cite an ingested external snapshot (web page, upstream feed, asset library entry) as a Content row. Re-sync the source on a schedule, bump the version, and any article that cites the prior version surfaces a drift signal in the editor.

Published Transparency

const publishedTransparency = await article.getPublishedTransparencyAction();
const previewTransparency = await article.previewTransparencyAction();

console.log(publishedTransparency?.factsUsed);
console.log(publishedTransparency?.publicationProfileKey);
console.log(previewTransparency.references);

Published transparency is frozen into ContentVersion.metadata.transparency when a publication snapshot is created. Built sites should render the published snapshot, while editors can use the preview snapshot to inspect what will be shown publicly before publishing.

Publish Readiness

import { evaluateContentPublishReadiness } from '@happyvertical/smrt-content';

const readiness = await evaluateContentPublishReadiness({
  content: article,
  profileKey: 'publication',
});
console.log(readiness.ready);
console.log(readiness.blockingRequirements);

When enforcePublishReadiness is enabled on a governance assignment, content.save() will throw a ValidationError if blocking requirements are not satisfied when status is set to 'published'.

Facts Integration

Content links to facts from @happyvertical/smrt-facts when fact-linking is enabled in governance:

// Link a fact to content
await article.addFact('fact_id', 'supports');
await article.addFact('fact_id', 'contradicts');
await article.addFact('fact_id', 'referenced_in');

// Get linked facts
const facts = await article.getFacts({ latestOnly: true });
const factLinks = await article.getFactLinks();

// Sync facts state (used by API)
const factsState = await article.getFactsState();
await article.syncFactsState({ factIds: ['fact1', 'fact2'] });

Collection-level fact browsing:

const contents = await Contents.create({ db: dbConfig });
const factCatalog = await contents.browseFacts();

Content Contributions

import {
  ContentContributionType,
  ContentContributions,
  ContentContributionForm,
  ContentContributionInbox,
  ContentContributionPortal,
  ContentContributionTypeManager,
  ContentContributorManager,
  configureContentContributions,
} from '@happyvertical/smrt-content';

configureContentContributions({
  types: [
    {
      key: 'letter',
      label: 'Letter to the editor',
      enabled: true,
      allowedChannels: ['web', 'email'],
      allowText: true,
      allowFiles: true,
      allowEmptyText: false,
      intakeRules: {
        maxFiles: 3,
        allowedMimePatterns: ['image/*', 'application/pdf'],
        quarantineTextPatterns: ['lawsuit', 'defamation'],
      },
      promotion: {
        targetContentType: 'article',
        targetContentVariant: 'letter',
        targetContentStatus: 'draft',
        autoPromoteTrusted: true,
        createAssets: true,
        assetRelationship: 'attachment',
      },
    },
  ],
});

const contributions = await ContentContributions.create({
  db: { url: 'sqlite:./content.db' },
});

const result = await contributions.submitWebContribution({
  typeKey: 'letter',
  contributorEmail: 'reader@example.com',
  contributorName: 'Reader',
  title: 'A community letter',
  body: 'Please publish this letter.',
  attachments: [
    {
      filename: 'photo.jpg',
      mimeType: 'image/jpeg',
      size: 1024,
      fileKey: 'uploads/photo.jpg',
    },
  ],
  tenantId: 'tenant-1',
});

const approved = await contributions.get({ id: result.contribution.id });
await approved?.approveAction({
  editorNote: 'Looks good for editorial review.',
  targetStatus: 'draft',
});

Content contributions are held separately from editorial Content and Asset records until they are promoted. That keeps plain smrt-content generic, while supporting community intake and moderation workflows when an app opts in.

The contribution holding layer adds these first-class s-m-r-t objects:

• ContentContributionType
• ContentContributor
• ContentContribution
• ContentContributionRevision
• ContentContributionAttachment

Key behavior:

• web and email intake normalize into the same contribution package
• one contribution can contain one primary text submission plus zero or more held files
• asset-only submissions are allowed when the type permits empty text
• contributors are resolved by email within one tenant ((tenant_id, email)) and linked to a Profile of the same tenant
• trust levels are standard, trusted, or blocked
• intake rules can accept, quarantine, or reject before editorial review
• approval promotes into normal draft Content and Asset records with provenance metadata
• governance starts after promotion, based on the promoted content type and variant

Chat Integration

Content has built-in AI chat via @happyvertical/smrt-chat:

// API endpoint: GET /api/v1/contents/{id}/chat
// Returns: { session, threads } or { session: null, notice }
// API endpoint: POST /api/v1/contents/{id}/chat
// Creates a new chat thread for the content

The ContentAgentChat Svelte component provides a chat sidebar in the content editor. When chat tables aren't provisioned, it gracefully shows a "not available" notice instead of erroring.

For app-level assistants, ContentEditor and GovernedContentEditor also publish a reusable assistant registration through onAssistantContextChange. This works even when hideChat={true}:

<GovernedContentEditor
  content={article}
  contentId={article.id}
  hideChat
  onAssistantContextChange={(registration) => {
    assistantStore.setContext(registration?.context ?? null);
    assistantStore.setActions(registration?.actions ?? null);
  }}
  onSave={saveArticle}
  onCancel={closeEditor}
/>

The registration includes a serializable ContentEditorAssistantContext (contentId, draft fields, current editor body, reference IDs, and governed fact/readiness summaries) plus local actions such as triggerSave, triggerReview, applyFieldUpdates, and undo for AI-applied field updates. ContentAgentChat can be mounted outside the editor by passing the context:

<ContentAgentChat apiBaseUrl="/tenant/api/v1" assistantContext={context} />

Server integrations can use getOrCreateContentEditorChatSession, createContentEditorChatThread, listContentEditorChatThreadMessages, and sendContentEditorChatThreadMessage to install /contents/:id/chat routes with app-specific tenancy, auth, and AI model resolution hooks instead of copying the package dev-server endpoints.

Dev Server

The package includes a SvelteKit dev server (npm run dev) with:

• Contents page (/) — Content catalog with search, filters, card/list views, and full CRUD. Includes governed article creation.
• Governance page (/governance) — Policy, profile, and assignment management via ContentGovernanceManager.
• Contributions page (/contributions) — Sub-tabbed: editorial inbox, public submit form, contributor management, contribution type config.
• API Explorer page (/api-explorer) — Browse all 69 auto-generated REST endpoints grouped by domain, with try-it-live for GET endpoints.

The dev server bootstraps schemas for all 13 local @smrt() classes on startup and seeds sample content (3 items) for immediate testing.

Svelte Components

Content Management

Component	Props	Description
ContentList	contents or query, jobs, onEdit, onDelete, onAdd, getViewHref	Query-backed catalog with realtime freshness, background-job progress, retry, search, filters, and view toggles
ContentEditor	content, contentId, onSave, onCancel	Full content editor with metadata, assets, references
GovernedContentEditor	content, contentId, onSave, onCancel	Editor with integrated governance panel and review controls
ContentAgentChat	contentId, apiBasePath	AI chat sidebar for content with thread management
ContentTitleField, ContentStatusFields, ContentMetadataFields, ContentReferencesPanel, ContentImageBrowser	focused field/section props	Composable editor primitives for application-owned layouts
ContentReviewStatusTray	items, activeId, open, onSelect	Compact review status tray for inline review drawers
ArticleCard	article	Card display for an article
ArticleList	articles	List of article cards
ImageThumbnail	src, alt	Thumbnail image display
Markdown	source	Markdown renderer

The governance panels (ContentGovernancePanel, the corrections, versions and transparency tools, ContentTransparencyReport) lay out by their own width: each is a container-type: inline-size container. A size container takes its width from its host, not its content, so inside a shrink-to-fit host (an absolutely positioned popover, an auto grid track, an inline-block) give the panel or its host a definite width, or it collapses.

ContentList retry handlers must return a new job attempt with a distinct jobId. The controller retains the failed attempt as immutable history so a late event from it cannot overwrite the retry result.

Simple mode and agent-ready editor fields

ContentTitleField, ContentStatusFields, ContentMetadataFields, and ContentBodyEditor render smrt-ui fields with a stable name, an id, and a plain label, so inside any Form, rich <Form webmcp>, or FormScope they register with the control registry and an agent can propose a title, status, story, author, summary, or tags for the person to review (ContentBodyEditor registers the whole story as one body control in its own HTML/Markdown format). ContentTitleField registers once you give it a name (e.g. name="title"). Pass idPrefix to the status and metadata fields, and id/name to the title and body, when two editors share a page.

mode ('full' by default, or 'simple') sets how much of the editor an everyday editor sees; fields is an explicit allow-list that overrides it:

	full	simple
ContentStatusFields	Type, State, Status, Published	Status, Publish date (optional)
ContentMetadataFields	Author, Description, Tags, URL, File key	Author, Summary, Tags — each "(optional)" — in a collapsed Details section (details controls it)
ContentEditor	every field and drawer	Type, State and References (with URL/File key) hidden; Metadata becomes a collapsed "Details"

Simple mode uses plain labels ("Ready for review", "Summary", "Story").

Applications that compose their own article editor can use createContentEditorState, getContentEditorAssetImageSource, and resolveContentEditorImageSelection to share the same form normalization, thumbnail selection, and save payload behavior as the package editors.

Body format picker

The toolbar's "Save as" HTML/Markdown picker is hidden by default. Pass showFormatPicker to ContentBodyEditor (or showBodyFormatPicker to ContentEditor) to offer it to technical editors. Without it the body keeps the format it was given.

Image panel and thumbnail block

ContentBodyEditor takes an imagePanel snippet with imagePanelOpen and onCloseImagePanel: the application's picture chooser/editor opens between the toolbar and the text (full width, in the page flow, no modal), the image button reports aria-expanded/aria-controls, focus moves into the panel on open and back to the button on close, and Escape inside it asks to close.

When content gets a thumbnail, placeThumbnailInBody(body, format, image) also shows it in the body at the standard spot for its shape (thumbnailPlacementForSize: width ÷ height ≥ 1.3 is a full-width header at the top; portrait or square floats right of the first paragraph, stacking full width on phones). The block is marked (data-smrt-thumbnail in HTML, the image title smrt-thumbnail:<placement> in Markdown) so placing again replaces it and removeThumbnailFromBody clears it. resolveContentEditorImageDimensions(asset, src) reads the size from the asset or by loading the image. Public pages render stored bodies of either format with renderContentBodyHtml(body, format, { thumbnailSrc }) (or ContentBodyRenderer), which sanitizes, turns the Markdown token into the same marked <img>, and can point the thumbnail at the page's own asset URL.

Body sanitizing

sanitizeHtml, renderMarkdownToHtml, renderContentBodyHtml, and the editor load/save helpers parse bodies with sanitize-html (htmlparser2, no DOM — identical in Node SSR/prerender and the browser) against an allowlist: headings, paragraphs, lists, blockquote, pre/code, tables, figures, inline emphasis, links (http(s), mailto, tel, relative; target="_blank" gets rel="noopener noreferrer"), and images (http(s), relative, raster data:image/* — never SVG) with the editor's data-smrt-* layout and thumbnail markers and a width/max-width/ height: auto style. Everything else is removed: scripts, event handlers, javascript:/vbscript: URLs, iframes and embeds (there is no embed feature), SVG/MathML, forms, media, classes, ids, and other CSS. Raw-text and foreign-content elements are dropped with their content, and the output is re-serialized with escaped text, so nested or malformed markup cannot reassemble into a live tag.

Governance

Component	Props	Description
ContentGovernanceManager	(self-contained)	Full manager for policies, profiles, and assignments
ContentGovernancePanel	contentId	Governance status panel for a single content item
ContentGovernancePolicyEditor	policy, onSave	Editor for a single policy
ContentGovernanceProfileEditor	profile, onSave	Editor for a single profile
ContentGovernanceAssignmentEditor	assignment, onSave	Editor for a single assignment
ContentTransparencyReport	data	Renders the transparency report for published content

Contributions

Component	Props	Description
ContentContributionForm	types, onSubmit, onCancel	Public submission form with file uploads
ContentContributionInbox	contributions, selectedId, onSelect, onApprove, onReject, onRequestChanges	Editorial inbox with approve/reject/request-changes actions
ContentContributionPortal	contributions, onSelect, onWithdraw	Contributor-facing submission tracker
ContentContributionTypeManager	types, onSave, onDelete	Manage contribution types, channels, and promotion settings
ContentContributorManager	contributors, onSave, onDelete	Manage contributors with trust levels

API

Classes

Export	Description
Content	STI base model. Fields: type, variant, status, state, category, tags, metadata, thumbnailAssetId
ContentAsset	Junction model for canonical content-to-asset ownership in content_assets
Article	STI subclass for editorial content
ContentDocument	STI subclass for structured documents
Mirror	STI subclass for mirrored/cached external content
Contents	Collection with mirror(), syncContentDir(), generateMissingThumbnails(), findWithGlobals(), getOrUpsert(), browseFacts(), getGovernanceDefinitionsAction(), resolveGovernanceAction()
ContentReference	Junction model for content-to-content links; nullable targetVersion pins citation-time ContentVersion.version for drift detection
ContentReview	AI review result tied to a governance policy
ContentCorrection	Post-publication correction record
ContentVersion	Content snapshot with kind ('manual', 'draft', 'review', 'publication', 'correction', or 'auto-generated') and transparency metadata
ContentContribution	Held inbound submission with approval, rejection, withdrawal, and promotion actions
ContentContributions	Contribution collection with web intake, email ingestion, inbox, and contributor views
ContentContributionType	Persisted contribution-type override for app-defined intake rules and promotion mapping
ContentContributor	Contributor profile/trust record resolved by email within its tenant
ContentContributionRevision	Revision history for held submissions
ContentContributionAttachment	Held file metadata that only becomes an Asset on promotion
ContentGovernancePolicy	Persisted review policy definition
ContentGovernanceProfile	Persisted review profile with requirements
ContentGovernanceAssignment	Persisted governance assignment for content type/variant
ThumbnailGenerator	Generates thumbnails via headline-card, static-map, or ai-generate strategies

Content Instance Methods

Method	Description
resolveGovernance()	Resolve effective governance for this content's type/variant
runReviewAction(options)	Run an AI review against a policy
listReviews()	List all reviews for this content
listReviewProfilesAction()	Get review readiness for all profiles
evaluateReviewProfile(key)	Evaluate one profile's requirements
issueCorrectionAction(options)	Issue a post-publication correction
listCorrections()	List corrections for this content
listVersions()	List version history
mutateVersionAction(options)	Create a version snapshot
getPublishedTransparencyAction()	Get frozen transparency data
previewTransparencyAction()	Preview live transparency state
addFact(factId, relationship)	Link a fact to this content
getFacts(options)	Get linked facts
getFactLinks()	Get fact-content link records
getFactsState()	Get full facts state (API)
syncFactsState(options)	Sync fact links (API)
getAssets(relationship?)	Get associated assets
addAsset(asset, relationship, sortOrder)	Add asset association
removeAsset(assetId, relationship?)	Remove asset association
setThumbnail(image)	Set thumbnail (adds asset + updates thumbnailAssetId)
generateThumbnail(options)	Generate a thumbnail
addReference(content, options?)	Link to another content; pass { targetVersion } to pin the citation to a specific ContentVersion.version
getReferences()	Get content references
getReferenceDrift()	Per-edge { citedVersion, currentVersion, isDrifted } — surfaces references whose pinned version differs from the target's latest

Types

Export	Description
ContentOptions	Options for Content constructor
ContentsOptions	Options for Contents.create()
ThumbnailStrategy	'headline-card' | 'static-map' | 'ai-generate'
ThumbnailOptions	Union of strategy-specific option types
HeadlineCardThumbnailOptions	Options for headline-card strategy
StaticMapThumbnailOptions	Options for static-map strategy
AIGenerateThumbnailOptions	Options for ai-generate strategy
ContentContributionTypeDefinition	App-defined contribution type shape
ContentGovernanceConfig	Shape passed to configureContentGovernance()
ContentGovernanceState	Resolved governance state for a content item
ContentReviewResult	AI review output with findings
ContentReviewFinding	Individual issue from a review
ContentCorrectionType	'correction' | 'retraction' | 'update' | 'clarification'
ContentVersionKind	'manual' | 'draft' | 'review' | 'publication' | 'correction' | 'auto-generated'
ContentTransparencyData	Full transparency report data shape
ContentPublishReadinessState	Profile evaluation result

Utilities

Export	Description
contentToString(content)	Serialize content to markdown with YAML frontmatter
stringToContent(str)	Parse markdown with frontmatter back to content data
configureContentGovernance(config)	Define default governance policies, profiles, and assignments
configureContentContributions(config)	Define default contribution types and intake rules
evaluateContentPublishReadiness(options)	Evaluate publication readiness against a profile
normalizeContentTransparency(raw)	Normalize raw transparency data into standard shape

Auto-Generated Endpoints

The @smrt() decorator generates REST API, MCP tools, and CLI commands.

Content Endpoints (instance-level)

Method	Path	Description
GET	/api/v1/contents	List contents
POST	/api/v1/contents	Create content
GET	/api/v1/contents/{id}	Get content
PUT	/api/v1/contents/{id}	Update content
DELETE	/api/v1/contents/{id}	Delete content
GET	/api/v1/contents/{id}/facts	Get facts state
PUT	/api/v1/contents/{id}/facts	Sync facts state
GET	/api/v1/contents/{id}/governance	Get governance state
GET	/api/v1/contents/{id}/reviews	List reviews
POST	/api/v1/contents/{id}/reviews	Run AI review
GET	/api/v1/contents/{id}/review-profiles	Review readiness
GET	/api/v1/contents/{id}/review-profiles/{profileKey}	Evaluate profile
GET	/api/v1/contents/{id}/transparency	Published transparency
GET	/api/v1/contents/{id}/transparency/preview	Preview transparency
GET	/api/v1/contents/{id}/corrections	List corrections
POST	/api/v1/contents/{id}/corrections	Issue correction
GET	/api/v1/contents/{id}/versions	List versions
POST	/api/v1/contents/{id}/versions	Create version

Collection Endpoints

Method	Path	Description
GET	/api/v1/contents/by-slug?slug=...	Get by slug
GET	/api/v1/contents/facts	Browse fact catalog
GET	/api/v1/contents/governance	Governance definitions
GET	/api/v1/contents/governance/resolve?type=...	Resolve governance

All s-m-r-t models (ContentGovernancePolicy, ContentContribution, etc.) also get standard CRUD + custom collection-level endpoints.

Dependencies

Package	Purpose
@happyvertical/smrt-core	ORM base (SmrtObject, SmrtCollection)
@happyvertical/smrt-assets	Asset association support
@happyvertical/smrt-images	Image/thumbnail creation
@happyvertical/smrt-facts	Fact linking and browsing
@happyvertical/smrt-chat	Content chat sessions and threads
@happyvertical/smrt-messages	Email ingestion for contribution intake
@happyvertical/smrt-profiles	Contributor/profile resolution by email
@happyvertical/smrt-tenancy	Optional tenant scoping
@happyvertical/documents	Document fetching and text extraction
@happyvertical/files	Filesystem operations
@happyvertical/geo	Static map thumbnails
@happyvertical/images	Headline card rendering
yaml	YAML frontmatter parsing

Browser QA: pnpm test:e2e builds package dependencies and runs Playwright. Playwright resets its fixture-owned .smrt/e2e-playwright.db, builds the app with the normal SvelteKit toolchain, and serves compiled assets with Vite preview on 127.0.0.1:4173 by default (SMRT_CONTENT_E2E_PORT selects another port). App output stays in .svelte-kit/output/, separate from the published library's dist/. Build failures or an occupied port fail startup. The six maintained scenarios retain their authorization and behavior assertions; failure traces, screenshots, and videos remain available for diagnosis. Set PLAYWRIGHT_CHROMIUM_EXECUTABLE_PATH=/path/to/chromium to use an installed Chromium when Playwright's managed browser dependencies are unavailable.