@dxos/plugin-magazine 0.0.0

package/dist/types/src/testing/builder.d.ts

@@ -0,0 +1,28 @@
+import { Magazine, Subscription } from '#types';
+/** Generates an array of random posts. */
+export declare const generatePosts: (count: number) => Subscription.Post[];
+/** Generates a random subscription feed. */
+export declare const generateFeed: (props?: Partial<{
+    name: string;
+    url: string;
+    description: string;
+}>) => Subscription.Subscription;
+/**
+ * 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 declare const generateCuratedPost: (_props?: {
+    imageUrl?: string;
+    read?: boolean;
+}) => Subscription.Post;
+/** Generates a Magazine with the given curated posts. Feeds default to empty. */
+export declare const generateMagazine: (props?: Partial<{
+    name: string;
+    feeds: Subscription.Subscription[];
+    posts: Subscription.Post[];
+}>) => Magazine.Magazine;
+//# sourceMappingURL=builder.d.ts.map

package/dist/types/src/testing/builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builder.d.ts","sourceRoot":"","sources":["../../../../src/testing/builder.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAEhD,0CAA0C;AAC1C,eAAO,MAAM,aAAa,UAAW,MAAM,KAAG,YAAY,CAAC,IAAI,EAgB9D,CAAC;AAEF,4CAA4C;AAC5C,eAAO,MAAM,YAAY,WAChB,OAAO,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,CAAC,KACjE,YAAY,CAAC,YAKZ,CAAC;AAEL;;;;;;;GAOG;AACH,eAAO,MAAM,mBAAmB,YAAY;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,OAAO,CAAA;CAAE,KAAQ,YAAY,CAAC,IAarG,CAAC;AAEF,iFAAiF;AACjF,eAAO,MAAM,gBAAgB,WACpB,OAAO,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,YAAY,CAAC,YAAY,EAAE,CAAC;IACnC,KAAK,EAAE,YAAY,CAAC,IAAI,EAAE,CAAC;CAC5B,CAAC,KACD,QAAQ,CAAC,QAMX,CAAC"}

package/dist/types/src/testing/index.d.ts

@@ -0,0 +1,2 @@
+export * from './builder';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/src/testing/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/testing/index.ts"],"names":[],"mappings":"AAIA,cAAc,WAAW,CAAC"}

package/dist/types/src/translations.d.ts

