@dxos/plugin-magazine 0.0.0

package/src/stories/ArticleExtractor.stories.tsx

@@ -0,0 +1,204 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+import React, { useCallback, useMemo, useState } from 'react';
+
+import { IconButton, Input, Panel, ScrollArea, Select, Toolbar } from '@dxos/react-ui';
+import { composable } from '@dxos/react-ui';
+import { SyntaxHighlighter } from '@dxos/react-ui-syntax-highlighter';
+import { withLayout, withTheme } from '@dxos/react-ui/testing';
+
+import { translations } from '#translations';
+
+import { PostContent } from '../components';
+import { type ExtractedArticle, extractArticle } from '../operations/extraction';
+import { Subscription } from '../types';
+
+type State =
+  | { status: 'idle' }
+  | { status: 'loading' }
+  | { status: 'ok'; article: ExtractedArticle; sourceLength: number }
+  | { status: 'error'; message: string };
+
+const SAMPLE_URLS = [
+  'https://www.inkandswitch.com/essay/local-first/',
+  'https://martinfowler.com/articles/cant-buy-integration.html',
+  'https://overreacted.io/before-you-memo/',
+  'https://www.theregister.com/2026/04/24/deepseek_v4/',
+];
+
+const formatBytes = (n: number): string => (n < 1024 ? `${n} B` : `${(n / 1024).toFixed(1)} KB`);
+
+const DefaultStory = () => {
+  const [url, setUrl] = useState(SAMPLE_URLS[0]);
+  const [state, setState] = useState<State>({ status: 'idle' });
+  const [showMarkdown, setShowMarkdown] = useState(false);
+
+  const handleFetch = useCallback(async () => {
+    if (!url) {
+      return;
+    }
+    setState({ status: 'loading' });
+    try {
+      // Storybook ships the same `/api/rss?url=` middleware as composer-app for CORS-free fetches.
+      const proxyUrl = `/api/rss?url=${encodeURIComponent(url)}`;
+      const response = await fetch(proxyUrl, { redirect: 'follow' });
+      if (!response.ok) {
+        throw new Error(`Fetch failed: ${response.status} ${response.statusText}`);
+      }
+      const html = await response.text();
+      const article = await extractArticle(html, url);
+      setState({ status: 'ok', article, sourceLength: html.length });
+    } catch (error) {
+      setState({ status: 'error', message: String(error) });
+    }
+  }, [url]);
+
+  return (
+    <Panel.Root>
+      <Panel.Toolbar asChild>
+        <Toolbar.Root>
+          <Input.Root>
+            <Input.TextInput
+              placeholder='Article URL'
+              value={url}
+              onChange={(event) => setUrl(event.target.value)}
+              onKeyDown={(event) => {
+                if (event.key === 'Enter') {
+                  void handleFetch();
+                }
+              }}
+              classNames='is-full min-is-[24rem]'
+            />
+          </Input.Root>
+          <Select.Root
+            value={url}
+            onValueChange={(sample) => {
+              setUrl(sample);
+              setState({ status: 'idle' });
+            }}
+          >
+            <Toolbar.Button asChild>
+              <Select.TriggerButton placeholder='Sample URL' />
+            </Toolbar.Button>
+            <Select.Portal>
+              <Select.Content>
+                <Select.Viewport>
+                  {SAMPLE_URLS.map((sample) => (
+                    <Select.Option key={sample} value={sample}>
+                      {new URL(sample).hostname}
+                    </Select.Option>
+                  ))}
+                </Select.Viewport>
+                <Select.Arrow />
+              </Select.Content>
+            </Select.Portal>
+          </Select.Root>
+          <Toolbar.IconButton
+            icon='ph--arrow-clockwise--regular'
+            iconOnly
+            label='Fetch'
+            onClick={() => void handleFetch()}
+            disabled={state.status === 'loading'}
+          />
+          <IconButton
+            label={showMarkdown ? 'Show preview' : 'Show Markdown'}
+            icon={showMarkdown ? 'ph--article--regular' : 'ph--code--regular'}
+            iconOnly
+            aria-pressed={showMarkdown}
+            onClick={() => setShowMarkdown((showMarkdown) => !showMarkdown)}
+          />
+        </Toolbar.Root>
+      </Panel.Toolbar>
+      <Panel.Content asChild>
+        {state.status === 'ok' ? (
+          <ResultView article={state.article} sourceLength={state.sourceLength} showMarkdown={showMarkdown} />
+        ) : (
+          <div>
+            {state.status === 'idle' && (
+              <p className='p-2 text-sm text-subdued'>Paste an article URL and press Fetch to see the extraction.</p>
+            )}
+            {state.status === 'loading' && <p className='p-2 text-sm text-subdued'>Fetching and extracting…</p>}
+            {state.status === 'error' && (
+              <pre className='p-2 text-sm text-error whitespace-pre-wrap break-all'>{state.message}</pre>
+            )}
+          </div>
+        )}
+      </Panel.Content>
+    </Panel.Root>
+  );
+};
+
+type ResultViewProps = {
+  article: ExtractedArticle;
+  sourceLength: number;
+  showMarkdown: boolean;
+};
+
+const ResultView = composable<HTMLDivElement, ResultViewProps>(
+  ({ article, sourceLength, showMarkdown, ...props }, forwardedRef) => {
+    const post = useMemo(
+      () =>
+        Subscription.makePost({
+          title: article.title,
+          author: article.author,
+          published: article.published,
+          // The story renders the extracted body via `description`; the new
+          // Post schema no longer carries `content`/`imageUrl` — those live
+          // on Subscription.postState now. The storybook flow is a
+          // standalone preview (no Subscription), so we just feed the body
+          // through `description`.
+          description: article.markdown,
+        }),
+      [article],
+    );
+
+    const metadata = [
+      article.domain,
+      article.wordCount && `${article.wordCount.toLocaleString()} words`,
+      `source ${formatBytes(sourceLength)}`,
+      `${article.imageUrls.length} images`,
+    ].filter((value): value is string => Boolean(value));
+
+    if (showMarkdown) {
+      return (
+        <ScrollArea.Root {...props} orientation='vertical' thin ref={forwardedRef}>
+          <ScrollArea.Viewport>
+            <SyntaxHighlighter language='markdown' classNames='m-4'>
+              {article.markdown}
+            </SyntaxHighlighter>
+          </ScrollArea.Viewport>
+        </ScrollArea.Root>
+      );
+    }
+
+    return <PostContent {...props} ref={forwardedRef} post={post} metadata={metadata} />;
+  },
+);
+
+ResultView.displayName = 'ResultView';
+
+const meta = {
+  title: 'plugins/plugin-magazine/stories/ArticleExtractor',
+  render: DefaultStory,
+  decorators: [withTheme(), withLayout({ layout: 'column' })],
+  parameters: {
+    layout: 'fullscreen',
+    translations,
+  },
+} satisfies Meta<typeof DefaultStory>;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+/**
+ * Live preview of the defuddle-based article extractor.
+ *
+ * Paste a URL → the storybook-react vite middleware proxies the fetch via
+ * `/api/rss?url=` to bypass browser CORS → the HTML is run through
+ * `extractArticle` → the result is rendered with `MarkdownView`.
+ */
+export const Default: Story = {};

