handle read state, and realize how indexing has to work

src/app/components/feed-row.tsx

···
 
   const feedurl = createMemo(() => encodeURIComponent(props.feed.url))
 
-  const totalCount = makeSignalQuery(async () =>
-    await feedline.entries.where('feedurl').equals(props.feed.url).count()
+  const unreadCount = makeSignalQuery(async () =>
+    await feedline.entries.where('[feedurl+idx_read]').equals([props.feed.url, 0]).count()
   )
-
-  const readCount = makeSignalQuery(async () =>
-    await feedline.entries
-      .where('[feedurl+progress.position]')
-      .between([props.feed.url, 0], [props.feed.url, [[]]])
-      .count()
-  )
-
-  const unreadCount = () => (totalCount() ?? 0) - (readCount() ?? 0)
 
   return (
     <li>

src/app/layout/sidenav/index.tsx

···
   const [publishedAt] = createDate(props.feed.lastPublishedAt ?? props.feed.lastBuildAt ?? '1999-12-31')
   const [published] = createTimeAgo(publishedAt)
 
-  const totalCount = makeSignalQuery(
-    async () => await feedline.entries.where('feedurl').equals(props.feed.url).count(),
-  )
-
-  const readCount = makeSignalQuery(
-    async () =>
-      await feedline.entries
-        .where('[feedurl+progress.position]')
-        .between([props.feed.url, 0], [props.feed.url, [[]]])
-        .count(),
+  const unreadCount = makeSignalQuery(
+    async () => await feedline.entries.where('[feedurl+idx_read]').equals([props.feed.url, 0]).count(),
   )
-
-  const unreadCount = () => (totalCount() ?? 0) - (readCount() ?? 0)
 
   return (
     <li>

src/app/pages/entry/index.tsx

···
   }
 
   createEffect(() => {
-    console.log('live query', entry()?.title)
+    console.log('loaded entry', entry())
   })
 
   // mark as read after delay if not already read, and on unload
···
       if (!entry) return
 
       // already read - nothing to do on mount
-      const alreadyRead = entry.progress !== undefined
+      const alreadyRead = entry.progress !== null
 
       // otherwise start the timer
       let timeoutId: ReturnType<typeof setTimeout> | undefined
···
     return publishedAt && new Date(publishedAt).toLocaleDateString()
   }
 
+  const content = () => {
+    const html = entry()?.content || entry()?.snippet
+    if (!html) return null
+
+    const href = entry()?.linkUrl || 'about:blank'
+    return `<base href="${href}">${html}`
+  }
+
   return (
     <NavigationPage class={styles['entry']}>
       <Show when={entry()} fallback={<p>Entry not found</p>}>
···
               <button onClick={setTitle}>Change Title</button>
             </header>
 
-            <Show when={entry().content || entry().snippet}>
-              {(content) => <iframe srcdoc={content()} />}
+            <Show when={content()}>
+              {(content) => <iframe srcdoc={content()} sandbox="allow-same-origin" />}
             </Show>
 
             <Show when={enclosureAudio()}>

src/app/pages/feed/index.tsx

···
 
 function FeedEntryRow(props: {entry: Entry; feedurl: string, pass: ComponentProps<'li'>}) {
   const feedurl = createMemo(() => encodeURIComponent(props.feedurl))
-  const unread = createMemo(() => props.entry.progress === undefined)
+  const unread = createMemo(() => props.entry.progress === null)
   const guid = createMemo(() => encodeURIComponent(props.entry.guid))
   const date = createMemo(
     () => props.entry.publishedAt && new Date(props.entry.publishedAt).toLocaleDateString(),

src/feedline/client/action-handler.ts

···
 
   async #feedAdd(action: FeedAddAction) {
     try {
-      await this.#db.feeds.add({
+      const feed = this.#db.enrichFeed({
         url: action.dat.url,
         lock: action.dat.lock ?? null,
         status: 'pending',
···
         tags: [],
         meta: {},
       })
+
+      await this.#db.feeds.add(feed)
     } catch (exc) {
       // skip duplicates - feed already exists
       if (exc instanceof Dexie.ConstraintError) return
···
   }
 
   async #feedPatch(action: FeedPatchAction) {
-    // this should check locks and clocks
-    await this.#db.feeds.update(action.dat.url, action.dat.payload)
+    // TODO: this should check locks and clocks
+    const update = this.#db.enrichFeed(action.dat.payload)
+    await this.#db.feeds.update(action.dat.url, update)
   }
 
   async #entryPatch(action: EntryPatchAction) {
-    // this should check locks and clocks
+    // TODO: this should check locks and clocks
     try {
       await this.#db.transaction('rw', ['feeds', 'entries'], async (tx) => {
         const feed = await tx.feeds.get(action.dat.feedurl)
···
         const key: [string, string] = [action.dat.feedurl, action.dat.guid]
         const extant = await tx.entries.get(key)
         if (extant) {
-          await tx.entries.update(key, action.dat.payload)
+          const update = this.#db.enrichEntry(action.dat.payload)
+          await tx.entries.update(key, update)
         } else {
-          await tx.entries.add({
+          const entry = this.#db.enrichEntry({
             tags: [],
             links: [],
             meta: {},
             lock: null,
+            progress: null,
             // defaults ^^
             ...action.dat.payload,
             // overrides vv
             guid: action.dat.guid,
             feedurl: action.dat.feedurl,
           })
+
+          await tx.entries.add(entry)
         }
       })
       return
···
       return
     }
 
-    await this.#db.entries.update(key, {
+    const update = this.#db.enrichEntry({
       progress: {
         position: action.dat.position,
         lastUpdated: action.clk,
       },
     })