@@ -0,0 +1,247 @@
+export declare const translations: [{
+    readonly 'en-US': {
+        readonly "@dxos/react-ui-form": {
+            readonly 'ref-editor.placeholder': "Type '@' to add a reference, or enter a value";
+            readonly 'ref-editor-auto.placeholder': 'Search by name, or enter a value';
+            readonly 'fields.label': 'Fields';
+            readonly 'hidden-fields.label': 'Hidden Fields';
+            readonly 'empty-readonly-ref-field.label': '(none)';
+            readonly 'field-property.label': 'Property';
+            readonly 'field-property.placeholder': 'Property name';
+            readonly 'field-format.label': 'Type';
+            readonly 'field-path.label': 'Field path';
+            readonly 'remove-item.button': 'Delete item';
+            readonly 'add-item.button': 'Add item';
+            readonly 'add-property-button.label': 'Add property';
+            readonly 'boolean-input-true.value': 'Yes';
+            readonly 'boolean-input-false.value': 'No';
+            readonly 'show-field.label': 'Show field';
+            readonly 'hide-field.label': 'Hide field';
+            readonly 'expand-fields.label': 'Expand';
+            readonly 'collapse-fields.label': 'Collapse';
+            readonly 'delete-field.label': 'Delete field';
+            readonly 'create-option.label': 'Create';
+            readonly 'add-tag.label': 'Add tag';
+            readonly 'ref-field-combobox-input.placeholder': 'Search\u2026';
+            readonly 'ref-field.placeholder': 'Select\u2026';
+            readonly 'ref-field.placeholder_one': 'Select\u2026';
+            readonly 'ref-field.placeholder_other': 'Select items\u2026';
+            readonly 'example.placeholder': 'Example';
+            readonly 'latitude.placeholder': 'Latitude (e.g., 40.7128)';
+            readonly 'longitude.placeholder': 'Longitude (e.g., -74.0060)';
+            readonly 'cancel-button.label': 'Cancel';
+            readonly 'save-button.label': 'Save';
+            readonly 'create-text.label': 'Create text';
+            readonly 'format.boolean.label': 'Boolean';
+            readonly 'format.currency.label': 'Currency';
+            readonly 'format.date.label': 'Date';
+            readonly 'format.date-time.label': 'DateTime';
+            readonly 'format.did.label': 'DID';
+            readonly 'format.duration.label': 'Duration';
+            readonly 'format.dxn.label': 'DXN';
+            readonly 'format.email.label': 'Email';
+            readonly 'format.formula.label': 'Formula';
+            readonly 'format.hostname.label': 'Hostname';
+            readonly 'format.integer.label': 'Integer';
+            readonly 'format.json.label': 'JSON';
+            readonly 'format.lnglat.label': 'Geopoint';
+            readonly 'format.markdown.label': 'Markdown';
+            readonly 'format.percent.label': 'Percent';
+            readonly 'format.ref.label': 'Reference';
+            readonly 'format.regex.label': 'RegExp';
+            readonly 'format.string.label': 'String';
+            readonly 'format.single-select.label': 'Select';
+            readonly 'format.multi-select.label': 'Multi-select';
+            readonly 'format.text.label': 'Long text';
+            readonly 'format.time.label': 'Time';
+            readonly 'format.timestamp.label': 'Timestamp';
+            readonly 'format.user.label': 'User';
+            readonly 'format.number.label': 'Number';
+            readonly 'format.uri.label': 'URI';
+            readonly 'format.url.label': 'URL';
+            readonly 'format.uuid.label': 'UUID';
+            readonly 'latitude.label': 'Latitude';
+            readonly 'longitude.label': 'Longitude';
+            readonly 'select-option.label': 'Label';
+            readonly 'select-option-label.placeholder': 'Option label';
+            readonly 'select-option-delete.button': 'Delete';
+            readonly 'select-option-add.button': 'Add option';
+            readonly 'system-schema.title': 'System type';
+            readonly 'system-schema.description': 'System type: cannot add or remove fields.';
+            readonly 'remove.button': 'Delete';
+        };
+    };
+}, {
+    readonly 'en-US': {
+        readonly [x: string]: {
+            readonly 'typename.label': 'Feed';
+            readonly 'typename.label_zero': 'Feeds';
+            readonly 'typename.label_one': 'Feed';
+            readonly 'typename.label_other': 'Feeds';
+            readonly 'object-name.placeholder': 'New feed';
+            readonly 'add-object.label': 'Add feed';
+            readonly 'rename-object.label': 'Rename feed';
+            readonly 'delete-object.label': 'Delete feed';
+            readonly 'object-deleted.label': 'Feed deleted';
+            readonly 'plugin.name'?: undefined;
+            readonly 'empty-feed.message'?: undefined;
+            readonly 'feed-companion.label'?: undefined;
+            readonly 'sync-feed.label'?: undefined;
+            readonly 'sync-feed-error.title'?: undefined;
+            readonly 'feed-sync.label'?: undefined;
+            readonly 'view-trigger.label'?: undefined;
+            readonly 'add-feed.label'?: undefined;
+            readonly 'curate.label'?: undefined;
+            readonly 'clear-magazine.label'?: undefined;
+            readonly 'refreshing-magazine.label'?: undefined;
+            readonly 'no-feeds.label'?: undefined;
+            readonly 'empty-magazine.message'?: undefined;
+            readonly 'curate-error.message'?: undefined;
+            readonly 'clear-error.message'?: undefined;
+            readonly 'refresh-content-error.message'?: undefined;
+            readonly 'post-companion.label'?: undefined;
+            readonly 'post-title.placeholder'?: undefined;
+            readonly 'open-original.label'?: undefined;
+            readonly 'mark-unread.label'?: undefined;
+            readonly 'refresh-content.label'?: undefined;
+            readonly 'refresh-content-pending.label'?: undefined;
+            readonly 'archive-post.label'?: undefined;
+            readonly 'unarchive-post.label'?: undefined;
+            readonly 'star-post.label'?: undefined;
+            readonly 'unstar-post.label'?: undefined;
+            readonly 'sort-by-date.label'?: undefined;
+            readonly 'sort-by-rank.label'?: undefined;
+            readonly 'view-filter.label'?: undefined;
+            readonly 'show-archived.label'?: undefined;
+            readonly 'only-starred.label'?: undefined;
+            readonly 'close.label'?: undefined;
+        } | {
+            readonly 'typename.label': 'Post';
+            readonly 'typename.label_zero': 'Posts';
+            readonly 'typename.label_one': 'Post';
+            readonly 'typename.label_other': 'Posts';
+            readonly 'post-title.placeholder': 'Untitled';
+            readonly 'object-name.placeholder'?: undefined;
+            readonly 'add-object.label'?: undefined;
+            readonly 'rename-object.label'?: undefined;
+            readonly 'delete-object.label'?: undefined;
+            readonly 'object-deleted.label'?: undefined;
+            readonly 'plugin.name'?: undefined;
+            readonly 'empty-feed.message'?: undefined;
+            readonly 'feed-companion.label'?: undefined;
+            readonly 'sync-feed.label'?: undefined;
+            readonly 'sync-feed-error.title'?: undefined;
+            readonly 'feed-sync.label'?: undefined;
+            readonly 'view-trigger.label'?: undefined;
+            readonly 'add-feed.label'?: undefined;
+            readonly 'curate.label'?: undefined;
+            readonly 'clear-magazine.label'?: undefined;
+            readonly 'refreshing-magazine.label'?: undefined;
+            readonly 'no-feeds.label'?: undefined;
+            readonly 'empty-magazine.message'?: undefined;
+            readonly 'curate-error.message'?: undefined;
+            readonly 'clear-error.message'?: undefined;
+            readonly 'refresh-content-error.message'?: undefined;
+            readonly 'post-companion.label'?: undefined;
+            readonly 'open-original.label'?: undefined;
+            readonly 'mark-unread.label'?: undefined;
+            readonly 'refresh-content.label'?: undefined;
+            readonly 'refresh-content-pending.label'?: undefined;
+            readonly 'archive-post.label'?: undefined;
+            readonly 'unarchive-post.label'?: undefined;
+            readonly 'star-post.label'?: undefined;
+            readonly 'unstar-post.label'?: undefined;
+            readonly 'sort-by-date.label'?: undefined;
+            readonly 'sort-by-rank.label'?: undefined;
+            readonly 'view-filter.label'?: undefined;
+            readonly 'show-archived.label'?: undefined;
+            readonly 'only-starred.label'?: undefined;
+            readonly 'close.label'?: undefined;
+        } | {
+            readonly 'typename.label': 'Magazine';
+            readonly 'typename.label_zero': 'Magazines';
+            readonly 'typename.label_one': 'Magazine';
+            readonly 'typename.label_other': 'Magazines';
+            readonly 'object-name.placeholder': 'New magazine';
+            readonly 'add-object.label': 'Add magazine';
+            readonly 'rename-object.label': 'Rename magazine';
+            readonly 'delete-object.label': 'Delete magazine';
+            readonly 'object-deleted.label': 'Magazine deleted';
+            readonly 'plugin.name'?: undefined;
+            readonly 'empty-feed.message'?: undefined;
+            readonly 'feed-companion.label'?: undefined;
+            readonly 'sync-feed.label'?: undefined;
+            readonly 'sync-feed-error.title'?: undefined;
+            readonly 'feed-sync.label'?: undefined;
+            readonly 'view-trigger.label'?: undefined;
+            readonly 'add-feed.label'?: undefined;
+            readonly 'curate.label'?: undefined;
+            readonly 'clear-magazine.label'?: undefined;
+            readonly 'refreshing-magazine.label'?: undefined;
+            readonly 'no-feeds.label'?: undefined;
+            readonly 'empty-magazine.message'?: undefined;
+            readonly 'curate-error.message'?: undefined;
+            readonly 'clear-error.message'?: undefined;
+            readonly 'refresh-content-error.message'?: undefined;
+            readonly 'post-companion.label'?: undefined;
+            readonly 'post-title.placeholder'?: undefined;
+            readonly 'open-original.label'?: undefined;
+            readonly 'mark-unread.label'?: undefined;
+            readonly 'refresh-content.label'?: undefined;
+            readonly 'refresh-content-pending.label'?: undefined;
+            readonly 'archive-post.label'?: undefined;
+            readonly 'unarchive-post.label'?: undefined;
+            readonly 'star-post.label'?: undefined;
+            readonly 'unstar-post.label'?: undefined;
+            readonly 'sort-by-date.label'?: undefined;
+            readonly 'sort-by-rank.label'?: undefined;
+            readonly 'view-filter.label'?: undefined;
+            readonly 'show-archived.label'?: undefined;
+            readonly 'only-starred.label'?: undefined;
+            readonly 'close.label'?: undefined;
+        } | {
+            readonly 'typename.label'?: undefined;
+            readonly 'typename.label_zero'?: undefined;
+            readonly 'typename.label_one'?: undefined;
+            readonly 'typename.label_other'?: undefined;
+            readonly 'object-name.placeholder'?: undefined;
+            readonly 'add-object.label'?: undefined;
+            readonly 'rename-object.label'?: undefined;
+            readonly 'delete-object.label'?: undefined;
+            readonly 'object-deleted.label'?: undefined;
+            readonly 'plugin.name': 'Feed';
+            readonly 'empty-feed.message': 'No posts yet';
+            readonly 'feed-companion.label': 'Feed';
+            readonly 'sync-feed.label': 'Sync feed';
+            readonly 'sync-feed-error.title': 'Failed to sync feed';
+            readonly 'feed-sync.label': 'Feed Sync';
+            readonly 'view-trigger.label': 'View trigger';
+            readonly 'add-feed.label': 'Add feed';
+            readonly 'curate.label': 'Curate';
+            readonly 'clear-magazine.label': 'Clear (preserves starred)';
+            readonly 'refreshing-magazine.label': 'Refreshing magazine...';
+            readonly 'no-feeds.label': 'Add at least one feed first';
+            readonly 'empty-magazine.message': 'No articles yet.';
+            readonly 'curate-error.message': 'Failed to curate magazine.';
+            readonly 'clear-error.message': 'Failed to clear magazine.';
+            readonly 'refresh-content-error.message': 'Failed to refresh content.';
+            readonly 'post-companion.label': 'Post';
+            readonly 'post-title.placeholder': 'Untitled';
+            readonly 'open-original.label': 'Open original';
+            readonly 'mark-unread.label': 'Mark as unread';
+            readonly 'refresh-content.label': 'Refresh content';
+            readonly 'refresh-content-pending.label': 'Refreshing\u2026';
+            readonly 'archive-post.label': 'Archive';
+            readonly 'unarchive-post.label': 'Unarchive';
+            readonly 'star-post.label': 'Star';
+            readonly 'unstar-post.label': 'Unstar';
+            readonly 'sort-by-date.label': 'Sort by date';
+            readonly 'sort-by-rank.label': 'Sort by rank';
+            readonly 'view-filter.label': 'Filter posts';
+            readonly 'show-archived.label': 'Show archived';
+            readonly 'only-starred.label': 'Show starred only';
+            readonly 'close.label': 'Close';
+        };
+    };
+}];
+//# sourceMappingURL=translations.d.ts.map

