@dxos/plugin-magazine 0.0.0

package/dist/lib/neutral/chunk-OYCDRSWB.mjs

@@ -0,0 +1,624 @@
+import {
+  __export
+} from "./chunk-J5LGTIGS.mjs";
+
+// src/types/CreateSubscription.ts
+var CreateSubscription_exports = {};
+__export(CreateSubscription_exports, {
+  HandleSchema: () => HandleSchema,
+  RssCreateBase: () => RssCreateBase,
+  StandardSiteCreateBase: () => StandardSiteCreateBase,
+  isHandle: () => isHandle,
+  isUrl: () => isUrl,
+  makeSubscriptionFromCreate: () => makeSubscriptionFromCreate
+});
+import * as Schema2 from "effect/Schema";
+import { Format } from "@dxos/echo";
+
+// src/types/Subscription.ts
+var Subscription_exports = {};
+__export(Subscription_exports, {
+  DEFAULT_KEEP: () => DEFAULT_KEEP,
+  FeedType: () => FeedType,
+  Post: () => Post,
+  PostContent: () => PostContent,
+  PostState: () => PostState,
+  SYSTEM_TAGS: () => SYSTEM_TAGS,
+  Subscription: () => Subscription,
+  appendPostContent: () => appendPostContent,
+  findPostContent: () => findPostContent,
+  findSystemTagUri: () => findSystemTagUri,
+  getPostSubscription: () => getPostSubscription,
+  getReadAt: () => getReadAt,
+  hasTag: () => hasTag,
+  instanceOf: () => instanceOf,
+  makePost: () => makePost,
+  makeSubscription: () => makeSubscription,
+  pickLatestPostContent: () => pickLatestPostContent,
+  queryPostContentForPost: () => queryPostContentForPost,
+  setReadAt: () => setReadAt,
+  setTag: () => setTag
+});
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import { Annotation, Database, DXN, Feed, Filter, Obj, Query, Ref, Scope, Tag, Type } from "@dxos/echo";
+import { FormInputAnnotation, LabelAnnotation } from "@dxos/echo/Annotation";
+import { EffectEx } from "@dxos/effect";
+import { FactoryAnnotation, FeedAnnotation, StateMap, TagIndex } from "@dxos/schema";
+var FeedType = Schema.Literal("standard-site", "rss", "bluesky");
+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"
+  }
+};
+var PostState = Schema.Struct({
+  /** ISO 8601 timestamp when first opened. */
+  readAt: Schema.optional(Schema.String)
+});
+var DEFAULT_KEEP = 10;
+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)))) {
+};
+var instanceOf = (value) => Obj.instanceOf(Subscription, value);
+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;
+};
+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: "orange"
+}))) {
+};
+var makePost = (props = {}) => Obj.make(Post, props);
+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))) {
+};
+var getReadAt = (subscription, postId) => {
+  const stateMap = subscription?.postState.target;
+  return stateMap ? StateMap.bind(stateMap).get(postId).readAt : void 0;
+};
+var setReadAt = (subscription, postId, value) => {
+  const stateMap = subscription.postState.target;
+  if (stateMap) {
+    StateMap.bind(stateMap).patch(postId, {
+      readAt: value
+    });
+  }
+};
+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;
+};
+var hasTag = (subscription, postId, tagUri) => {
+  const tagIndex = subscription?.tags.target;
+  return !!(tagIndex && tagUri) && TagIndex.bind(tagIndex).objects(tagUri).includes(postId);
+};
+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);
+  }
+};
+var getPostSubscription = (post) => post.source?.target;
+var queryPostContentForPost = (subscription, post) => {
+  const postFeed = subscription.feed?.target;
+  const contentFeed = subscription.contentFeed?.target;
+  if (!postFeed || !contentFeed) {
+    return void 0;
+  }
+  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));
+};
+var pickLatestPostContent = (entries) => {
+  if (entries.length === 0) {
+    return void 0;
+  }
+  return [
+    ...entries
+  ].sort((entryA, entryB) => entryB.fetchedAt.localeCompare(entryA.fetchedAt))[0];
+};
+var findPostContent = async (subscription, post) => {
+  const db = Obj.getDatabase(subscription);
+  const query = queryPostContentForPost(subscription, post);
+  if (!db || !query) {
+    return void 0;
+  }
+  return pickLatestPostContent(await db.query(query).run());
+};
+var ensureContentFeed = (subscription) => {
+  const existing = subscription.contentFeed?.target;
+  if (existing) {
+    return existing;
+  }
+  const created = Feed.make();
+  Obj.update(subscription, (subscription2) => {
+    const mutable = subscription2;
+    mutable.contentFeed = Ref.make(created);
+  });
+  Obj.setParent(created, subscription);
+  return created;
+};
+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);
+};
+
+// src/types/CreateSubscription.ts
+var HandleSchema = Schema2.String.pipe(Schema2.pattern(/^@?([\da-z-]+\.)+[a-z]{2,}$|^did:[a-z]+:[a-zA-Z0-9._%:-]+$/i));
+var isHandle = Schema2.is(HandleSchema);
+var isUrl = Schema2.is(Format.URL);
+var StandardSiteCreateBase = Schema2.Struct({
+  type: Schema2.Literal("standard-site"),
+  handle: HandleSchema.annotations({
+    title: "Handle",
+    description: "atproto handle, e.g. dxos.org."
+  }),
+  // No `name`: the feed name is taken from the selected publication (resolved by `fetchStandardSite`).
+  publication: Schema2.String.annotations({
+    title: "Publication",
+    description: "Choose a publication."
+  })
+});
+var RssCreateBase = Schema2.Struct({
+  type: Schema2.Literal("rss"),
+  url: Format.URL.annotations({
+    title: "URL",
+    description: "RSS feed URL."
+  }),
+  name: Schema2.optional(Schema2.String.annotations({
+    title: "Name"
+  }))
+});
+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
+      });
+  }
+};
+
+// src/types/FeedOperation.ts
+var FeedOperation_exports = {};
+__export(FeedOperation_exports, {
+  ClearMagazine: () => ClearMagazine,
+  CurateMagazine: () => CurateMagazine,
+  FetchArticleContent: () => FetchArticleContent,
+  LoadPostContent: () => LoadPostContent,
+  SyncFeed: () => SyncFeed
+});
+import * as Schema4 from "effect/Schema";
+import { Operation } from "@dxos/compute";
+import { Database as Database2, DXN as DXN3, Ref as Ref3, Registry } from "@dxos/echo";
+import { meta } from "#meta";
+
+// src/types/Magazine.ts
+var Magazine_exports = {};
+__export(Magazine_exports, {
+  CreateMagazineSchema: () => CreateMagazineSchema,
+  CurationOutput: () => CurationOutput,
+  DEFAULT_INSTRUCTIONS: () => DEFAULT_INSTRUCTIONS,
+  Magazine: () => Magazine,
+  PostState: () => PostState2,
+  SKILL_KEY: () => SKILL_KEY,
+  composeInstructions: () => composeInstructions,
+  getPostState: () => getPostState,
+  getRank: () => getRank,
+  instanceOf: () => instanceOf2,
+  make: () => make,
+  patchPostState: () => patchPostState,
+  setRank: () => setRank
+});
+import * as Schema3 from "effect/Schema";
+import { AppAnnotation } from "@dxos/app-toolkit";
+import { Instructions, Skill } from "@dxos/compute";
+import { Annotation as Annotation2, DXN as DXN2, Obj as Obj2, Ref as Ref2, Type as Type2 } from "@dxos/echo";
+import { FormInlineAnnotation, FormInputAnnotation as FormInputAnnotation2, LabelAnnotation as LabelAnnotation2 } from "@dxos/echo/Annotation";
+import { StateMap as StateMap2 } from "@dxos/schema";
+import { trim } from "@dxos/util";
+var SKILL_KEY = "org.dxos.skill.magazine";
+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.
+`;
+var PostState2 = Schema3.Struct({
+  /** Agent-assigned relevance within this magazine (lower = more relevant). */
+  rank: Schema3.optional(Schema3.Number),
+  /** Agent-written concise snippet summarising the article in the context of this magazine's topic. */
+  snippet: Schema3.optional(Schema3.String),
+  /** Agent-selected hero image URL for this post in this magazine. */
+  imageUrl: Schema3.optional(Schema3.String)
+});
+var CurationOutput = Schema3.Struct({
+  posts: Schema3.Array(Schema3.Struct({
+    id: Obj2.ID,
+    /** Concise 1-2 sentence snippet summarising why this article is relevant to the magazine topic. */
+    snippet: Schema3.optional(Schema3.String),
+    /** Best image URL found for this article (from the post or fetched content). */
+    imageUrl: Schema3.optional(Schema3.String)
+  }))
+});
+var Magazine = class extends Type2.makeObject(DXN2.make("org.dxos.type.magazine", "0.2.0"))(Schema3.Struct({
+  /** User-facing title of the magazine. */
+  name: Schema3.String.pipe(Schema3.optional),
+  /** Feeds to pull content from. */
+  feeds: Schema3.Array(Ref2.Ref(Subscription)),
+  /** Curated Post refs (insertion order; UI displays newest-last reversed). */
+  posts: Schema3.Array(Ref2.Ref(Post)).pipe(FormInputAnnotation2.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: Ref2.Ref(Instructions.Instructions).pipe(FormInlineAnnotation.set(true), Schema3.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: Ref2.Ref(StateMap2.StateMap).pipe(FormInputAnnotation2.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: Schema3.Number.pipe(Schema3.annotations({
+    title: "Keep",
+    description: "Number of items to keep."
+  }), Schema3.optional)
+}).pipe(LabelAnnotation2.set([
+  "name"
+]), Annotation2.IconAnnotation.set({
+  icon: "ph--book-open-text--regular",
+  hue: "indigo"
+}), AppAnnotation.SkillsAnnotation.set([
+  SKILL_KEY
+]))) {
+};
+var instanceOf2 = (value) => Obj2.instanceOf(Magazine, value);
+var make = (props = {}) => {
+  const postState = StateMap2.make();
+  const magazine = Obj2.make(Magazine, {
+    name: props.name,
+    feeds: props.feeds ?? [],
+    posts: props.posts ?? [],
+    keep: props.keep,
+    postState: Ref2.make(postState)
+  });
+  const instructions = Instructions.make({
+    name: props.name ? `${props.name} curation` : "Magazine curation",
+    text: composeInstructions(props.instructions),
+    skills: [
+      Ref2.fromURI(Skill.registryURI(SKILL_KEY))
+    ],
+    // Bind the magazine as session context so the agent sees it, not only the candidate JSON input.
+    objects: [
+      Ref2.make(magazine)
+    ],
+    // Declare the selection contract so the agent's completeJob carries the chosen Posts.
+    output: CurationOutput
+  });
+  Obj2.update(magazine, (magazine2) => {
+    magazine2.instructions = Ref2.make(instructions);
+  });
+  Obj2.setParent(instructions, magazine);
+  if (instructions.text.target) {
+    Obj2.setParent(instructions.text.target, instructions);
+  }
+  Obj2.setParent(postState, magazine);
+  return magazine;
+};
+var composeInstructions = (topic) => {
+  const trimmed = topic?.trim();
+  return trimmed ? `${DEFAULT_INSTRUCTIONS}
+
+## Topic
+
+${trimmed}` : DEFAULT_INSTRUCTIONS;
+};
+var CreateMagazineSchema = Schema3.Struct({
+  name: Schema3.optional(Schema3.String.annotations({
+    title: "Name"
+  })),
+  feeds: Schema3.Array(Ref2.Ref(Subscription)).annotations({
+    title: "Feeds"
+  }),
+  instructions: Schema3.optional(Schema3.String.annotations({
+    title: "Topic",
+    description: "Describe what content to curate."
+  }))
+});
+var getRank = (magazine, postId) => {
+  const stateMap = magazine?.postState.target;
+  return stateMap ? StateMap2.bind(stateMap).get(postId).rank : void 0;
+};
+var getPostState = (magazine, postId) => {
+  const stateMap = magazine?.postState.target;
+  return stateMap ? StateMap2.bind(stateMap).get(postId) : {};
+};
+var patchPostState = (magazine, postId, state) => {
+  const stateMap = magazine.postState.target;
+  if (stateMap) {
+    StateMap2.bind(stateMap).patch(postId, state);
+  }
+};
+var setRank = (magazine, postId, rank) => patchPostState(magazine, postId, {
+  rank
+});
+
+// src/types/FeedOperation.ts
+var makeKey = (name) => DXN3.make(`${meta.profile.key}.operation.${name}`);
+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: [
+    Database2.Service
+  ],
+  input: Schema4.Struct({
+    feed: Ref3.Ref(Subscription)
+  }),
+  output: Schema4.Void
+}).pipe(Operation.visible);
+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: Schema4.Struct({
+    post: Ref3.Ref(Post).annotations({
+      description: "The Post to fetch content for. The Post must have a link."
+    })
+  }),
+  output: Schema4.Struct({
+    text: Schema4.String.annotations({
+      description: "Extracted plain text from the article page."
+    }),
+    imageUrls: Schema4.Array(Schema4.String).annotations({
+      description: "Image URLs found on the page (og:image first, then <img> src values)."
+    })
+  }),
+  services: [
+    Database2.Service
+  ]
+});
+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: Schema4.Struct({
+    post: Ref3.Ref(Post).annotations({
+      description: "The Post to load content for."
+    }),
+    force: Schema4.optional(Schema4.Boolean.annotations({
+      description: "Re-fetch and append fresh content even if an entry already exists (refresh)."
+    }))
+  }),
+  output: Schema4.Void
+});
+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: Schema4.Struct({
+    magazine: Ref3.Ref(Magazine).annotations({
+      description: "The Magazine to curate."
+    })
+  }),
+  output: Schema4.Struct({
+    synced: Schema4.Number.annotations({
+      description: "Number of feeds successfully synced."
+    }),
+    curated: Schema4.Number.annotations({
+      description: "Number of posts added to the magazine."
+    })
+  }),
+  // Database.Service for candidate collection, Registry.Service to resolve the methodology skill;
+  // sub-operations (SyncFeed, RunInstructions) resolve through the ambient Operation.Service invoker.
+  services: [
+    Database2.Service,
+    Registry.Service
+  ]
+}).pipe(Operation.visible);
+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: Schema4.Struct({
+    magazine: Ref3.Ref(Magazine).annotations({
+      description: "The Magazine to clear."
+    })
+  }),
+  output: Schema4.Void,
+  services: [
+    Database2.Service
+  ]
+}).pipe(Operation.visible);
+
+export {
+  Subscription_exports,
+  CreateSubscription_exports,
+  Magazine_exports,
+  FeedOperation_exports
+};
+//# sourceMappingURL=chunk-OYCDRSWB.mjs.map