@dxos/plugin-magazine 0.10.0 → 0.11.0

package/dist/lib/chunk-types.mjs

@@ -0,0 +1,607 @@
+import { trim } from "@dxos/util";
+import * as Schema from "effect/Schema";
+import { Annotation, DXN, Database, Feed, Filter, Format, Obj, Query, Ref, Registry, Scope, Tag, Type } from "@dxos/echo";
+import * as Effect from "effect/Effect";
+import { FormInlineAnnotation, FormInputAnnotation, LabelAnnotation } from "@dxos/echo/Annotation";
+import { EffectEx } from "@dxos/effect";
+import { FactoryAnnotation, FeedAnnotation, StateMap, TagIndex } from "@dxos/schema";
+import { Instructions, Operation, Skill } from "@dxos/compute";
+import { meta } from "#meta";
+import { AppAnnotation } from "@dxos/app-toolkit";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region src/types/Subscription.ts
+var Subscription_exports = /* @__PURE__ */ __exportAll({
+	DEFAULT_KEEP: () => 10,
+	FeedType: () => FeedType,
+	Post: () => Post,
+	PostContent: () => PostContent,
+	PostState: () => PostState$1,
+	SYSTEM_TAGS: () => SYSTEM_TAGS,
+	Subscription: () => Subscription,
+	appendPostContent: () => appendPostContent,
+	findPostContent: () => findPostContent,
+	findSystemTagUri: () => findSystemTagUri,
+	getPostSubscription: () => getPostSubscription,
+	getReadAt: () => getReadAt,
+	hasTag: () => hasTag,
+	instanceOf: () => instanceOf$1,
+	makePost: () => makePost,
+	makeSubscription: () => makeSubscription,
+	pickLatestPostContent: () => pickLatestPostContent,
+	queryPostContentForPost: () => queryPostContentForPost,
+	setReadAt: () => setReadAt,
+	setTag: () => setTag
+});
+/** Subscription protocol type. */
+var FeedType = Schema.Literal("standard-site", "rss", "bluesky");
+/**
+* System per-Post flags (starred/archived) modelled as space-wide {@link Tag} objects (resolved via
+* `Tag.findOrCreate` on first use). Each entry is a single source of truth carrying its foreign
+* `key` plus display `label`/`hue`.
+*/
+var SYSTEM_TAGS = {
+	starred: {
+		key: {
+			source: "org.dxos.plugin.magazine",
+			id: "starred"
+		},
+		label: "Starred",
+		hue: "amber"
+	},
+	archived: {
+		key: {
+			source: "org.dxos.plugin.magazine",
+			id: "archived"
+		},
+		label: "Archived",
+		hue: "neutral"
+	}
+};
+/** Per-Post mutable state stored on the Subscription (shared across magazines), keyed by Post id. */
+var PostState$1 = Schema.Struct({ 
+/** ISO 8601 timestamp when first opened. */
+readAt: Schema.optional(Schema.String) });
+/**
+* Subscription feed schema: an RSS/Atom/AT Protocol subscription.
+*/
+var Subscription = class extends Type.makeObject(DXN.make("org.dxos.type.subscription.feed", "0.1.0"))(Schema.Struct({
+	/** User-facing title of the feed. */
+	name: Schema.String.pipe(Schema.optional),
+	/** The URL of the RSS/Atom feed or AT Protocol handle/DID. */
+	url: Schema.String.pipe(Schema.optional),
+	/** Protocol type — determines which fetcher is used for sync. */
+	type: FeedType.pipe(Schema.optional),
+	/** Description of the feed. */
+	description: Schema.String.pipe(Schema.optional),
+	/** URL of the feed's associated website. */
+	link: Schema.String.pipe(Schema.optional),
+	/** URL of the feed's icon/image. */
+	iconUrl: Schema.String.pipe(Schema.optional),
+	/**
+	* Maximum number of (non-starred) Posts retained in the feed's queue when syncing.
+	* Older posts beyond this bound are dropped; starred posts are preserved regardless.
+	* Defaults to {@link DEFAULT_KEEP} when unset.
+	*/
+	keep: Schema.Number.pipe(Schema.annotations({
+		title: "Keep",
+		description: "Number of synced items."
+	}), Schema.optional),
+	/** Opaque sync cursor — protocol-specific. */
+	cursor: Schema.String.pipe(FormInputAnnotation.set(false), Schema.optional),
+	/** Backing ECHO feed (queue) for Posts: immutable feed entries appended by sync. */
+	feed: Ref.Ref(Feed.Feed).pipe(FormInputAnnotation.set(false)),
+	/**
+	* Backing ECHO feed (queue) for fetched article bodies — one
+	* {@link PostContent} entry per Post whose content has been loaded.
+	*
+	* Feeds (not the {@link postState} side map) are the right home for big
+	* immutable payloads: they're append-only, lazily replicated, and don't
+	* inflate the Subscription document. The side map keeps only the small
+	* per-Post user state (read/archived/star/imageUrl).
+	*
+	* Optional for backwards compatibility with older Subscription documents
+	* that pre-date this feed; new subscriptions always have one via
+	* {@link makeSubscription}.
+	*/
+	contentFeed: Ref.Ref(Feed.Feed).pipe(FormInputAnnotation.set(false), Schema.optional),
+	/**
+	* Per-Post mutable state keyed by Post id, shared across every Magazine that references the Post.
+	* Posts live immutably in the `feed` queue; their `readAt` marker lives here. (`snippet`/`imageUrl`
+	* are derived from the Post, or refined onto `contentFeed` entries — not stored here; star/archive
+	* are tags — see `tags`.)
+	*/
+	postState: Ref.Ref(StateMap.StateMap).pipe(FormInputAnnotation.set(false)),
+	/**
+	* Per-Post tags keyed by tag uri → Post ids. Boolean flags (starred, archived — see
+	* {@link SYSTEM_TAGS}) are modelled as {@link Tag} objects so they
+	* participate in the space-wide tag system. Stored as a child {@link TagIndex} object.
+	*/
+	tags: Ref.Ref(TagIndex.TagIndex).pipe(FormInputAnnotation.set(false))
+}).pipe(LabelAnnotation.set(["name", "url"]), Annotation.IconAnnotation.set({
+	icon: "ph--rss--regular",
+	hue: "indigo"
+}), FeedAnnotation.set(true), FactoryAnnotation.set(((values) => makeSubscription(values))))) {};
+/** Checks if a value is a Subscription.Subscription object. */
+var instanceOf$1 = (value) => Obj.instanceOf(Subscription, value);
+/** Creates a Subscription.Subscription with backing ECHO feeds for posts and fetched content. */
+var makeSubscription = (props = {}) => {
+	const postFeed = Feed.make();
+	const contentFeed = Feed.make();
+	const postState = StateMap.make();
+	const tags = TagIndex.make();
+	const subscription = Obj.make(Subscription, {
+		feed: Ref.make(postFeed),
+		contentFeed: Ref.make(contentFeed),
+		postState: Ref.make(postState),
+		tags: Ref.make(tags),
+		...props
+	});
+	Obj.setParent(postFeed, subscription);
+	Obj.setParent(contentFeed, subscription);
+	Obj.setParent(postState, subscription);
+	Obj.setParent(tags, subscription);
+	return subscription;
+};
+/**
+* A single post/entry within a subscription feed.
+*
+* Immutable feed-entry: every field below is set at sync time by the protocol
+* fetcher and never written to again. Mutable state (read, archived, starred,
+* fetched content, hero image) lives on
+* {@link Subscription.Subscription.postState} keyed by Post id; curation
+* outputs (snippet, rank) live on `Magazine.postState`.
+*/
+var Post = class extends Type.makeObject(DXN.make("org.dxos.type.subscription.post", "0.1.0"))(Schema.Struct({
+	/** Source subscription feed; populated by `SyncSubscription` so curated posts can show provenance. */
+	source: Ref.Ref(Subscription).pipe(FormInputAnnotation.set(false), Schema.optional),
+	/** Post title. */
+	title: Schema.String.pipe(Schema.optional),
+	/** URL link to the original article. */
+	link: Schema.String.pipe(Schema.optional),
+	/** Plain-text or summary. */
+	description: Schema.String.pipe(Schema.optional),
+	/** Plain-text or HTML content. */
+	content: Schema.String.pipe(Schema.optional),
+	/** Author name. */
+	author: Schema.String.pipe(Schema.optional),
+	/** ISO 8601 publication date. */
+	published: Schema.String.pipe(Schema.optional),
+	/** Unique identifier (guid) from the feed. */
+	guid: Schema.String.pipe(Schema.optional)
+}).pipe(LabelAnnotation.set(["title"]), Annotation.IconAnnotation.set({
+	icon: "ph--article--regular",
+	hue: "indigo"
+}))) {};
+/** Creates a Subscription.Post object. */
+var makePost = (props = {}) => Obj.make(Post, props);
+/**
+* An entry in a Subscription's {@link Subscription.contentFeed} queue: the
+* fetched body of a Post, linked back to the queue Post in the parallel `feed`
+* queue via {@link post}.
+*
+* Lives in a queue (not on `Subscription.postState`) because fetched bodies
+* can be many KB; storing them inline would inflate the Subscription document
+* unboundedly and force every reader to download every body. The queue is
+* lazily replicated and append-only — a natural fit for immutable content.
+*/
+var PostContent = class extends Type.makeObject(DXN.make("org.dxos.type.subscription.postContent", "0.1.0"))(Schema.Struct({
+	/** Source Post (in the Subscription's `feed` queue). */
+	post: Ref.Ref(Post).pipe(FormInputAnnotation.set(false)),
+	/** Extracted article body, in Markdown. */
+	text: Schema.String,
+	/** Refined snippet derived from the full article (preferred over the description-derived one). */
+	snippet: Schema.optional(Schema.String),
+	/** Refined hero image derived from the full article (preferred over the description-derived one). */
+	imageUrl: Schema.optional(Schema.String),
+	/** ISO 8601 timestamp when the content was fetched. */
+	fetchedAt: Schema.String
+}).pipe(Annotation.HiddenAnnotation.set(true))) {};
+/** ISO timestamp the Post was first opened, or undefined. */
+var getReadAt = (subscription, postId) => {
+	const stateMap = subscription?.postState.target;
+	return stateMap ? StateMap.bind(stateMap).get(postId).readAt : void 0;
+};
+/** Sets/clears the Post's read marker. */
+var setReadAt = (subscription, postId, value) => {
+	const stateMap = subscription.postState.target;
+	if (stateMap) StateMap.bind(stateMap).patch(postId, { readAt: value });
+};
+/** Resolves the uri of an existing system Tag without creating one; `undefined` when absent. Async. */
+var findSystemTagUri = async (db, which) => {
+	const [currentTag] = await db.query(Filter.foreignKeys(Tag.Tag, [SYSTEM_TAGS[which].key])).run();
+	if (currentTag) return Obj.getURI(currentTag).toString();
+	const legacyKey = {
+		source: "org.dxos.plugin.feed",
+		id: SYSTEM_TAGS[which].key.id
+	};
+	const [legacyTag] = await db.query(Filter.foreignKeys(Tag.Tag, [legacyKey])).run();
+	return legacyTag ? Obj.getURI(legacyTag).toString() : void 0;
+};
+/** Whether a Post carries the given (resolved) tag uri on its Subscription. Pure. */
+var hasTag = (subscription, postId, tagUri) => {
+	const tagIndex = subscription?.tags.target;
+	return !!(tagIndex && tagUri) && TagIndex.bind(tagIndex).objects(tagUri).includes(postId);
+};
+/** Sets/clears a system tag (`starred`/`archived`) on a Post (find-or-creates the Tag object). Async. */
+var setTag = async (subscription, postId, db, which, value) => {
+	const tag = await Tag.findOrCreate(db, SYSTEM_TAGS[which]);
+	const uri = Obj.getURI(tag).toString();
+	const tagIndex = subscription.tags.target;
+	if (!tagIndex) return;
+	const tags = TagIndex.bind(tagIndex);
+	if (value) tags.setTag(uri, postId);
+	else tags.unsetTag(uri, postId);
+};
+/** Resolves a Post's source Subscription synchronously if its `source` ref is loaded, else undefined. */
+var getPostSubscription = (post) => post.source?.target;
+/**
+* Query for {@link PostContent} entries referencing a Post via the reverse-ref index.
+* Scoped to the Subscription's post and content feeds.
+*/
+var queryPostContentForPost = (subscription, post) => {
+	const postFeed = subscription.feed?.target;
+	const contentFeed = subscription.contentFeed?.target;
+	if (!postFeed || !contentFeed) return;
+	const postFeedUri = Obj.getURI(postFeed);
+	const contentFeedUri = Obj.getURI(contentFeed);
+	return Query.select(Filter.id(post.id)).referencedBy(PostContent, "post").from(Scope.feed(postFeedUri), Scope.feed(contentFeedUri));
+};
+/** Pick the newest PostContent when multiple entries reference the same Post. */
+var pickLatestPostContent = (entries) => {
+	if (entries.length === 0) return;
+	return [...entries].sort((entryA, entryB) => entryB.fetchedAt.localeCompare(entryA.fetchedAt))[0];
+};
+/** Looks up PostContent for a Post (newest wins); undefined if absent. */
+var findPostContent = async (subscription, post) => {
+	const db = Obj.getDatabase(subscription);
+	const query = queryPostContentForPost(subscription, post);
+	if (!db || !query) return;
+	return pickLatestPostContent(await db.query(query).run());
+};
+/** Returns the Subscription's `contentFeed`, lazily creating and attaching one when missing. */
+var ensureContentFeed = (subscription) => {
+	const existing = subscription.contentFeed?.target;
+	if (existing) return existing;
+	const created = Feed.make();
+	Obj.update(subscription, (subscription) => {
+		const mutable = subscription;
+		mutable.contentFeed = Ref.make(created);
+	});
+	Obj.setParent(created, subscription);
+	return created;
+};
+/**
+* Appends a {@link PostContent} entry (body + refined snippet/imageUrl) to a Subscription's
+* `contentFeed`, lazily creating the feed on first use.
+*/
+var appendPostContent = async (space, subscription, entry) => {
+	const echoFeed = ensureContentFeed(subscription);
+	const content = Obj.make(PostContent, {
+		post: Ref.fromURI(Obj.getURI(entry.post)),
+		text: entry.text,
+		...entry.snippet ? { snippet: entry.snippet } : {},
+		...entry.imageUrl ? { imageUrl: entry.imageUrl } : {},
+		fetchedAt: entry.fetchedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+	});
+	await Feed.append(echoFeed, [content]).pipe(Effect.provide(Database.layer(space.db)), EffectEx.runAndForwardErrors);
+};
+//#endregion
+//#region src/types/CreateSubscription.ts
+var CreateSubscription_exports = /* @__PURE__ */ __exportAll({
+	HandleSchema: () => HandleSchema,
+	RssCreateBase: () => RssCreateBase,
+	StandardSiteCreateBase: () => StandardSiteCreateBase,
+	isHandle: () => isHandle,
+	isUrl: () => isUrl,
+	makeSubscriptionFromCreate: () => makeSubscriptionFromCreate
+});
+var HandleSchema = Schema.String.pipe(Schema.pattern(/^@?([\da-z-]+\.)+[a-z]{2,}$|^did:[a-z]+:[a-zA-Z0-9._%:-]+$/i));
+var isHandle = Schema.is(HandleSchema);
+var isUrl = Schema.is(Format.URL);
+var StandardSiteCreateBase = Schema.Struct({
+	type: Schema.Literal("standard-site"),
+	handle: HandleSchema.annotations({
+		title: "Handle",
+		description: "atproto handle, e.g. dxos.org."
+	}),
+	publication: Schema.String.annotations({
+		title: "Publication",
+		description: "Choose a publication."
+	})
+});
+var RssCreateBase = Schema.Struct({
+	type: Schema.Literal("rss"),
+	url: Format.URL.annotations({
+		title: "URL",
+		description: "RSS feed URL."
+	}),
+	name: Schema.optional(Schema.String.annotations({ title: "Name" }))
+});
+/** Normalizes a create-form union member into the stored {@link Subscription.Subscription} fields. */
+var makeSubscriptionFromCreate = (input) => {
+	switch (input.type) {
+		case "standard-site": return makeSubscription({
+			type: "standard-site",
+			url: input.publication
+		});
+		case "rss": return makeSubscription({
+			type: "rss",
+			url: input.url,
+			name: input.name
+		});
+	}
+};
+//#endregion
+//#region src/types/Magazine.ts
+var Magazine_exports = /* @__PURE__ */ __exportAll({
+	CreateMagazineSchema: () => CreateMagazineSchema,
+	CurationOutput: () => CurationOutput,
+	DEFAULT_INSTRUCTIONS: () => DEFAULT_INSTRUCTIONS,
+	Magazine: () => Magazine,
+	PostState: () => PostState,
+	SKILL_KEY: () => SKILL_KEY,
+	composeInstructions: () => composeInstructions,
+	getPostState: () => getPostState,
+	getRank: () => getRank,
+	instanceOf: () => instanceOf,
+	make: () => make,
+	patchPostState: () => patchPostState,
+	setRank: () => setRank
+});
+var SKILL_KEY = "org.dxos.skill.magazine";
+/**
+* Default editorial methodology seeded into a Magazine's curation Routine. Describes WHAT to curate
+* (selection, dedup, snippet, hero image). The HOW (candidate input shape, tool usage, output
+* contract) lives in the Magazine skill, not here.
+*/
+var DEFAULT_INSTRUCTIONS = trim`
+  You curate articles for a Magazine around the Topic described below.
+
+  Select only candidates that clearly match the Topic — quality over quantity.
+
+  Never select duplicate articles. Two candidates are duplicates if they share a link or guid, or if
+  their titles and content describe the same story (e.g. the same article syndicated by different
+  feeds). Keep only one of each — prefer the most complete or authoritative source — and skip the rest.
+
+  For each candidate you select, also produce:
+  - A concise 1-2 sentence snippet (plain text, no markdown) capturing why the article is relevant to
+    the Topic. If you read the full article, use it to write a richer snippet.
+  - The best hero image URL for the article, when one is available.
+`;
+/** Per-Post magazine-scoped curation state, keyed by Post id. */
+var PostState = Schema.Struct({
+	/** Agent-assigned relevance within this magazine (lower = more relevant). */
+	rank: Schema.optional(Schema.Number),
+	/** Agent-written concise snippet summarising the article in the context of this magazine's topic. */
+	snippet: Schema.optional(Schema.String),
+	/** Agent-selected hero image URL for this post in this magazine. */
+	imageUrl: Schema.optional(Schema.String)
+});
+/**
+* Structured output contract of the curation Routine: the Posts the agent selected, each with
+* agent-generated display values. Declared as the Routine's `output` ({@link make}) so the agent's
+* `completeJob` carries this payload (a Void/Unknown default would silently drop it); {@link
+* CurateMagazine} decodes the Routine result against the same schema.
+*/
+var CurationOutput = Schema.Struct({ posts: Schema.Array(Schema.Struct({
+	id: Obj.ID,
+	/** Concise 1-2 sentence snippet summarising why this article is relevant to the magazine topic. */
+	snippet: Schema.optional(Schema.String),
+	/** Best image URL found for this article (from the post or fetched content). */
+	imageUrl: Schema.optional(Schema.String)
+})) });
+/**
+* An agent-curated collection of articles drawn from one or more Feeds.
+* Curation is driven by a {@link Routine.Routine} created with the magazine ({@link make}): its
+* instructions hold the editorial brief and it references the Magazine skill (the tool/output
+* contract). {@link CurateMagazine} runs the Routine to select matching Posts.
+*/
+var Magazine = class extends Type.makeObject(DXN.make("org.dxos.type.magazine", "0.2.0"))(Schema.Struct({
+	/** User-facing title of the magazine. */
+	name: Schema.String.pipe(Schema.optional),
+	/** Feeds to pull content from. */
+	feeds: Schema.Array(Ref.Ref(Subscription)),
+	/** Curated Post refs (insertion order; UI displays newest-last reversed). */
+	posts: Schema.Array(Ref.Ref(Post)).pipe(FormInputAnnotation.set(false)),
+	/**
+	* Curation Instructions, created with the magazine ({@link make}). Holds the editorial brief and
+	* references the Magazine skill. Rendered inline by the properties form (the Instructions'
+	* own fields), so the brief is edited there without a custom surface.
+	* Optional for backward compatibility; {@link CurateMagazine} and the toolbar require it.
+	*/
+	instructions: Ref.Ref(Instructions.Instructions).pipe(FormInlineAnnotation.set(true), Schema.optional),
+	/**
+	* Per-Post magazine-scoped curation state, keyed by Post id. Shared per-Post state (readAt,
+	* star/archive tags) lives on `Subscription`; snippet/imageUrl here are agent-written at
+	* curation time and take precedence over the RSS-derived defaults in display.
+	*/
+	postState: Ref.Ref(StateMap.StateMap).pipe(FormInputAnnotation.set(false)),
+	/**
+	* Maximum number of (non-starred) curated Posts retained on the magazine after curation.
+	* Older posts beyond this bound are dropped; starred posts are preserved regardless.
+	* Defaults to {@link Subscription.DEFAULT_KEEP} when unset.
+	*/
+	keep: Schema.Number.pipe(Schema.annotations({
+		title: "Keep",
+		description: "Number of items to keep."
+	}), Schema.optional)
+}).pipe(LabelAnnotation.set(["name"]), Annotation.IconAnnotation.set({
+	icon: "ph--book-open-text--regular",
+	hue: "indigo"
+}), AppAnnotation.SkillsAnnotation.set([SKILL_KEY]))) {};
+/** Checks if a value is a Magazine object. */
+var instanceOf = (value) => Obj.instanceOf(Magazine, value);
+/**
+* Creates a Magazine plus its curation Routine and per-Post state map as hidden children (all
+* cascade-deleted with the magazine). The Routine holds the editorial brief (its instructions,
+* seeded from {@link composeInstructions}) and references the Magazine skill by its registry DXN;
+* {@link CurateMagazine} runs it and the agent resolves the skill at run time.
+*/
+var make = (props = {}) => {
+	const postState = StateMap.make();
+	const magazine = Obj.make(Magazine, {
+		name: props.name,
+		feeds: props.feeds ?? [],
+		posts: props.posts ?? [],
+		keep: props.keep,
+		postState: Ref.make(postState)
+	});
+	const instructions = Instructions.make({
+		name: props.name ? `${props.name} curation` : "Magazine curation",
+		text: composeInstructions(props.instructions),
+		skills: [Ref.fromURI(Skill.registryURI(SKILL_KEY))],
+		objects: [Ref.make(magazine)],
+		output: CurationOutput
+	});
+	Obj.update(magazine, (magazine) => {
+		magazine.instructions = Ref.make(instructions);
+	});
+	Obj.setParent(instructions, magazine);
+	if (instructions.text.target) Obj.setParent(instructions.text.target, instructions);
+	Obj.setParent(postState, magazine);
+	return magazine;
+};
+/** Composes Routine instructions from the default editorial methodology and an optional topic focus. */
+var composeInstructions = (topic) => {
+	const trimmed = topic?.trim();
+	return trimmed ? `${DEFAULT_INSTRUCTIONS}\n\n## Topic\n\n${trimmed}` : DEFAULT_INSTRUCTIONS;
+};
+/** Schema for the create-magazine dialog form. */
+var CreateMagazineSchema = Schema.Struct({
+	name: Schema.optional(Schema.String.annotations({ title: "Name" })),
+	feeds: Schema.Array(Ref.Ref(Subscription)).annotations({ title: "Feeds" }),
+	instructions: Schema.optional(Schema.String.annotations({
+		title: "Topic",
+		description: "Describe what content to curate."
+	}))
+});
+/** Agent-assigned relevance of a Post within a Magazine, or undefined. */
+var getRank = (magazine, postId) => {
+	const stateMap = magazine?.postState.target;
+	return stateMap ? StateMap.bind(stateMap).get(postId).rank : void 0;
+};
+/** Returns the full magazine-scoped {@link PostState} for a Post, or an empty record. */
+var getPostState = (magazine, postId) => {
+	const stateMap = magazine?.postState.target;
+	return stateMap ? StateMap.bind(stateMap).get(postId) : {};
+};
+/** Merges partial state into a Post's magazine-scoped {@link PostState}. */
+var patchPostState = (magazine, postId, state) => {
+	const stateMap = magazine.postState.target;
+	if (stateMap) StateMap.bind(stateMap).patch(postId, state);
+};
+/** Sets the magazine-scoped rank for a Post. */
+var setRank = (magazine, postId, rank) => patchPostState(magazine, postId, { rank });
+//#endregion
+//#region src/types/FeedOperation.ts
+var FeedOperation_exports = /* @__PURE__ */ __exportAll({
+	ClearMagazine: () => ClearMagazine,
+	CurateMagazine: () => CurateMagazine,
+	FetchArticleContent: () => FetchArticleContent,
+	LoadPostContent: () => LoadPostContent,
+	SyncFeed: () => SyncFeed
+});
+var makeKey = (name) => DXN.make(`${meta.profile.key}.operation.${name}`);
+/** Fetches an RSS/Atom feed and appends new posts to the backing ECHO feed. */
+var SyncFeed = Operation.make({
+	meta: {
+		key: makeKey("syncFeed"),
+		name: "Sync Feed",
+		description: "Fetches RSS/Atom feed and writes posts to the ECHO feed.",
+		icon: "ph--arrows-clockwise--regular"
+	},
+	services: [Database.Service],
+	input: Schema.Struct({ feed: Ref.Ref(Subscription) }),
+	output: Schema.Void
+}).pipe(Operation.visible);
+/**
+* Fetches a Post's article page over HTTP and returns extracted plain text plus
+* any image URLs found. Read-only; does not mutate the Post. Agent-facing tool
+* (the surviving curation tool: the agent may call it to read a candidate's full
+* text when title + description are insufficient to judge relevance).
+*/
+var FetchArticleContent = Operation.make({
+	meta: {
+		key: makeKey("fetchArticleContent"),
+		name: "Fetch Article Content",
+		description: "Fetches and extracts text + image URLs from a Post's article page.",
+		icon: "ph--article--regular"
+	},
+	input: Schema.Struct({ post: Ref.Ref(Post).annotations({ description: "The Post to fetch content for. The Post must have a link." }) }),
+	output: Schema.Struct({
+		text: Schema.String.annotations({ description: "Extracted plain text from the article page." }),
+		imageUrls: Schema.Array(Schema.String).annotations({ description: "Image URLs found on the page (og:image first, then <img> src values)." })
+	}),
+	services: [Database.Service]
+});
+/**
+* Fetches a Post's article page over HTTP and writes the extracted plain text
+* and hero image URL to the source Subscription's content feed. Per-Post read/star/archive
+* state on the Subscription is keyed by Post entity id.
+* (the Post itself is an immutable queue item). Idempotent — skips if
+* `content` is already set or the Post has no link. Used by the reader view
+* to populate the full article on first open.
+*/
+var LoadPostContent = Operation.make({
+	meta: {
+		key: makeKey("loadPostContent"),
+		name: "Load Post Content",
+		description: "Fetches and stores the full article content on a Post.",
+		icon: "ph--download--regular"
+	},
+	input: Schema.Struct({
+		post: Ref.Ref(Post).annotations({ description: "The Post to load content for." }),
+		force: Schema.optional(Schema.Boolean.annotations({ description: "Re-fetch and append fresh content even if an entry already exists (refresh)." }))
+	}),
+	output: Schema.Void
+});
+/**
+* End-to-end magazine curation: syncs all referenced feeds (in parallel), then runs an in-memory
+* routine (the magazine's topic instructions + the registry-resolved Magazine skill) through the
+* agent to select matching posts, adds the selected posts mechanically, and finally enforces each
+* feed's `keep` bound. Drives the MagazineArticle Curate button; schedulable via triggers.
+*/
+var CurateMagazine = Operation.make({
+	meta: {
+		key: makeKey("curateMagazine"),
+		name: "Curate Magazine",
+		description: "Syncs feeds, selects matching posts via the magazine skill, and applies per-feed keep limits.",
+		icon: "ph--sparkle--regular"
+	},
+	input: Schema.Struct({ magazine: Ref.Ref(Magazine).annotations({ description: "The Magazine to curate." }) }),
+	output: Schema.Struct({
+		synced: Schema.Number.annotations({ description: "Number of feeds successfully synced." }),
+		curated: Schema.Number.annotations({ description: "Number of posts added to the magazine." })
+	}),
+	services: [Database.Service, Registry.Service]
+}).pipe(Operation.visible);
+/**
+* Clears a Magazine's curated posts, preserving any that are starred. Drives the MagazineArticle
+* Clear button.
+*/
+var ClearMagazine = Operation.make({
+	meta: {
+		key: makeKey("clearMagazine"),
+		name: "Clear Magazine",
+		description: "Removes a Magazine's posts, keeping any that are starred.",
+		icon: "ph--trash--regular"
+	},
+	input: Schema.Struct({ magazine: Ref.Ref(Magazine).annotations({ description: "The Magazine to clear." }) }),
+	output: Schema.Void,
+	services: [Database.Service]
+}).pipe(Operation.visible);
+//#endregion
+export { hasTag as _, LoadPostContent as a, __exportAll as b, Magazine_exports as c, Post as d, SYSTEM_TAGS as f, findSystemTagUri as g, findPostContent as h, FetchArticleContent as i, patchPostState as l, appendPostContent as m, CurateMagazine as n, SyncFeed as o, Subscription_exports as p, FeedOperation_exports as r, CurationOutput as s, ClearMagazine as t, CreateSubscription_exports as u, pickLatestPostContent as v, queryPostContentForPost as y };
+
+//# sourceMappingURL=chunk-types.mjs.map