package/dist/types/src/translations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"translations.d.ts","sourceRoot":"","sources":["../../../src/translations.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uCAKC,MAAM;4CACD,OAAO;2CACR,MAAM;6CACJ,OAAO;gDACJ,UAAU;yCACjB,UAAU;4CACP,aAAa;4CACb,aAAa;6CACZ,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uCAGpB,MAAM;4CACD,OAAO;2CACR,MAAM;6CACJ,OAAO;+CACL,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uCAGlB,UAAU;4CACL,WAAW;2CACZ,UAAU;6CACR,WAAW;gDACR,cAAc;yCACrB,cAAc;4CACX,iBAAiB;4CACjB,iBAAiB;6CAChB,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAG3B,MAAM;2CACC,cAAc;6CACZ,MAAM;wCACX,WAAW;8CACL,qBAAqB;wCAC3B,WAAW;2CACR,cAAc;uCAClB,UAAU;qCACZ,QAAQ;6CACA,2BAA2B;kDACtB,wBAAwB;uCACnC,6BAA6B;+CACrB,kBAAkB;6CACpB,4BAA4B;4CAC7B,2BAA2B;sDACjB,4BAA4B;6CACrC,MAAM;+CACJ,UAAU;4CACb,eAAe;0CACjB,gBAAgB;8CACZ,iBAAiB;sDACT,kBAAa;2CACxB,SAAS;6CACP,WAAW;wCAChB,MAAM;0CACJ,QAAQ;2CACP,cAAc;2CACd,cAAc;0CACf,cAAc;4CACZ,eAAe;2CAChB,mBAAmB;oCAC1B,OAAO;;;EAIC,CAAC"}