package/src/stories/MagazineCurate.stories.tsx

@@ -0,0 +1,217 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import React from 'react';
+import { expect, userEvent, waitFor, within } from 'storybook/test';
+
+import { AiService } from '@dxos/ai';
+import { AiServiceTestingPreset } from '@dxos/ai/testing';
+import { ActivationEvents, Capabilities, Capability, Plugin } from '@dxos/app-framework';
+import { withPluginManager } from '@dxos/app-framework/testing';
+import { Surface } from '@dxos/app-framework/ui';
+import { AppPlugin } from '@dxos/app-toolkit';
+import { AppSurface } from '@dxos/app-toolkit/ui';
+import { AgentHandlers } from '@dxos/assistant-toolkit';
+import { type Client } from '@dxos/client';
+import { type Space } from '@dxos/client/echo';
+import { LayerSpec } from '@dxos/compute';
+import { DXN, Feed, Filter, Ref } from '@dxos/echo';
+import { ClientPlugin, initializeIdentity } from '@dxos/plugin-client/testing';
+import { RoutinePlugin } from '@dxos/plugin-routine/plugin';
+import { SpacePlugin } from '@dxos/plugin-space/testing';
+import { StorybookPlugin, corePlugins } from '@dxos/plugin-testing';
+import { useQuery, useSpaces } from '@dxos/react-client/echo';
+import { Panel } from '@dxos/react-ui';
+import { Loading, withLayout } from '@dxos/react-ui/testing';
+import { Text } from '@dxos/schema';
+
+import { MagazineSkill } from '#skills';
+import { translations } from '#translations';
+import { Magazine, Subscription } from '#types';
+
+import { MagazineArticle } from '../containers/MagazineArticle/MagazineArticle';
+import { MagazinePlugin } from '../MagazinePlugin';
+
+// Curation runs the agent (CurateMagazine → RunInstructions). The process-manager runtime therefore needs
+// the full agent stack: RoutinePlugin supplies the OpaqueToolkit / Registry / Trace LayerSpecs and
+// MagazinePlugin the curation handlers; this story-local plugin adds the RunInstructions handler and a
+// live edge AiService (the 'edge-remote' testing preset — no client edge-config or credentials needed).
+// Excluded from CI (the `Test` story is `!test`); intended for manual, signed-in, online use.
+const aiServiceSpec = LayerSpec.make({ affinity: 'space', requires: [], provides: [AiService.AiService] }, () =>
+  AiServiceTestingPreset('edge-remote').pipe(Layer.orDie),
+);
+
+const AgentRuntimePlugin = Plugin.define(
+  Plugin.makeMeta({ key: DXN.make('org.dxos.plugin.magazineStoryAgent'), name: 'Magazine Story Agent Runtime' }),
+).pipe(
+  AppPlugin.addOperationHandlerModule({
+    activate: Capability.makeModule(() =>
+      Effect.succeed([Capability.contributes(Capabilities.OperationHandler, AgentHandlers)]),
+    ),
+  }),
+  Plugin.addModule({
+    id: 'ai-service',
+    activatesOn: ActivationEvents.SetupProcessManager,
+    activate: Capability.makeModule(() =>
+      Effect.succeed([Capability.contributes(Capabilities.LayerSpec, aiServiceSpec)]),
+    ),
+  }),
+  Plugin.make,
+);
+
+// Source the magazine from the live The Register "AI + ML" feed.
+const REGISTER_FEED_URL =
+  'https://api.theregister.com/api/v1/article?query=tag:%22ai%20and%20ml%22&orderBy=published&site_id=2&remapper=rss&limit=25';
+
+// Mock fetcher: serve the bundled fixture instead of hitting the network so the
+// story is deterministic offline. Matches both the direct URL (seed) and the
+// browser CORS-proxied form (`/api/rss?url=<encoded>`) used by SyncFeed; the
+// encoded URL still contains the literal `theregister.com`. Other URLs delegate
+// to the original fetch.
+// eslint-disable-next-line no-restricted-globals
+const originalFetch = globalThis.fetch.bind(globalThis);
+
+const installRegisterFetchMock = async () => {
+  const { default: registerFeedXml } = await import('./fixtures/theregister-ai.xml?raw');
+  const registerFetchMock: typeof fetch = async (input, init) => {
+    const url = typeof input === 'string' ? input : input instanceof URL ? input.toString() : input.url;
+    if (url.includes('theregister.com')) {
+      return new Response(registerFeedXml, { status: 200, headers: { 'content-type': 'application/rss+xml' } });
+    }
+    return originalFetch(input, init);
+  };
+  globalThis.fetch = registerFetchMock;
+};
+
+// Bridge from the seed (runs in the plugin-manager/client-init context) to the `Curate` play test,
+// which reads ECHO state directly. A module-level variable does not survive Storybook's seed↔play
+// boundary, so a shared global is used (mirrors plugin-space/plugin-debug story seeds).
+declare global {
+  // eslint-disable-next-line no-var
+  var __magazineStoryContext: { space: Space; magazine: Magazine.Magazine } | undefined;
+}
+
+const DefaultStory = () => {
+  const spaces = useSpaces();
+  const space = spaces[spaces.length - 1];
+  const magazines = useQuery(space?.db, Filter.type(Magazine.Magazine));
+  const magazine = magazines[0];
+  if (!magazine) {
+    return <Loading />;
+  }
+
+  return (
+    <Panel.Root classNames='border-is border-separator'>
+      <Panel.Content className='px-3 grid grid-cols-2 gap-3'>
+        {/* Rendered directly: the `article` role is shared with plugin-space's catch-all RecordArticle
+            (position:last), so a raw `Surface type={Article}` here is ambiguous and resolves to the
+            fallback — the deck disambiguates via the app-graph node, which a story has no equivalent of. */}
+        <MagazineArticle role='article' subject={magazine} attendableId='story' />
+        {/* The object-properties companion surface (plugin-space DefaultProperties); 'settings' is unambiguous. */}
+        <Surface.Surface type={AppSurface.Article} data={{ subject: 'settings', companionTo: magazine }} />
+      </Panel.Content>
+    </Panel.Root>
+  );
+};
+
+const seedRegisterMagazine = ({ client }: { client: Client }) =>
+  Effect.gen(function* () {
+    globalThis.__magazineStoryContext = undefined;
+    yield* Effect.promise(() => installRegisterFetchMock());
+    yield* initializeIdentity(client);
+    const space = (yield* Effect.promise(() => client.spaces.create())) as Space;
+    yield* Effect.promise(() => space.waitUntilReady());
+
+    // Feed points at the real Register AI/ML URL; the mock fetcher serves the
+    // bundled fixture. Posts are NOT pre-seeded — clicking Curate drives the live
+    // flow (SyncFeed fetches + parses, then CurateMagazine runs the Routine via the
+    // agent to select Posts into `magazine.posts`).
+    const feed = space.db.add(
+      Subscription.makeSubscription({ name: 'The Register — AI + ML', url: REGISTER_FEED_URL, type: 'rss' }),
+    );
+
+    const magazine = Magazine.make({ name: 'AI', feeds: [Ref.make(feed)] });
+    space.db.add(magazine);
+    // Curation resolves the base methodology skill from the registry; register it here since the
+    // automation plugin (which normally syncs SkillDefinition capabilities) isn't in this story.
+    client.graph.registry.add([MagazineSkill.make()]);
+    yield* Effect.promise(() => space.db.flush());
+
+    globalThis.__magazineStoryContext = { space, magazine };
+  });
+
+const meta: Meta<typeof DefaultStory> = {
+  title: 'plugins/plugin-magazine/stories/MagazineCurate',
+  component: DefaultStory,
+  decorators: [
+    withLayout({ layout: 'fullscreen' }),
+    withPluginManager({
+      plugins: [
+        ...corePlugins(),
+        ClientPlugin({
+          types: [Feed.Feed, Subscription.Subscription, Subscription.Post, Magazine.Magazine, Text.Text],
+          onClientInitialized: seedRegisterMagazine,
+        }),
+        SpacePlugin({}),
+        StorybookPlugin({}),
+        RoutinePlugin(),
+        MagazinePlugin(),
+        AgentRuntimePlugin(),
+      ],
+    }),
+  ],
+  parameters: {
+    layout: 'fullscreen',
+    translations,
+  },
+};
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+export const Default: Story = {};
+
+/**
+ * Live, agent-driven curation end-to-end against the The Register "AI + ML" feed (the feed fetch is
+ * served from a bundled fixture, but the LLM call is real). It verifies:
+ *   1. the curation Routine exists — created with the magazine (Magazine.make), so it is present
+ *      before any curate; and
+ *   2. clicking Curate pulls the feed (SyncFeed) and runs that Routine via RunInstructions against the
+ *      live edge model, which selects matching Posts into `magazine.posts` (rendered as tiles).
+ *
+ * The seed stashes the space + magazine in module scope so the play can read ECHO state directly.
+ *
+ * Excluded from CI (`!test`) — needs network + a reachable edge model and is non-deterministic/slow;
+ * run it manually (signed in, online). Deterministic pieces are covered by `theregister-fixture.test.ts`
+ * (fetch → parse), `curate-magazine.test.ts`, and `Magazine.test.ts`; the agent path by
+ * `curate-magazine.skill.test.ts`.
+ */
+export const Curate: Story = {
+  tags: ['!test'],
+  play: async ({ canvasElement }) => {
+    const canvas = within(canvasElement);
+    // The seed sets the context at the end of its async init, which can land just after the magazine
+    // first renders — so wait for it rather than reading once.
+    await waitFor(() => expect(globalThis.__magazineStoryContext, 'story seed did not run').toBeDefined(), {
+      timeout: 15_000,
+    });
+    const { magazine } = globalThis.__magazineStoryContext!;
+
+    // The curation Routine is created with the magazine, not on curate.
+    await expect(magazine.instructions).toBeDefined();
+
+    // Starts empty; clicking Curate pulls the feed and runs the Routine.
+    await expect(await canvas.findByText(/no articles yet/i, {}, { timeout: 10_000 })).toBeVisible();
+    await userEvent.click(await canvas.findByRole('button', { name: /^curate$/i }));
+
+    // Feed pulled + Routine run: the agent (live edge model) selects synced candidates into the
+    // magazine — tiles replace the empty state.
+    await waitFor(() => expect(magazine.posts.length).toBeGreaterThan(0), { timeout: 120_000 });
+    await waitFor(() => expect(canvas.queryByText(/no articles yet/i)).toBeNull(), { timeout: 5_000 });
+  },
+};

