dsh-book-reader 0.1.0 → 0.2.0

package/lib/index.js

@@ -12,13 +12,14 @@
  *   `.pdf` suffix, regular file, size cap, JSON only, no CORS header.
  * - Page images use the same attachment route as `read_image`: a durable
  *   `attachments.saveImage` reference plus an `ImageBlock` from `render()`.
- * - Auto-share is per-session and deliberately conservative: a changed page,
- *   a minimum interval, a minimum step distance, at most one message per step.
+ * - Auto-share is per-session and deliberately conservative: at most one
+ *   message per turn, and only when the page changed since the last hint.
  *
  * @module dsh-pdf-reader
  */
 
 import { basename, isAbsolute, relative, resolve as resolvePath, sep } from 'node:path'
+import { createHash } from 'node:crypto'
 import { appendFileSync } from 'node:fs'
 import { stat } from 'node:fs/promises'
 import z from '@deepseek-ai/schemastery'
@@ -51,16 +52,16 @@ const PAGE_SELECTION_HARD_LIMIT = 256
 export const Config = z.object({
   /** Master switch: false mounts no tool, route, or listener. */
   enabled: z.boolean().default(true),
-  /** Inject the current reading page into `agent/pre-step`. */
+  /** Remember page/zoom per PDF and restore on reopen. */
+  rememberView: z.boolean().default(true),
+  /** Inject the current reading page into `agent/pre-step`, at most once per turn. */
   autoShare: z.boolean().default(true),
   /** Resolve the outline section for the injected message (one cached getInfo). */
   autoShareSection: z.boolean().default(true),
-  /** Minimum milliseconds between two injected reading positions. */
-  autoShareMinIntervalMs: z.number().default(180_000),
-  /** Minimum absolute page change required before another injection. */
+  /** Optional minimum milliseconds between hints; 0 = no time throttle. */
+  autoShareMinIntervalMs: z.number().default(0),
+  /** Minimum absolute page change required before another hint. */
   autoSharePageDelta: z.number().default(1),
-  /** Minimum step distance between injections in the same turn. */
-  autoShareMinSteps: z.number().default(1),
   /** Ignore a reported position older than this; 0 means no age limit. */
   autoShareMaxAgeMs: z.number().default(0),
   /** Hard cap on pages rendered by one `pdf_read_pages` call. */
@@ -96,11 +97,11 @@ export const Config = z.object({
 /** Defaults applied independently of the loader, so direct callers work too. */
 export const DEFAULT_CONFIG = Object.freeze({
   enabled: true,
+  rememberView: true,
   autoShare: true,
   autoShareSection: true,
-  autoShareMinIntervalMs: 180_000,
+  autoShareMinIntervalMs: 0,
   autoSharePageDelta: 1,
-  autoShareMinSteps: 1,
   autoShareMaxAgeMs: 0,
   maxPagesPerCall: 4,
   defaultScale: 2.5,
@@ -124,7 +125,6 @@ export const INITIAL_AUTO_SHARE_STATE = Object.freeze({
   lastInjectedPdfPage: null,
   lastInjectedAt: null,
   lastInjectedTurn: null,
-  lastInjectedStep: null,
 })
 
 /** Create an Error carrying a stable code, for tests and route mapping. */
@@ -170,6 +170,7 @@ export function normalizeConfig(raw) {
   if (typeof source !== 'object' || Array.isArray(source)) throw new TypeError('pdf-reader: config must be an object')
   return {
     enabled: configBoolean(source.enabled, DEFAULT_CONFIG.enabled, 'enabled'),
+    rememberView: configBoolean(source.rememberView, DEFAULT_CONFIG.rememberView, 'rememberView'),
     autoShare: configBoolean(source.autoShare, DEFAULT_CONFIG.autoShare, 'autoShare'),
     autoShareSection: configBoolean(source.autoShareSection, DEFAULT_CONFIG.autoShareSection, 'autoShareSection'),
     autoShareMinIntervalMs: configInteger(
@@ -180,7 +181,6 @@ export function normalizeConfig(raw) {
       86_400_000,
     ),
     autoSharePageDelta: configInteger(source.autoSharePageDelta, DEFAULT_CONFIG.autoSharePageDelta, 'autoSharePageDelta', 1, 1000),
-    autoShareMinSteps: configInteger(source.autoShareMinSteps, DEFAULT_CONFIG.autoShareMinSteps, 'autoShareMinSteps', 1, 1000),
     autoShareMaxAgeMs: configInteger(source.autoShareMaxAgeMs, DEFAULT_CONFIG.autoShareMaxAgeMs, 'autoShareMaxAgeMs', 0, 31_536_000_000),
     maxPagesPerCall: configInteger(
       source.maxPagesPerCall,
@@ -421,6 +421,233 @@ export function createPositionStore({ now = Date.now, maxSessions = 200, maxPath
   }
 }
 
+// ---------------------------------------------------------------------------
+// Remembered page/zoom view state
+// ---------------------------------------------------------------------------
+
+/** Durable storage-domain name for remembered book views. */
+export const VIEW_DOMAIN_NAME = 'book_reader_views'
+
+/** Format version of {@link VIEW_DOMAIN_NAME}; bump only with a migration. */
+export const VIEW_DOMAIN_VERSION = 1
+
+/** Table holding one remembered view per book inside {@link VIEW_DOMAIN_NAME}. */
+export const VIEW_TABLE_NAME = 'views'
+
+/** Hard cap on remembered books; the oldest records are pruned past this. */
+export const MAX_VIEW_RECORDS = 500
+
+/** Longest accepted book path in a `/view` request. */
+export const MAX_VIEW_PATH_LENGTH = 4096
+
+/** Hard ceiling for a remembered PDF page number. */
+export const MAX_VIEW_PAGE = 100_000
+
+/** The only accepted zoom modes (mirrors the client's toolbar). */
+export const VIEW_ZOOM_MODES = Object.freeze(['fit-width', 'fixed'])
+
+/** Smallest accepted zoom ratio. */
+export const VIEW_ZOOM_SCALE_MIN = 0.25
+
+/** Largest accepted zoom ratio. */
+export const VIEW_ZOOM_SCALE_MAX = 4
+
+/**
+ * Stable storage key for one book: sha256 hex of the absolute path.
+ * @param path - normalized absolute `.pdf` path.
+ * @returns 64 lowercase hex characters.
+ */
+export function viewKeyForPath(path) {
+  return createHash('sha256').update(path, 'utf8').digest('hex')
+}
+
+/**
+ * Declarative zod schema for one remembered view.
+ *
+ * The schema is the durable-boundary validator of the storage domain. The
+ * HTTP route validates requests itself, so this stays purely declarative and
+ * needs no zod call at request time.
+ * @param zod - the dynamically imported zod module namespace.
+ * @returns a zod object schema matching the `/view` record contract.
+ */
+export function viewRecordSchema(zod) {
+  return zod.object({
+    path: zod.string().min(1).max(MAX_VIEW_PATH_LENGTH),
+    pdfPage: zod.number().int().min(1).max(MAX_VIEW_PAGE),
+    zoomMode: zod.enum([...VIEW_ZOOM_MODES]),
+    zoomScale: zod.number().min(VIEW_ZOOM_SCALE_MIN).max(VIEW_ZOOM_SCALE_MAX),
+    updatedAt: zod.number().int().nonnegative(),
+  })
+}
+
+/**
+ * Build the `book_reader_views` domain declaration.
+ *
+ * `zod` and the domain helpers are imported dynamically so this module still
+ * loads where the storage packages are absent; callers must handle rejection.
+ * @returns the domain spec understood by `ctx.storageDomain.open`.
+ */
+export async function createViewDomainSpec() {
+  const [{ defineDomain, domainTable }, { z: zod }] = await Promise.all([
+    import('@deepseek-ai/dsh-storage-domain'),
+    import('zod'),
+  ])
+  return defineDomain({
+    name: VIEW_DOMAIN_NAME,
+    version: VIEW_DOMAIN_VERSION,
+    layout: 'single',
+    tables: {
+      [VIEW_TABLE_NAME]: domainTable(viewRecordSchema(zod)),
+    },
+  })
+}
+
+/**
+ * Open the remembered-view domain through the injected `storageDomain` service.
+ * @param storageDomain - the `ctx.storageDomain` facility (DomainFacility).
+ * @returns the opened domain handle; the caller owns `close()`.
+ * @throws when the service, the modules, or `open` itself are unavailable.
+ */
+export async function openViewStateDomain(storageDomain) {
+  if (storageDomain === null || typeof storageDomain !== 'object' || typeof storageDomain.open !== 'function') {
+    throw new TypeError('pdf-reader: storageDomain service is unavailable')
+  }
+  const spec = await createViewDomainSpec()
+  const domain = await storageDomain.open(spec)
+  if (domain === null || typeof domain !== 'object' || typeof domain.table !== 'function') {
+    throw new TypeError('pdf-reader: storageDomain.open returned no domain')
+  }
+  return domain
+}
+
+/** Whether one stored value is a usable view record for the requested path. */
+function isViewRecordFor(record, path) {
+  if (typeof path !== 'string' || path.length === 0 || path.length > MAX_VIEW_PATH_LENGTH) return false
+  if (record === null || typeof record !== 'object') return false
+  if (record.path !== path) return false
+  if (!Number.isInteger(record.pdfPage) || record.pdfPage < 1 || record.pdfPage > MAX_VIEW_PAGE) return false
+  if (record.zoomMode !== 'fit-width' && record.zoomMode !== 'fixed') return false
+  if (typeof record.zoomScale !== 'number' || !Number.isFinite(record.zoomScale)) return false
+  if (record.zoomScale < VIEW_ZOOM_SCALE_MIN || record.zoomScale > VIEW_ZOOM_SCALE_MAX) return false
+  if (!Number.isInteger(record.updatedAt) || record.updatedAt < 0) return false
+  return true
+}
+
+/** Project one stored record to the exact client-facing shape. */
+function publicViewRecord(record) {
+  return {
+    path: record.path,
+    pdfPage: record.pdfPage,
+    zoomMode: record.zoomMode,
+    zoomScale: record.zoomScale,
+    updatedAt: record.updatedAt,
+  }
+}
+
+/**
+ * Delete the least recently updated records once the table exceeds the cap.
+ * Best-effort: pruning never rejects an already-durable write.
+ * @param table - an open domain table handle.
+ */
+async function pruneViewTable(table) {
+  try {
+    if (table.size <= MAX_VIEW_RECORDS) return
+    const excess = table.size - MAX_VIEW_RECORDS
+    const oldest = [...table.entries()]
+      .sort((left, right) => {
+        const leftAt = Number.isFinite(left[1]?.updatedAt) ? left[1].updatedAt : 0
+        const rightAt = Number.isFinite(right[1]?.updatedAt) ? right[1].updatedAt : 0
+        return leftAt - rightAt
+      })
+      .slice(0, excess)
+    for (const [key] of oldest) await table.delete(key)
+  } catch {
+    // The record is already durable; a failed prune is not a failed write.
+  }
+}
+
+/**
+ * Route-facing adapter over the opened `book_reader_views` domain.
+ *
+ * `apply()` attaches the table once storage is open and detaches it on
+ * unload. Until then (or forever, when storage is unavailable) `read()`
+ * answers `null` and `write()` answers `false`, so routes degrade without
+ * throwing. Every failure is contained here and reported to `warn` once.
+ * @param options - warning sink; defaults to `console.warn`.
+ * @returns a mutable adapter read by the route handler.
+ */
+export function createViewStateAdapter({ warn = console.warn } = {}) {
+  let table = null
+  let warned = false
+
+  function warnOnce(message, error) {
+    if (warned) return
+    warned = true
+    try {
+      const detail = error instanceof Error ? `: ${error.message}` : ''
+      warn(`dsh-pdf-reader: ${message}${detail}`)
+    } catch {
+      // A broken logger must not break plugin loading or routing.
+    }
+  }
+
+  return {
+    /** Whether an open domain table is currently attached. */
+    get available() {
+      return table !== null
+    },
+    /** Attach the table of a successfully opened domain. */
+    attach(nextTable) {
+      table = nextTable ?? null
+    },
+    /** Detach on unload so in-flight routes degrade instead of throwing. */
+    detach() {
+      table = null
+    },
+    /** Emit at most one warning for this adapter. */
+    warnOnce,
+    /**
+     * Read the remembered view for one normalized absolute path.
+     * @returns the public record, or `null` when absent/unavailable/invalid.
+     */
+    async read(path) {
+      const current = table
+      if (current === null) return null
+      try {
+        const record = current.get(viewKeyForPath(path))
+        if (!isViewRecordFor(record, path)) return null
+        return publicViewRecord(record)
+      } catch (error) {
+        warnOnce('could not read the remembered page/zoom', error)
+        return null
+      }
+    },
+    /**
+     * Persist one complete view record (key hashed from `record.path`).
+     * @returns true when durable, false when storage is unavailable/failed.
+     */
+    async write(record) {
+      const current = table
+      if (current === null) return false
+      try {
+        const value = {
+          path: record.path,
+          pdfPage: record.pdfPage,
+          zoomMode: record.zoomMode,
+          zoomScale: record.zoomScale,
+          updatedAt: Number.isInteger(record.updatedAt) ? record.updatedAt : Date.now(),
+        }
+        await current.put(viewKeyForPath(value.path), value)
+        await pruneViewTable(current)
+        return true
+      } catch (error) {
+        warnOnce('could not remember the page/zoom', error)
+        return false
+      }
+    },
+  }
+}
+
 /** Normalize unicode dashes so a pasted page range parses. */
 function normalizeDashes(value) {
   return value.replace(/[\u2010-\u2015\u2212]/gu, '-')
@@ -738,12 +965,15 @@ function sameInjectedPage(state, position) {
 }
 
 /**
- * Decide whether this step should receive a reading-position message.
+ * Decide whether this turn should receive a reading-position message.
+ *
+ * One hint per turn at most: the guard is the turn number, not the step, and
+ * the hint is only sent when the reported page changed since the last one.
  * Pure: callers own the state map and the clock.
- * @param options - position, prior state, turn/step, clock, and config.
+ * @param options - position, prior state, turn, clock, and config.
  * @returns `{ inject, reason, nextState }`; `nextState` is unchanged when false.
  */
-export function decideAutoShare({ position, state = INITIAL_AUTO_SHARE_STATE, now, turn, step, config = DEFAULT_CONFIG }) {
+export function decideAutoShare({ position, state = INITIAL_AUTO_SHARE_STATE, now, turn, config = DEFAULT_CONFIG }) {
   const keep = { inject: false, reason: '', nextState: state }
   if (!config.autoShare) return { ...keep, reason: 'disabled' }
   if (position === null || position === undefined) return { ...keep, reason: 'no-position' }
@@ -752,15 +982,11 @@ export function decideAutoShare({ position, state = INITIAL_AUTO_SHARE_STATE, no
     if (typeof position.updatedAt !== 'number') return { ...keep, reason: 'unknown-age' }
     if (now - position.updatedAt > config.autoShareMaxAgeMs) return { ...keep, reason: 'stale' }
   }
-  if (state.lastInjectedAt !== null && state.lastInjectedAt !== undefined) {
+  if (Number.isInteger(turn) && state.lastInjectedTurn === turn) return { ...keep, reason: 'same-turn' }
+  if (config.autoShareMinIntervalMs > 0 && state.lastInjectedAt !== null && state.lastInjectedAt !== undefined) {
     const elapsed = now - state.lastInjectedAt
     if (!(elapsed >= config.autoShareMinIntervalMs)) return { ...keep, reason: 'throttled' }
   }
-  const sameTurn = Number.isInteger(turn) && Number.isInteger(step) && state.lastInjectedTurn === turn
-  if (sameTurn && state.lastInjectedStep === step) return { ...keep, reason: 'same-step' }
-  if (sameTurn && state.lastInjectedStep !== null && step - state.lastInjectedStep < config.autoShareMinSteps) {
-    return { ...keep, reason: 'too-few-steps' }
-  }
   if (
     config.autoSharePageDelta > 1 &&
     state.lastInjectedPdfPage !== null &&
@@ -777,7 +1003,6 @@ export function decideAutoShare({ position, state = INITIAL_AUTO_SHARE_STATE, no
       lastInjectedPdfPage: position.pdfPage,
       lastInjectedAt: now,
       lastInjectedTurn: Number.isInteger(turn) ? turn : null,
-      lastInjectedStep: Number.isInteger(step) ? step : null,
     },
   }
 }
@@ -823,7 +1048,6 @@ export function createAutoShareListener({
       state,
       now: now(),
       turn: payload.turn,
-      step: payload.step,
       config,
     })
     if (!verdict.inject) return decision
@@ -1083,8 +1307,33 @@ function createLazyCore() {
   }
 }
 
+/**
+ * Validate a `/view` book path without touching the filesystem.
+ *
+ * The remembered-view route deliberately does not stat the PDF: the client
+ * may report a state for a book whose preview is still opening, and restoring
+ * a missing book's state is harmless. The shape and size checks still mirror
+ * the rest of the route surface.
+ * @param rawPath - the raw query/body `path` value.
+ * @returns the normalized absolute path, or `null` when invalid.
+ */
+function validateViewPath(rawPath) {
+  if (typeof rawPath !== 'string' || rawPath.length === 0 || rawPath.length > MAX_VIEW_PATH_LENGTH) return null
+  if (!isAbsolute(rawPath)) return null
+  const path = resolvePath(rawPath)
+  if (!/\.pdf$/iu.test(path)) return null
+  return path
+}
+
 /** Build the route handler. Exported so tests can use fake core and stat. */
-export function createRouteHandler({ config, pdfCore, infoCache, positions, statFile = stat }) {
+export function createRouteHandler({
+  config,
+  pdfCore,
+  infoCache,
+  positions,
+  statFile = stat,
+  views = createViewStateAdapter(),
+}) {
   async function loadPositionFor(sessionId, path) {
     if (typeof sessionId === 'string' && sessionId !== '') {
       return positions.forSession(sessionId)
@@ -1294,6 +1543,97 @@ export function createRouteHandler({ config, pdfCore, infoCache, positions, stat
       return
     }
 
+    if (url.pathname === `${ROUTE_PATH}/view`) {
+      const rememberView = config.rememberView !== false
+      if (method === 'GET') {
+        const path = validateViewPath(url.searchParams.get('path') ?? '')
+        if (path === null) {
+          sendJson(response, 400, { ok: false, error: 'invalid-path' })
+          return
+        }
+        // Disabled remembering and unavailable storage both answer the same
+        // non-blocking shape, so restoring a book never fails the preview.
+        if (!rememberView) {
+          sendJson(response, 200, { ok: true, view: null })
+          return
+        }
+        let view = null
+        try {
+          view = await views.read(path)
+        } catch {
+          view = null
+        }
+        sendJson(response, 200, { ok: true, view: view ?? null })
+        return
+      }
+
+      if (method === 'POST') {
+        const contentType = String(request.headers['content-type'] ?? '').toLowerCase()
+        if (!contentType.startsWith('application/json')) {
+          sendJson(response, 415, { ok: false, error: 'unsupported-media-type' })
+          return
+        }
+        let body
+        try {
+          body = await readJsonBody(request, config.maxRouteBodyBytes)
+        } catch (error) {
+          const status = Number.isInteger(error?.status) ? error.status : 400
+          sendJson(response, status, { ok: false, error: error?.error ?? 'invalid-body' })
+          return
+        }
+        const path = validateViewPath(body.path)
+        if (path === null) {
+          sendJson(response, 400, { ok: false, error: 'invalid-path' })
+          return
+        }
+        if (!Number.isInteger(body.pdfPage) || body.pdfPage < 1 || body.pdfPage > MAX_VIEW_PAGE) {
+          sendJson(response, 400, { ok: false, error: 'invalid-page' })
+          return
+        }
+        if (body.zoomMode !== 'fit-width' && body.zoomMode !== 'fixed') {
+          sendJson(response, 400, { ok: false, error: 'invalid-zoom-mode' })
+          return
+        }
+        if (
+          typeof body.zoomScale !== 'number' ||
+          !Number.isFinite(body.zoomScale) ||
+          body.zoomScale < VIEW_ZOOM_SCALE_MIN ||
+          body.zoomScale > VIEW_ZOOM_SCALE_MAX
+        ) {
+          sendJson(response, 400, { ok: false, error: 'invalid-zoom-scale' })
+          return
+        }
+        // Remembering may be disabled while previews still talk to the route:
+        // validation stays complete, the write becomes a deliberate no-op.
+        if (!rememberView) {
+          sendJson(response, 200, { ok: true })
+          return
+        }
+        let stored = false
+        try {
+          stored =
+            (await views.write({
+              path,
+              pdfPage: body.pdfPage,
+              zoomMode: body.zoomMode,
+              zoomScale: body.zoomScale,
+              updatedAt: Date.now(),
+            })) === true
+        } catch {
+          stored = false
+        }
+        if (!stored) {
+          sendJson(response, 503, { ok: false, error: 'storage-unavailable' })
+          return
+        }
+        sendJson(response, 200, { ok: true })
+        return
+      }
+
+      sendJson(response, 405, { ok: false, error: 'method-not-allowed' })
+      return
+    }
+
     sendJson(response, 404, { ok: false, error: 'not-found' })
   }
 
@@ -1339,8 +1679,8 @@ export function trimPageText(raw, maxChars) {
   return { text: normalized.slice(0, maxChars), truncated: true, unavailable: false }
 }
 
-/** Register `pdf_info`, `pdf_search`, and `pdf_current_page`. */
-export function createCheapTools({ defineTool: makeTool, config, core, infoCache, positions, statFile = stat }) {
+/** Register `pdf_info` and `pdf_search`. */
+export function createCheapTools({ defineTool: makeTool, config, core, infoCache, statFile = stat }) {
   return [
     makeTool({
       name: 'pdf_info',
@@ -1522,83 +1862,6 @@ export function createCheapTools({ defineTool: makeTool, config, core, infoCache
         locations: [{ path: args.path }],
       }),
     }),
-
-    makeTool({
-      name: 'pdf_current_page',
-      description:
-        'The page the user is reading in the preview, plus its section. Text only, cheap.',
-      parameters: {
-        path: {
-          type: 'string',
-          description: 'Optional expected PDF path. When supplied and it differs from the reported book, returns current:null.',
-        },
-      },
-      output: {
-        schema: {
-          type: 'object',
-          additionalProperties: false,
-          properties: {
-            current: {
-              oneOf: [
-                { type: 'null' },
-                {
-                  type: 'object',
-                  additionalProperties: false,
-                  properties: {
-                    path: { type: 'string', required: true },
-                    book: { type: 'string', required: true },
-                    pdfPage: { type: 'integer', required: true },
-                    printedPage: { ...PRINTED_PAGE_SCHEMA, required: true },
-                    pageNumberMode: { type: 'string', enum: ['printed', 'pdf'], required: true },
-                    section: { ...SECTION_SCHEMA },
-                    sectionTrail: { type: 'array', items: { type: 'string' } },
-                    updatedAt: { type: 'integer', required: true },
-                  },
-                },
-              ],
-              required: true,
-            },
-            reason: { type: 'string' },
-          },
-        },
-        render: (_args, value) => [{ type: 'text', text: JSON.stringify(value) }],
-        presentationMeta: (_args, value) => ({ path: value?.current?.path }),
-      },
-      isConcurrencySafe: () => true,
-      async execute(args, exec) {
-        const sessionId = exec?.agent?.session?.id
-        const position = typeof sessionId === 'string' ? positions.forSession(sessionId) : undefined
-        if (position === undefined) return { current: null, reason: 'no-reading-position' }
-        if (args.path !== undefined) {
-          const expected = resolveToolPath(args.path, exec)
-          if (expected !== position.path) return { current: null, reason: 'path-mismatch' }
-        }
-        let info = null
-        try {
-          info = (await infoCache.load(position.path)).info
-        } catch {
-          info = null
-        }
-        const trail = info === null ? [] : sectionTrailForPage(info.outline, position.pdfPage)
-        const printedPage = printedPageFor(info, position.pdfPage, position.printedPage)
-        return {
-          current: {
-            path: position.path,
-            book: titleFromPath(position.path),
-            pdfPage: position.pdfPage,
-            printedPage,
-            pageNumberMode: typeof printedPage === 'number' ? 'printed' : 'pdf',
-            ...(trail.length === 0 ? {} : { section: trail[trail.length - 1], sectionTrail: trail.map((entry) => entry.title) }),
-            updatedAt: position.updatedAt,
-          },
-        }
-      },
-      presentCall: () => ({
-        card: 'generic',
-        title: 'Current PDF page',
-        kind: 'read',
-      }),
-    }),
   ]
 }
 
@@ -1892,6 +2155,7 @@ export function apply(ctx, rawConfig) {
     limit: config.infoCacheSize,
   })
   const positions = createPositionStore()
+  const views = createViewStateAdapter()
 
   const routeHandler = createRouteHandler({
     config,
@@ -1899,6 +2163,7 @@ export function apply(ctx, rawConfig) {
     infoCache,
     positions,
     statFile: stat,
+    views,
   })
   ctx.effect(
     () => ctx.webServer.register({ kind: 'prefix', path: ROUTE_PATH, handler: routeHandler }),
@@ -1910,7 +2175,6 @@ export function apply(ctx, rawConfig) {
     config,
     core,
     infoCache,
-    positions,
     statFile: stat,
   })) {
     ctx.tools.register(tool)
@@ -1929,6 +2193,53 @@ export function apply(ctx, rawConfig) {
     )
   })
 
+  if (config.rememberView) {
+    ctx.inject(['storageDomain'], (storageCtx) => {
+      let disposed = false
+      let domain = null
+
+      async function closeDomain() {
+        const handle = domain
+        domain = null
+        if (handle === null) return
+        try {
+          await handle.close()
+        } catch (error) {
+          views.warnOnce('remembered page/zoom storage did not close cleanly', error)
+        }
+      }
+
+      // Opening is asynchronous while the route is already answering: the
+      // adapter stays unavailable until attach(), and reverts to unavailable
+      // on unload. Every failure leaves the feature disabled, never thrown.
+      const opening = (async () => {
+        try {
+          domain = await openViewStateDomain(storageCtx.storageDomain)
+        } catch (error) {
+          views.warnOnce('remembered page/zoom storage is unavailable', error)
+          return
+        }
+        if (disposed) {
+          await closeDomain()
+          return
+        }
+        try {
+          views.attach(domain.table(VIEW_TABLE_NAME))
+        } catch (error) {
+          views.warnOnce('remembered page/zoom storage is unavailable', error)
+          await closeDomain()
+        }
+      })()
+
+      return async () => {
+        disposed = true
+        views.detach()
+        await opening
+        await closeDomain()
+      }
+    })
+  }
+
   if (config.autoShare) {
     const listener = createAutoShareListener({ config, positions, infoCache })
     ctx.on('agent/pre-step', listener, { prepend: true })