package/dist/types/src/types/CreateSubscription.d.ts

@@ -0,0 +1,29 @@
+import * as Schema from 'effect/Schema';
+import * as Subscription from './Subscription';
+export declare const HandleSchema: Schema.filter<typeof Schema.String>;
+export declare const isHandle: (u: unknown, overrideOptions?: import("effect/SchemaAST").ParseOptions | number) => u is string;
+export declare const isUrl: (u: unknown, overrideOptions?: import("effect/SchemaAST").ParseOptions | number) => u is string;
+export declare const StandardSiteCreateBase: Schema.Struct<{
+    type: Schema.Literal<["standard-site"]>;
+    handle: Schema.refine<string, typeof Schema.String>;
+    publication: Schema.SchemaClass<string, string, never>;
+}>;
+export type StandardSiteValues = Schema.Schema.Type<typeof StandardSiteCreateBase>;
+export declare const RssCreateBase: Schema.Struct<{
+    type: Schema.Literal<["rss"]>;
+    url: Schema.refine<string, typeof Schema.String>;
+    name: Schema.optional<Schema.SchemaClass<string, string, never>>;
+}>;
+export type RssValues = Schema.Schema.Type<typeof RssCreateBase>;
+export type CreateSubscriptionInput = {
+    type: 'standard-site';
+    handle: string;
+    publication: string;
+} | {
+    type: 'rss';
+    url: string;
+    name?: string;
+};
+/** Normalizes a create-form union member into the stored {@link Subscription.Subscription} fields. */
+export declare const makeSubscriptionFromCreate: (input: CreateSubscriptionInput) => Subscription.Subscription;
+//# sourceMappingURL=CreateSubscription.d.ts.map

package/dist/types/src/types/CreateSubscription.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CreateSubscription.d.ts","sourceRoot":"","sources":["../../../../src/types/CreateSubscription.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAIxC,OAAO,KAAK,YAAY,MAAM,gBAAgB,CAAC;AAK/C,eAAO,MAAM,YAAY,qCAExB,CAAC;AAEF,eAAO,MAAM,QAAQ,iGAA0B,CAAC;AAChD,eAAO,MAAM,KAAK,iGAAwB,CAAC;AAO3C,eAAO,MAAM,sBAAsB;;;;EAKjC,CAAC;AAEH,MAAM,MAAM,kBAAkB,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEnF,eAAO,MAAM,aAAa;;;;EAIxB,CAAC;AAEH,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,aAAa,CAAC,CAAC;AAIjE,MAAM,MAAM,uBAAuB,GAC/B;IAAE,IAAI,EAAE,eAAe,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,GAC9D;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAEhD,sGAAsG;AACtG,eAAO,MAAM,0BAA0B,UAAW,uBAAuB,KAAG,YAAY,CAAC,YASxF,CAAC"}