+
+    await this.#db.entries.update(key, update)
   }
 }

src/feedline/client/database.ts

···
 import {Timestamp, elapsed} from '#realm/schema/timestamp'
 
 import {Entry} from '#feedline/schema/entry'
-import {Feed} from '#feedline/schema/feed'
+import {Feed, tagString} from '#feedline/schema/feed'
 import {Lock} from '#feedline/schema/lock'
 
 export type Lockable = {lock: Lock | null}
+
+export type FeedRow  = Feed & {
+  idx_tags: string[]
+}
+
+export type EntryRow = Entry & {
+  idx_read?: 0 | 1
+  idx_tags: string[]
+}
 
 export class FeedlineDatabase extends Dexie {
-  feeds!: Table<Feed, string>
-  entries!: Table<Entry>
+  feeds!: Table<FeedRow>
+  entries!: Table<EntryRow>
 
   constructor(identid: IdentID) {
     super(`feedline-${identid}`)
 
     this.version(1).stores({
-      feeds: '&url, *tags.tag, lock.at, lock.by, status, medium',
-      entries:
-        '&[feedurl+guid], *tags.tag, lock.at, lock.by, publishedAt, fetchedAt, [feedurl+progress.position]',
+      feeds: '&url, lock.at, lock.by, status, medium, *idx_tags',
+      entries: '&[feedurl+guid], lock.at, lock.by, publishedAt, fetchedAt, *idx_tags, [feedurl+idx_read]'
     })
+  }
+
+  enrichFeed(feed_: Feed): FeedRow
+  enrichFeed(feed_: Partial<Feed>): Partial<FeedRow>
+  enrichFeed(feed_: Feed | Partial<Feed>): Feed | Partial<FeedRow> {
+    const feed = feed_ as FeedRow
+
+    feed.idx_tags = feed.tags?.map(tagString)
+
+    return feed
+  }
+
+  enrichEntry(entry_: Entry): EntryRow
+  enrichEntry(entry_: Partial<Entry>): Partial<EntryRow>
+  enrichEntry(entry_: Entry | Partial<Entry>): Entry | Partial<Entry> {
+    const entry = entry_ as Partial<EntryRow>
+
+    entry.idx_read = entry.progress === null ? 0 : 1;
+    if (entry.tags) {
+      entry.idx_tags = entry.tags.map(tagString)
+    }
+
+    return entry
   }
 
   /**

src/feedline/client/feed-fetcher.ts

···
   }
 }
 
+// guess the mime based on the file extension
+function urlToMime(url_: string): string | null {
+  try {
+    const url = URL.parse(url_)
+    if (!url) return null
+
+    const path  = url.pathname.split('/').pop()
+    const match = path?.match(/\.([a-z0-9]+)$/i)
+    switch (match?.[1]) {
+      case 'mp3': return 'audio/mpeg'
+      case 'm4a': return 'audio/mp4'
+      case 'ogg': return 'audio/ogg'
+      case 'jpg':
+      case 'jpeg': return 'image/jpeg'
+      case 'png': return 'image/png'
+
+      default:
+        return null
+    }
+  } catch {
+    return null
+  }
+}
+
 function mapRssToEntry(feedurl: string, item: Rss.Item<string>, fetchedAt: number): Entry {
   const entryTags: Tag[] = []
   const entryLinks: Link[] = []
···
   }
 
   // Get primary enclosure
-  const enclosure = item.enclosures?.[0]
+  const enclosure: Entry['enclosure'] = item.enclosures?.[0]
     ? {
         url: item.enclosures[0].url,
-        mime: item.enclosures[0].type,
+        mime: item.enclosures[0].type || urlToMime(item.enclosures[0].url),
         length: item.enclosures[0].length,
       }
     : undefined
···
     feedurl,
     guid: item.guid?.value ?? item.link ?? `${feedurl}#${item.title}`,
     lock: null,
+    progress: null,
     tags: entryTags,
     title: item.title ?? null,
     snippet: item.description ?? null,
···
   const enclosure = enclosureLink
     ? {
         url: enclosureLink.href,
-        mime: enclosureLink.type ?? null,
+        mime: enclosureLink.type || urlToMime(enclosureLink.href),
         length: enclosureLink.length ?? null,
       }
     : undefined
···
     feedurl,
     guid: entry.id,
     lock: null,
+    progress: null,
     tags: entryTags,
     title: entry.title,
     snippet: entry.summary ?? null,

src/feedline/schema/entry.ts

···
   guid: z.string(),
   lock: lockSchema.nullable(),
 
-  // for db indexing
   progress: z
     .object({
       position: z.number(), // seconds or pixels
       lastUpdated: logicalClockSchema,
     })
-    .optional(),
+    .nullable(),
 
   title: z.string().nullish(),
   snippet: z.string().nullish(),

src/feedline/schema/feed.ts

···
   z.object({tag: z.literal('podcast.episode'), value: z.string()}),
 ])
 
+export type Tag = z.infer<typeof tagSchema>
+
+export function tagString(tag: Tag): string {
+  switch(tag.tag) {
+    case 'explicit': return 'explicit'
+    case 'category': return `category:${tag.value}`
+    case 'language': return `language:${tag.value}`
+    case 'person': return `person:${tag.value}${tag.rel ? ":" + tag.rel : ""}`
+    case 'podcast.season': return `podcast:season:${tag.value}`
+    case 'podcast.episode': return `podcast:episode:${tag.value}`
+  }
+}
+
 export const feedSchema = z.object({
   url: z.url(),
   lock: lockSchema.nullable(),
···
 
 export type Feed = z.infer<typeof feedSchema>
 export type Link = z.infer<typeof linkSchema>
-export type Tag = z.infer<typeof tagSchema>