@dxos/plugin-magazine 0.10.0 → 0.11.0

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

@@ -1,624 +0,0 @@
-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