package/dist/types/src/types/FeedOperation.d.ts

@@ -0,0 +1,52 @@
+import { Operation } from '@dxos/compute';
+import { Database, Registry } from '@dxos/echo';
+import * as Magazine from './Magazine';
+import * as Subscription from './Subscription';
+/** Fetches an RSS/Atom feed and appends new posts to the backing ECHO feed. */
+export declare const SyncFeed: Operation.Definition<{
+    readonly feed: import("@dxos/echo/internal").Ref<Subscription.Subscription & import("@dxos/echo/Entity").OfKind<import("@dxos/echo/internal").EntityKind.Object> & import("@dxos/echo/Obj").Unknown>;
+}, void, Database.Service>;
+/**
+ * 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).
+ */
+export declare const FetchArticleContent: Operation.Definition<{
+    readonly post: import("@dxos/echo/internal").Ref<Subscription.Post & import("@dxos/echo/Entity").OfKind<import("@dxos/echo/internal").EntityKind.Object> & import("@dxos/echo/Obj").Unknown>;
+}, {
+    readonly text: string;
+    readonly imageUrls: readonly string[];
+}, 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.
+ */
+export declare const LoadPostContent: Operation.Definition<{
+    readonly post: import("@dxos/echo/internal").Ref<Subscription.Post & import("@dxos/echo/Entity").OfKind<import("@dxos/echo/internal").EntityKind.Object> & import("@dxos/echo/Obj").Unknown>;
+    readonly force?: boolean | undefined;
+}, void, never>;
+/**
+ * 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.
+ */
+export declare const CurateMagazine: Operation.Definition<{
+    readonly magazine: import("@dxos/echo/internal").Ref<Magazine.Magazine & import("@dxos/echo/Entity").OfKind<import("@dxos/echo/internal").EntityKind.Object> & import("@dxos/echo/Obj").Unknown>;
+}, {
+    readonly synced: number;
+    readonly curated: number;
+}, Registry.Service | Database.Service>;
+/**
+ * Clears a Magazine's curated posts, preserving any that are starred. Drives the MagazineArticle
+ * Clear button.
+ */
+export declare const ClearMagazine: Operation.Definition<{
+    readonly magazine: import("@dxos/echo/internal").Ref<Magazine.Magazine & import("@dxos/echo/Entity").OfKind<import("@dxos/echo/internal").EntityKind.Object> & import("@dxos/echo/Obj").Unknown>;
+}, void, Database.Service>;
+//# sourceMappingURL=FeedOperation.d.ts.map

package/dist/types/src/types/FeedOperation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FeedOperation.d.ts","sourceRoot":"","sources":["../../../../src/types/FeedOperation.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC1C,OAAO,EAAE,QAAQ,EAAY,QAAQ,EAAE,MAAM,YAAY,CAAC;AAI1D,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAC;AACvC,OAAO,KAAK,YAAY,MAAM,gBAAgB,CAAC;AAI/C,+EAA+E;AAC/E,eAAO,MAAM,QAAQ;;0BAYK,CAAC;AAE3B;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB;;;;;oBAmB9B,CAAC;AAEH;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe;;;eAkB1B,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,cAAc;;;;;uCAmBD,CAAC;AAE3B;;;GAGG;AACH,eAAO,MAAM,aAAa;;0BAcA,CAAC"}

package/dist/types/src/types/Magazine.d.ts