package/src/stories/fixtures/theregister-ai.xml

@@ -0,0 +1,45 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<rss version="2.0" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/">
+  <channel>
+    <title>The Register - AI + ML</title>
+    <link>https://www.theregister.com/software/ai_ml/</link>
+    <description>Biting the hand that feeds IT — AI and machine learning coverage.</description>
+    <language>en-us</language>
+    <item>
+      <title>Sovereign AI push has nations racing to build domestic compute</title>
+      <link>https://www.theregister.com/2026/05/28/sovereign_ai_compute/</link>
+      <dc:creator>Tobias Mann</dc:creator>
+      <pubDate>Wed, 28 May 2026 09:30:00 GMT</pubDate>
+      <guid isPermaLink="true">https://www.theregister.com/2026/05/28/sovereign_ai_compute/</guid>
+      <description><![CDATA[<p>Governments from the EU to the Gulf are pouring billions into <strong>sovereign AI</strong> infrastructure, determined to keep models, data, and GPUs within national borders.</p>]]></description>
+      <content:encoded><![CDATA[<p>Governments from the EU to the Gulf are pouring billions into <strong>sovereign AI</strong> infrastructure, determined to keep models, data, and GPUs within national borders. Analysts say the trend marks a decisive break from the cloud-centric assumptions of the last decade.</p><p>The shift is reshaping procurement, with state-backed clouds demanding on-shore training runs and audited supply chains.</p>]]></content:encoded>
+    </item>
+    <item>
+      <title>Open-weights model claims parity with frontier labs at a fraction of the cost</title>
+      <link>https://www.theregister.com/2026/05/27/open_weights_frontier/</link>
+      <dc:creator>Katyanna Quach</dc:creator>
+      <pubDate>Tue, 27 May 2026 14:05:00 GMT</pubDate>
+      <guid isPermaLink="true">https://www.theregister.com/2026/05/27/open_weights_frontier/</guid>
+      <description><![CDATA[<p>A new open-weights release is the latest to argue that smaller, cheaper models can match the big labs on reasoning benchmarks.</p>]]></description>
+      <content:encoded><![CDATA[<p>A new open-weights release is the latest to argue that smaller, cheaper models can match the big labs on reasoning benchmarks — and it ships under a permissive licence.</p>]]></content:encoded>
+    </item>
+    <item>
+      <title>Datacenter power demand from AI training forces grid rethink</title>
+      <link>https://www.theregister.com/2026/05/26/ai_datacenter_power/</link>
+      <dc:creator>Dan Robinson</dc:creator>
+      <pubDate>Mon, 26 May 2026 11:20:00 GMT</pubDate>
+      <guid isPermaLink="true">https://www.theregister.com/2026/05/26/ai_datacenter_power/</guid>
+      <description><![CDATA[<p>Utilities warn that the appetite of AI training clusters is outpacing new generation capacity in several regions.</p>]]></description>
+      <content:encoded><![CDATA[<p>Utilities warn that the appetite of AI training clusters is outpacing new generation capacity, pushing operators toward on-site generation and long-term nuclear deals.</p>]]></content:encoded>
+    </item>
+    <item>
+      <title>Regulators circle AI agents as autonomous tooling spreads</title>
+      <link>https://www.theregister.com/2026/05/25/ai_agent_regulation/</link>
+      <dc:creator>Brandon Vigliarolo</dc:creator>
+      <pubDate>Sun, 25 May 2026 08:00:00 GMT</pubDate>
+      <guid isPermaLink="true">https://www.theregister.com/2026/05/25/ai_agent_regulation/</guid>
+      <description><![CDATA[<p>As agentic systems take actions on users' behalf, lawmakers are weighing liability and audit requirements.</p>]]></description>
+      <content:encoded><![CDATA[<p>As agentic systems take actions on users' behalf, lawmakers are weighing liability and audit requirements for the software that decides and acts.</p>]]></content:encoded>
+    </item>
+  </channel>
+</rss>

package/src/stories/theregister-fixture.test.ts

@@ -0,0 +1,35 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { afterEach, beforeEach, describe, test, vi } from 'vitest';
+
+import { EffectEx } from '@dxos/effect';
+
+import { fetchRss } from '../operations/sources';
+import registerFeedXml from './fixtures/theregister-ai.xml?raw';
+
+const REGISTER_FEED_URL = 'https://api.theregister.com/api/v1/article?remapper=rss';
+
+describe('theregister fixture', () => {
+  beforeEach(() => {
+    vi.stubGlobal(
+      'fetch',
+      vi.fn(
+        async () => new Response(registerFeedXml, { status: 200, headers: { 'content-type': 'application/rss+xml' } }),
+      ),
+    );
+  });
+
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+
+  test('parses into Posts via the mock fetcher', async ({ expect }) => {
+    const { feed, posts } = await EffectEx.runPromise(fetchRss(REGISTER_FEED_URL));
+    expect(feed.name).toMatch(/register/i);
+    expect(posts.length).toBe(4);
+    expect(posts.some((post) => /sovereign ai/i.test(post.title ?? ''))).toBe(true);
+    expect(posts.every((post) => Boolean(post.description))).toBe(true);
+  });
+});

package/src/templates/magazine-curation.ts

@@ -0,0 +1,47 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Trigger } from '@dxos/compute';
+import { Ref } from '@dxos/echo';
+import { invariant } from '@dxos/invariant';
+import { Routine, type RoutineCapabilities } from '@dxos/plugin-routine/types';
+
+import { FeedOperation, Magazine } from '#types';
+
+/** Default cron for a magazine curation routine: daily at 9 AM. The user edits the schedule from the trigger. */
+const DEFAULT_CRON = '0 9 * * *';
+
+/**
+ * Magazine curation template. Creates a routine that invokes {@link FeedOperation.CurateMagazine} for
+ * the companion's Magazine subject on a daily schedule. Only visible in Magazine object companions.
+ */
+export const magazineCuration: RoutineCapabilities.Template = {
+  id: 'org.dxos.routine.magazineCuration',
+  label: 'Curate Magazine',
+  icon: 'ph--sparkle--regular',
+  appliesTo: (subject) => subject != null && Magazine.instanceOf(subject),
+  scaffold: ({ name, subject }) =>
+    Effect.gen(function* () {
+      invariant(
+        subject != null && Magazine.instanceOf(subject),
+        'Magazine curation template requires a Magazine subject.',
+      );
+
+      const magazine = subject;
+
+      // Pre-populate the trigger's input so the magazine binding is preserved through the save flow.
+      return Routine.make({
+        name: name ?? magazine.name ?? 'Curate Magazine',
+        // Bind the CurateMagazine operation directly as the action (an operation action, not instructions-based).
+        spec: { kind: 'runnable', runnable: Ref.fromURI(FeedOperation.CurateMagazine.meta.key) },
+        trigger: Trigger.make({
+          enabled: false,
+          spec: Trigger.specTimer(DEFAULT_CRON),
+          input: { magazine: Ref.make(magazine) },
+        }),
+      });
+    }),
+};

package/src/testing/builder.ts

@@ -0,0 +1,77 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { subDays } from 'date-fns';
+
+import { Ref } from '@dxos/echo';
+import { random } from '@dxos/random';
+
+import { Magazine, Subscription } from '#types';
+
+/** Generates an array of random posts. */
+export const generatePosts = (count: number): Subscription.Post[] => {
+  const now = new Date();
+  const start = subDays(now, 30);
+  const rangeMs = now.getTime() - start.getTime();
+
+  return Array.from({ length: count }, () => {
+    const published = new Date(start.getTime() + Math.random() * rangeMs);
+    return Subscription.makePost({
+      title: random.lorem.sentence(random.number.int({ min: 4, max: 10 })),
+      link: random.internet.url(),
+      description: random.lorem.paragraph(random.number.int({ min: 1, max: 3 })),
+      author: random.person.fullName(),
+      published: published.toISOString(),
+      guid: random.string.uuid(),
+    });
+  }).sort((postA, postB) => (postB.published ?? '').localeCompare(postA.published ?? ''));
+};
+
+/** Generates a random subscription feed. */
+export const generateFeed = (
+  props: Partial<{ name: string; url: string; description: string }> = {},
+): Subscription.Subscription =>
+  Subscription.makeSubscription({
+    name: props.name ?? random.company.name() + ' Blog',
+    url: props.url ?? random.internet.url(),
+    description: props.description ?? random.lorem.sentence(),
+  });
+
+/**
+ * Generates a Post. Note: per-Post state (snippet, imageUrl, readAt) is no
+ * longer on the Post itself — it lives on the source Subscription's or
+ * Magazine's `postState` map. The caller is responsible for seeding those if
+ * the story / test needs them. The `read` / `imageUrl` params are kept on
+ * the signature for back-compat call sites; they are currently no-ops and
+ * will be wired through state-seeding helpers in a follow-up.
+ */
+export const generateCuratedPost = (_props: { imageUrl?: string; read?: boolean } = {}): Subscription.Post => {
+  const description = random.lorem.paragraph(random.number.int({ min: 2, max: 4 }));
+  // TODO: seed Magazine.postState / Subscription.postState here once the
+  // builder has access to them; for now Posts are bare feed entries and
+  // tile snippets are recomputed on render from `description`.
+  return Subscription.makePost({
+    title: random.lorem.sentence(random.number.int({ min: 4, max: 10 })),
+    link: random.internet.url(),
+    description,
+    author: random.person.fullName(),
+    published: new Date(Date.now() - Math.random() * 7 * 24 * 3600 * 1000).toISOString(),
+    guid: random.string.uuid(),
+  });
+};
+
+/** Generates a Magazine with the given curated posts. Feeds default to empty. */
+export const generateMagazine = (
+  props: Partial<{
+    name: string;
+    feeds: Subscription.Subscription[];
+    posts: Subscription.Post[];
+  }> = {},
+): Magazine.Magazine => {
+  return Magazine.make({
+    name: props.name ?? random.company.name() + ' Reading List',
+    feeds: (props.feeds ?? []).map((feed) => Ref.make(feed)),
+    posts: (props.posts ?? []).map((post) => Ref.make(post)),
+  });
+};

package/src/testing/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export * from './builder';