@@ -0,0 +1,87 @@
+import * as Schema from 'effect/Schema';
+import { Instructions } from '@dxos/compute';
+import { Obj, Ref, Type } from '@dxos/echo';
+import { type EntityId } from '@dxos/keys';
+import { StateMap } from '@dxos/schema';
+import * as Subscription from './Subscription';
+export declare const 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.
+ */
+export declare const DEFAULT_INSTRUCTIONS: string;
+/** Per-Post magazine-scoped curation state, keyed by Post id. */
+export declare const PostState: Schema.Struct<{
+    /** Agent-assigned relevance within this magazine (lower = more relevant). */
+    rank: Schema.optional<typeof Schema.Number>;
+    /** Agent-written concise snippet summarising the article in the context of this magazine's topic. */
+    snippet: Schema.optional<typeof Schema.String>;
+    /** Agent-selected hero image URL for this post in this magazine. */
+    imageUrl: Schema.optional<typeof Schema.String>;
+}>;
+export type PostState = Schema.Schema.Type<typeof PostState>;
+/**
+ * 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.
+ */
+export declare const CurationOutput: Schema.Struct<{
+    posts: Schema.Array$<Schema.Struct<{
+        id: import("@dxos/keys").EntityIdClass;
+        /** Concise 1-2 sentence snippet summarising why this article is relevant to the magazine topic. */
+        snippet: Schema.optional<typeof Schema.String>;
+        /** Best image URL found for this article (from the post or fetched content). */
+        imageUrl: Schema.optional<typeof Schema.String>;
+    }>>;
+}>;
+declare const Magazine_base: Type.ObjClass<Magazine, {
+    readonly name?: string | undefined;
+    readonly feeds: readonly import("@dxos/echo/internal").Ref<Subscription.Subscription & import("@dxos/echo/Entity").OfKind<import("@dxos/echo/internal").EntityKind.Object> & Obj.Unknown>[];
+    readonly posts: readonly import("@dxos/echo/internal").Ref<Subscription.Post & import("@dxos/echo/Entity").OfKind<import("@dxos/echo/internal").EntityKind.Object> & Obj.Unknown>[];
+    readonly instructions?: import("@dxos/echo/internal").Ref<Instructions.Instructions & import("@dxos/echo/Entity").OfKind<import("@dxos/echo/internal").EntityKind.Object> & Obj.Unknown> | undefined;
+    readonly postState: import("@dxos/echo/internal").Ref<StateMap.StateMap & import("@dxos/echo/Entity").OfKind<import("@dxos/echo/internal").EntityKind.Object> & Obj.Unknown>;
+    readonly keep?: number | undefined;
+}, {}>;
+/**
+ * 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.
+ */
+export declare class Magazine extends Magazine_base {
+}
+/** Checks if a value is a Magazine object. */
+export declare const instanceOf: (value: unknown) => value is Magazine;
+export type MakeProps = Omit<Obj.MakeProps<typeof Magazine>, 'feeds' | 'posts' | 'instructions' | 'postState'> & {
+    feeds?: Ref.Ref<Subscription.Subscription>[];
+    posts?: Ref.Ref<Subscription.Post>[];
+    /** Editorial brief seeded into the curation Routine's instructions (composed with the default methodology). */
+    instructions?: string;
+};
+/**
+ * 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.
+ */
+export declare const make: (props?: MakeProps) => Magazine;
+/** Composes Routine instructions from the default editorial methodology and an optional topic focus. */
+export declare const composeInstructions: (topic?: string) => string;
+/** Schema for the create-magazine dialog form. */
+export declare const CreateMagazineSchema: Schema.Struct<{
+    name: Schema.optional<Schema.SchemaClass<string, string, never>>;
+    feeds: Schema.Array$<Ref.RefSchema<Subscription.Subscription & import("@dxos/echo/Entity").OfKind<import("@dxos/echo/internal").EntityKind.Object> & Obj.Unknown>>;
+    instructions: Schema.optional<Schema.SchemaClass<string, string, never>>;
+}>;
+/** Agent-assigned relevance of a Post within a Magazine, or undefined. */
+export declare const getRank: (magazine: Magazine | undefined, postId: EntityId) => number | undefined;
+/** Returns the full magazine-scoped {@link PostState} for a Post, or an empty record. */
+export declare const getPostState: (magazine: Magazine | undefined, postId: EntityId) => Partial<PostState>;
+/** Merges partial state into a Post's magazine-scoped {@link PostState}. */
+export declare const patchPostState: (magazine: Magazine, postId: EntityId, state: Partial<PostState>) => void;
+/** Sets the magazine-scoped rank for a Post. */
+export declare const setRank: (magazine: Magazine, postId: EntityId, rank: number) => void;
+export {};
+//# sourceMappingURL=Magazine.d.ts.map

package/dist/types/src/types/Magazine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Magazine.d.ts","sourceRoot":"","sources":["../../../../src/types/Magazine.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAGxC,OAAO,EAAE,YAAY,EAAS,MAAM,eAAe,CAAC;AACpD,OAAO,EAAmB,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAE7D,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAGxC,OAAO,KAAK,YAAY,MAAM,gBAAgB,CAAC;AAE/C,eAAO,MAAM,SAAS,4BAA4B,CAAC;AAEnD;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,QAahC,CAAC;AAEF,iEAAiE;AACjE,eAAO,MAAM,SAAS;IACpB,6EAA6E;;IAE7E,qGAAqG;;IAErG,oEAAoE;;EAEpE,CAAC;AACH,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,SAAS,CAAC,CAAC;AAE7D;;;;;GAKG;AACH,eAAO,MAAM,cAAc;;;QAIrB,mGAAmG;;QAEnG,gFAAgF;;;EAIpF,CAAC;;;;;;;;;AAEH;;;;;GAKG;AACH,qBAAa,QAAS,SAAQ,aAsC7B;CAAG;AAEJ,8CAA8C;AAC9C,eAAO,MAAM,UAAU,UAAW,OAAO,KAAG,KAAK,IAAI,QAA2C,CAAC;AAEjG,MAAM,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,OAAO,QAAQ,CAAC,EAAE,OAAO,GAAG,OAAO,GAAG,cAAc,GAAG,WAAW,CAAC,GAAG;IAC/G,KAAK,CAAC,EAAE,GAAG,CAAC,GAAG,CAAC,YAAY,CAAC,YAAY,CAAC,EAAE,CAAC;IAC7C,KAAK,CAAC,EAAE,GAAG,CAAC,GAAG,CAAC,YAAY,CAAC,IAAI,CAAC,EAAE,CAAC;IACrC,+GAA+G;IAC/G,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,IAAI,WAAW,SAAS,KAAQ,QA8B5C,CAAC;AAEF,wGAAwG;AACxG,eAAO,MAAM,mBAAmB,WAAY,MAAM,KAAG,MAGpD,CAAC;AAEF,kDAAkD;AAClD,eAAO,MAAM,oBAAoB;;;;EAe/B,CAAC;AAMH,0EAA0E;AAC1E,eAAO,MAAM,OAAO,aAAc,QAAQ,GAAG,SAAS,UAAU,QAAQ,KAAG,MAAM,GAAG,SAGnF,CAAC;AAEF,yFAAyF;AACzF,eAAO,MAAM,YAAY,aAAc,QAAQ,GAAG,SAAS,UAAU,QAAQ,KAAG,OAAO,CAAC,SAAS,CAGhG,CAAC;AAEF,4EAA4E;AAC5E,eAAO,MAAM,cAAc,aAAc,QAAQ,UAAU,QAAQ,SAAS,OAAO,CAAC,SAAS,CAAC,KAAG,IAKhG,CAAC;AAEF,gDAAgD;AAChD,eAAO,MAAM,OAAO,aAAc,QAAQ,UAAU,QAAQ,QAAQ,MAAM,KAAG,IACjC,CAAC"}

package/dist/types/src/types/Magazine.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Magazine.test.d.ts.map

package/dist/types/src/types/Magazine.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Magazine.test.d.ts","sourceRoot":"","sources":["../../../../src/types/Magazine.test.ts"],"names":[],"mappings":""}

package/dist/types/src/types/Subscription.d.ts

@@ -0,0 +1,144 @@
+import * as Schema from 'effect/Schema';
+import { type Space } from '@dxos/client/echo';
+import { Database, Feed, Obj, Query, Type } from '@dxos/echo';
+import { type EntityId } from '@dxos/keys';
+import { StateMap, TagIndex } from '@dxos/schema';
+/** Subscription protocol type. */
+export declare const FeedType: Schema.Literal<["standard-site", "rss", "bluesky"]>;
+export type FeedType = Schema.Schema.Type<typeof FeedType>;
+/**
+ * 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`.
+ */
+export declare const SYSTEM_TAGS: {
+    readonly starred: {
+        readonly key: {
+            readonly source: 'org.dxos.plugin.magazine';
+            readonly id: 'starred';
+        };
+        readonly label: 'Starred';
+        readonly hue: 'amber';
+    };
+    readonly archived: {
+        readonly key: {
+            readonly source: 'org.dxos.plugin.magazine';
+            readonly id: 'archived';
+        };
+        readonly label: 'Archived';
+        readonly hue: 'neutral';
+    };
+};
+/** A system per-Post flag modelled as a tag. */
+export type SystemTag = keyof typeof SYSTEM_TAGS;
+/** Per-Post mutable state stored on the Subscription (shared across magazines), keyed by Post id. */
+export declare const PostState: Schema.Struct<{
+    /** ISO 8601 timestamp when first opened. */
+    readAt: Schema.optional<typeof Schema.String>;
+}>;
+export type PostState = Schema.Schema.Type<typeof PostState>;
+/**
+ * Default upper bound on the number of (non-starred) Posts retained when
+ * syncing a {@link Subscription} or curating a Magazine. Applied when the object
+ * has no explicit `keep` value.
+ */
+export declare const DEFAULT_KEEP = 10;
+declare const Subscription_base: Type.ObjClass<Subscription, {
+    readonly name?: string | undefined;
+    readonly url?: string | undefined;
+    readonly type?: "bluesky" | "rss" | "standard-site" | undefined;
+    readonly description?: string | undefined;
+    readonly link?: string | undefined;
+    readonly iconUrl?: string | undefined;
+    readonly keep?: number | undefined;
+    readonly cursor?: string | undefined;
+    readonly feed: import("@dxos/echo/internal").Ref<Feed.Feed & import("@dxos/echo/Entity").OfKind<import("@dxos/echo/internal").EntityKind.Object> & Obj.Unknown>;
+    readonly contentFeed?: import("@dxos/echo/internal").Ref<Feed.Feed & import("@dxos/echo/Entity").OfKind<import("@dxos/echo/internal").EntityKind.Object> & Obj.Unknown> | undefined;
+    readonly postState: import("@dxos/echo/internal").Ref<StateMap.StateMap & import("@dxos/echo/Entity").OfKind<import("@dxos/echo/internal").EntityKind.Object> & Obj.Unknown>;
+    readonly tags: import("@dxos/echo/internal").Ref<TagIndex.TagIndex & import("@dxos/echo/Entity").OfKind<import("@dxos/echo/internal").EntityKind.Object> & Obj.Unknown>;
+}, {}>;
+/**
+ * Subscription feed schema: an RSS/Atom/AT Protocol subscription.
+ */
+export declare class Subscription extends Subscription_base {
+}
+/** Checks if a value is a Subscription.Subscription object. */
+export declare const instanceOf: (value: unknown) => value is Subscription;
+/** Creates a Subscription.Subscription with backing ECHO feeds for posts and fetched content. */
+export declare const makeSubscription: (props?: Omit<Obj.MakeProps<typeof Subscription>, 'feed' | 'contentFeed' | 'postState' | 'tags'>) => Subscription;
+declare const Post_base: Type.ObjClass<Post, {
+    readonly source?: import("@dxos/echo/internal").Ref<Subscription & import("@dxos/echo/Entity").OfKind<import("@dxos/echo/internal").EntityKind.Object> & Obj.Unknown> | undefined;
+    readonly title?: string | undefined;
+    readonly link?: string | undefined;
+    readonly description?: string | undefined;
+    readonly content?: string | undefined;
+    readonly author?: string | undefined;
+    readonly published?: string | undefined;
+    readonly guid?: string | undefined;
+}, {}>;
+/**
+ * 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`.
+ */
+export declare class Post extends Post_base {
+}
+/** Creates a Subscription.Post object. */
+export declare const makePost: (props?: Obj.MakeProps<typeof Post>) => Post;
+declare const PostContent_base: Type.ObjClass<PostContent, {
+    readonly post: import("@dxos/echo/internal").Ref<Post & import("@dxos/echo/Entity").OfKind<import("@dxos/echo/internal").EntityKind.Object> & Obj.Unknown>;
+    readonly text: string;
+    readonly snippet?: string | undefined;
+    readonly imageUrl?: string | undefined;
+    readonly fetchedAt: string;
+}, {}>;
+/**
+ * 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.
+ */
+export declare class PostContent extends PostContent_base {
+}
+/** ISO timestamp the Post was first opened, or undefined. */
+export declare const getReadAt: (subscription: Subscription | Obj.Snapshot<Subscription> | undefined, postId: EntityId) => string | undefined;
+/** Sets/clears the Post's read marker. */
+export declare const setReadAt: (subscription: Subscription, postId: EntityId, value: string | undefined) => void;
+/** Resolves the uri of an existing system Tag without creating one; `undefined` when absent. Async. */
+export declare const findSystemTagUri: (db: Pick<Database.Database, 'query'>, which: SystemTag) => Promise<string | undefined>;
+/** Whether a Post carries the given (resolved) tag uri on its Subscription. Pure. */
+export declare const hasTag: (subscription: Subscription | Obj.Snapshot<Subscription> | undefined, postId: EntityId, tagUri: string | undefined) => boolean;
+/** Sets/clears a system tag (`starred`/`archived`) on a Post (find-or-creates the Tag object). Async. */
+export declare const setTag: (subscription: Subscription, postId: EntityId, db: Pick<Database.Database, 'query' | 'add'>, which: SystemTag, value: boolean) => Promise<void>;
+/** Resolves a Post's source Subscription synchronously if its `source` ref is loaded, else undefined. */
+export declare const getPostSubscription: (post: Post) => Subscription | undefined;
+/**
+ * Query for {@link PostContent} entries referencing a Post via the reverse-ref index.
+ * Scoped to the Subscription's post and content feeds.
+ */
+export declare const queryPostContentForPost: (subscription: Subscription | Obj.Snapshot<Subscription>, post: Post | Obj.Snapshot<Post>) => Query.Any | undefined;
+/** Pick the newest PostContent when multiple entries reference the same Post. */
+export declare const pickLatestPostContent: (entries: readonly PostContent[]) => PostContent | undefined;
+/** Looks up PostContent for a Post (newest wins); undefined if absent. */
+export declare const findPostContent: (subscription: Subscription | Obj.Snapshot<Subscription>, post: Post | Obj.Snapshot<Post>) => Promise<PostContent | undefined>;
+/**
+ * Appends a {@link PostContent} entry (body + refined snippet/imageUrl) to a Subscription's
+ * `contentFeed`, lazily creating the feed on first use.
+ */
+export declare const appendPostContent: (space: Pick<Space, 'db'>, subscription: Subscription, entry: {
+    post: Post | Obj.Snapshot<Post>;
+    text: string;
+    snippet?: string;
+    imageUrl?: string;
+    fetchedAt?: string;
+}) => Promise<void>;
+export {};
+//# sourceMappingURL=Subscription.d.ts.map