rasler 0.1.0 → 0.2.0

package/src/routes/operator.js

@@ -1,14 +1,16 @@
 import { Router, json as expressJson } from 'express';
 import multer from 'multer';
-import { CarReader } from '@ipld/car';
-import { base32 } from 'multiformats/bases/base32';
-import * as dagCbor from '@ipld/dag-cbor';
-import { computeDataCid, computeMaslCid, isMaslCid } from '../crypto/cid.js';
-import { createSingleMasl, parseMasl, maslLinkedCids, maslIsBundle } from '../masl/document.js';
 import { realpathSync } from 'fs';
 import { requireApiSecret } from '../middleware/auth.js';
 import { makeOperatorCors } from '../middleware/cors.js';
 import { normalizeMountPath } from '../util/normalizeMountPath.js';
+import {
+  handleUpload, handlePin, handleUnpin,
+  handleListContent, handleGetContent, handleDeleteContent,
+  handleGetStatus,
+} from '../handlers/operator.js';
+import { isMaslCid } from '../crypto/cid.js';
+import { parseMasl, maslIsBundle } from '../masl/document.js';
 
 const upload = multer({ storage: multer.memoryStorage() });
 
@@ -49,62 +51,6 @@ const upload = multer({ storage: multer.memoryStorage() });
  *           type: string
  */
 
-function isCarFile(file) {
-  return (
-    file.mimetype === 'application/vnd.ipld.car' ||
-    file.mimetype === 'application/car' ||
-    file.originalname?.toLowerCase().endsWith('.car')
-  );
-}
-
-// Extract, verify, and return all blocks from a CAR file.
-// Returns { maslCid, blocks: Map<cidStr, Uint8Array> } or throws with { status, error, ...extra }.
-async function readCar(fileBuffer) {
-  let reader;
-  try {
-    reader = await CarReader.fromBytes(fileBuffer);
-  } catch {
-    throw { status: 400, error: 'Invalid CAR file' };
-  }
-
-  const blocks = new Map();
-  try {
-    for await (const { cid, bytes } of reader.blocks()) {
-      const cidStr = cid.toString(base32);
-      const isMasl = cid.code === dagCbor.code;
-      const actual = isMasl ? await computeMaslCid(bytes) : await computeDataCid(bytes);
-      if (actual !== cidStr) throw { status: 400, error: `CID mismatch for block ${cidStr}` };
-      blocks.set(cidStr, bytes);
-    }
-  } catch (err) {
-    if (err.status) throw err;
-    throw { status: 400, error: `Failed to read CAR blocks: ${err.message}` };
-  }
-
-  const roots = await reader.getRoots();
-  const maslRoot = roots.find(cid => cid.code === dagCbor.code);
-  if (!maslRoot) throw { status: 400, error: 'CAR root must be a MASL CID (dag-cbor codec)' };
-
-  const maslCid = maslRoot.toString(base32);
-  if (!blocks.has(maslCid)) throw { status: 400, error: 'MASL root block is missing from the CAR' };
-
-  let doc;
-  try { doc = parseMasl(blocks.get(maslCid)); } catch {
-    throw { status: 400, error: 'Failed to parse MASL document' };
-  }
-
-  const links = maslLinkedCids(doc);
-  const missing = links.filter(l => !blocks.has(l.cid)).map(l => l.cid);
-  if (missing.length > 0) throw { status: 400, error: 'CAR is missing linked data CIDs', missing };
-
-  return { maslCid, blocks, links };
-}
-
-// Base operator router: content management and node status (base fields).
-// Auth and CORS are applied here, which also protects any operator extension router
-// routes — Express runs router.use middleware for all requests entering the router
-// even when no route matches, so auth is enforced before the request falls through
-// to the overlay extension.
 export function makeOperatorRouter({ store, selfOrigin, apiSecret, corsOrigins = [], staticRoots = [], mountPoints = [] }) {
   const router = Router();
   if (corsOrigins.length > 0) router.use(makeOperatorCors(corsOrigins));
@@ -163,71 +109,13 @@ export function makeOperatorRouter({ store, selfOrigin, apiSecret, corsOrigins =
    *               $ref: '#/components/schemas/Error'
    */
   router.post('/upload', upload.array('files'), async (req, res) => {
-    const files = req.files;
-    if (!files || files.length === 0) {
-      return res.status(400).json({ error: 'No files provided' });
-    }
-
-    const uploads = [];
-
-    for (const file of files) {
-      if (isCarFile(file)) {
-        let parsed;
-        try {
-          parsed = await readCar(file.buffer);
-        } catch (err) {
-          return res.status(err.status ?? 400).json(
-            err.missing ? { error: err.error, missing: err.missing } : { error: err.error }
-          );
-        }
-
-        const { maslCid, blocks, links } = parsed;
-        const totalBytes = [...blocks.values()].reduce((n, b) => n + b.length, 0);
-        if (store.getPoolAvailable() < totalBytes) {
-          if (!store.evictIfNeeded(totalBytes)) {
-            return res.status(507).json({ error: 'Insufficient storage' });
-          }
-        }
-
-        store.putContent(maslCid, blocks.get(maslCid));
-        for (const link of links) {
-          store.putContent(link.cid, blocks.get(link.cid), { maslCid });
-        }
-        uploads.push({ filename: file.originalname, maslCid });
-
-      } else {
-        const bytes = file.buffer;
-        const name = file.originalname ?? 'upload';
-        const type = file.mimetype ?? 'application/octet-stream';
-        const size = bytes.length;
-
-        let dataCid;
-        try { dataCid = await computeDataCid(bytes); } catch {
-          return res.status(500).json({ error: `CID computation failed for ${name}` });
-        }
-
-        let maslResult;
-        try {
-          maslResult = await createSingleMasl({ name, type, size, dataCid });
-        } catch {
-          return res.status(500).json({ error: `MASL creation failed for ${name}` });
-        }
-
-        const { cborBytes, maslCid } = maslResult;
-        const totalBytes = bytes.length + cborBytes.length;
-        if (store.getPoolAvailable() < totalBytes) {
-          if (!store.evictIfNeeded(totalBytes)) {
-            return res.status(507).json({ error: 'Insufficient storage' });
-          }
-        }
-
-        store.putContent(dataCid, bytes, { maslCid });
-        store.putContent(maslCid, cborBytes);
-        uploads.push({ filename: name, maslCid });
-      }
-    }
-
-    return res.status(200).json({ uploads });
+    const files = (req.files ?? []).map(f => ({
+      name: f.originalname,
+      type: f.mimetype,
+      bytes: f.buffer,
+    }));
+    const result = await handleUpload(store, files);
+    return res.status(result.status).json(result.body);
   });
 
   /**
@@ -280,36 +168,10 @@ export function makeOperatorRouter({ store, selfOrigin, apiSecret, corsOrigins =
    *             schema:
    *               $ref: '#/components/schemas/Error'
    */
-  router.post('/pin', (req, res) => {
+  router.post('/pin', async (req, res) => {
     const { cids } = req.body ?? {};
-    if (!Array.isArray(cids) || cids.length === 0) {
-      return res.status(400).json({ error: 'cids must be a non-empty array' });
-    }
-
-    const pinned = new Set();
-
-    for (const cid of cids) {
-      const entry = store.getContent(cid);
-      if (!entry) return res.status(404).json({ error: `CID not found: ${cid}` });
-
-      store.setPinned(cid, true);
-      pinned.add(cid);
-
-      const maslCid = entry.meta.masl_cid;
-      if (maslCid && store.hasContent(maslCid)) {
-        store.setPinned(maslCid, true);
-        pinned.add(maslCid);
-      }
-
-      for (const row of store.listContent()) {
-        if (row.masl_cid === cid) {
-          store.setPinned(row.cid, true);
-          pinned.add(row.cid);
-        }
-      }
-    }
-
-    return res.status(200).json({ pinned: [...pinned] });
+    const result = await handlePin(store, cids);
+    return res.status(result.status).json(result.body);
   });
 
   /**
@@ -343,23 +205,9 @@ export function makeOperatorRouter({ store, selfOrigin, apiSecret, corsOrigins =
    *       '401':
    *         description: Missing or invalid operator secret
    */
-  router.delete('/pin/:cid', (req, res) => {
-    const { cid } = req.params;
-    const meta = store.getContent(cid)?.meta;
-
-    if (!meta) return res.status(200).json({ status: 'not found' });
-
-    store.setPinned(cid, false);
-
-    if (meta.masl_cid && store.hasContent(meta.masl_cid)) {
-      store.setPinned(meta.masl_cid, false);
-    }
-
-    for (const row of store.listContent()) {
-      if (row.masl_cid === cid) store.setPinned(row.cid, false);
-    }
-
-    return res.status(200).json({ status: 'ok' });
+  router.delete('/pin/:cid', async (req, res) => {
+    const result = await handleUnpin(store, req.params.cid);
+    return res.status(result.status).json(result.body);
   });
 
   /**
@@ -405,25 +253,11 @@ export function makeOperatorRouter({ store, selfOrigin, apiSecret, corsOrigins =
    *       '401':
    *         description: Missing or invalid operator secret
    */
-  router.get('/content', (req, res) => {
+  router.get('/content', async (req, res) => {
     const limit = Math.min(200, Math.max(1, parseInt(req.query.limit ?? '50', 10) || 50));
     const cursor = req.query.cursor ?? null;
-
-    const items = store.listContentPage(limit, cursor);
-    const total = store.countContent();
-    const nextCursor = items.length === limit ? items[items.length - 1].cid : null;
-
-    return res.status(200).json({
-      total,
-      items: items.map(row => ({
-        cid: row.cid,
-        maslCid: row.masl_cid ?? null,
-        size: row.size,
-        pinned: row.pinned === 1,
-        lastRequested: row.last_requested ?? null,
-      })),
-      nextCursor,
-    });
+    const result = await handleListContent(store, limit, cursor);
+    return res.status(result.status).json(result.body);
   });
 
   /**
@@ -487,45 +321,14 @@ export function makeOperatorRouter({ store, selfOrigin, apiSecret, corsOrigins =
    *             schema:
    *               $ref: '#/components/schemas/Error'
    */
-  router.get('/content/:cid', (req, res) => {
-    const { cid } = req.params;
-    const meta = store.getContentMeta(cid);
-    if (!meta) return res.status(404).json({ error: 'CID not found' });
-    return res.status(200).json({
-      cid: meta.cid,
-      maslCid: meta.masl_cid ?? null,
-      size: meta.size,
-      pinned: meta.pinned === 1,
-      lastRequested: meta.last_requested ?? null,
-    });
+  router.get('/content/:cid', async (req, res) => {
+    const result = await handleGetContent(store, req.params.cid);
+    return res.status(result.status).json(result.body);
   });
 
-  router.delete('/content/:cid', (req, res) => {
-    const { cid } = req.params;
-    const entry = store.getContent(cid);
-    if (!entry) return res.status(404).json({ error: 'CID not found' });
-
-    const deleted = [];
-
-    if (isMaslCid(cid)) {
-      let linkedCids = [];
-      try {
-        linkedCids = maslLinkedCids(parseMasl(entry.bytes)).map(l => l.cid);
-      } catch {
-        // Unparseable MASL — fall through and delete just the MASL itself
-      }
-      for (const linkedCid of linkedCids) {
-        if (store.hasContent(linkedCid)) {
-          store.deleteContent(linkedCid);
-          deleted.push(linkedCid);
-        }
-      }
-    }
-
-    store.deleteContent(cid);
-    deleted.push(cid);
-
-    return res.status(200).json({ deleted });
+  router.delete('/content/:cid', async (req, res) => {
+    const result = await handleDeleteContent(store, req.params.cid);
+    return res.status(result.status).json(result.body);
   });
 
   /**
@@ -618,14 +421,12 @@ export function makeOperatorRouter({ store, selfOrigin, apiSecret, corsOrigins =
     const result = [];
     const seen = new Set();
 
-    // Runtime entries first (they take serving priority).
     for (const mp of store.runtimeMountPoints) {
       const key = `${mp.hostname}|${mp.prefix}`;
       seen.add(key);
       result.push({ hostname: mp.hostname || null, mountPath: mp.prefix || '/', path: null, maslCid: mp.maslCid, source: 'runtime' });
     }
 
-    // Config-backed entries not overridden by a runtime mapping at the same (hostname, prefix).
     for (const mp of mountPoints) {
       const key = `${mp.hostname}|${mp.prefix}`;
       if (seen.has(key)) continue;
@@ -831,7 +632,7 @@ export function makeOperatorRouter({ store, selfOrigin, apiSecret, corsOrigins =
     return normalizeMountPath(req.path.slice('/mount-points/'.length + hostname.length) || '/');
   }
 
-  function handleMountPointPut(req, res) {
+  async function handleMountPointPut(req, res) {
     const { hostname: hostnameParam } = req.params;
     const hostname = hostnameParam === '-' ? '' : hostnameParam;
     const prefix = getMountPrefix(req);
@@ -842,10 +643,8 @@ export function makeOperatorRouter({ store, selfOrigin, apiSecret, corsOrigins =
     if (!isMaslCid(maslCid)) {
       return res.status(400).json({ error: 'maslCid must be a dag-cbor CID' });
     }
-    const entry = store.getContent(maslCid);
-    if (!entry) {
-      return res.status(404).json({ error: 'CID not held locally' });
-    }
+    const entry = await store.getContent(maslCid);
+    if (!entry) return res.status(404).json({ error: 'CID not held locally' });
     let doc;
     try { doc = parseMasl(entry.bytes); } catch {
       return res.status(400).json({ error: 'Failed to parse MASL document' });
@@ -853,12 +652,12 @@ export function makeOperatorRouter({ store, selfOrigin, apiSecret, corsOrigins =
     if (!maslIsBundle(doc)) {
       return res.status(400).json({ error: 'maslCid must refer to a bundle MASL' });
     }
-    store.setPinned(maslCid, true);
-    store.setMountPoint(hostname, prefix, maslCid);
+    await store.setPinned(maslCid, true);
+    await store.setMountPoint(hostname, prefix, maslCid);
     return res.status(200).json({ hostname: hostname || null, mountPath: prefix || '/', maslCid });
   }
 
-  function handleMountPointDelete(req, res) {
+  async function handleMountPointDelete(req, res) {
     const { hostname: hostnameParam } = req.params;
     const hostname = hostnameParam === '-' ? '' : hostnameParam;
     const prefix = getMountPrefix(req);
@@ -866,7 +665,7 @@ export function makeOperatorRouter({ store, selfOrigin, apiSecret, corsOrigins =
     if (!exists) {
       return res.status(404).json({ error: 'Runtime virtual host mapping not found' });
     }
-    store.deleteMountPoint(hostname, prefix);
+    await store.deleteMountPoint(hostname, prefix);
     return res.status(200).json({ status: 'ok' });
   }
 
@@ -918,25 +717,14 @@ export function makeOperatorRouter({ store, selfOrigin, apiSecret, corsOrigins =
    *       '401':
    *         description: Missing or invalid operator secret
    */
-  // Base /status: writes local fields and falls through to overlay/terminator.
-  router.get('/status', (req, res, next) => {
-    res.locals.status = {
-      origin: selfOrigin,
-      storage: {
-        totalCapacity: store.totalCapacity,
-        poolUsed: store.getPoolUsed(),
-        poolAvailable: store.getPoolAvailable(),
-        pinnedUsed: store.getPinnedUsed(),
-        pinnedCount: store.countPinned(),
-      },
-    };
+  router.get('/status', async (req, res, next) => {
+    res.locals.status = await handleGetStatus(store, selfOrigin);
     next();
   });
 
   return router;
 }
 
-// Terminator: sends the /status response assembled by base and overlay handlers.
 export function makeOperatorStatusTerminator() {
   const router = Router();
   router.get('/status', (req, res) => res.status(200).json(res.locals.status));

package/src/routes/rasl.js

@@ -1,122 +1,34 @@
 import { Router } from 'express';
-import {
-  parseMasl,
-  maslContentHeaders,
-  maslIsBundle,
-  resolveBundleEntry,
-  maslLinkedCids,
-  findBundleHeadersForCid,
-} from '../masl/document.js';
-import { isMaslCid, cidToUnencodedDigest } from '../crypto/cid.js';
+import { resolveRaslRequest } from '../handlers/rasl.js';
 
-// Determine the path suffix after the CID in the request URL.
-// Returns '' for the path-free form (no trailing slash or path segment),
-// '/' for a trailing-slash-only request, '/style.css' for non-root, etc.
-// Using req.path directly avoids the ambiguity in how Express 5 populates
-// req.params.path for trailing-slash-only URLs.
 function getPathAfterCid(req, cid) {
   const cidPrefix = '/.well-known/rasl/' + cid;
   return req.path.startsWith(cidPrefix) ? req.path.slice(cidPrefix.length) : '';
 }
 
-// Streams a data CID's bytes to the response. Uses getContentStream so that
-// static (filesystem-backed) entries are served without copying to memory.
-function pipeContent(store, cid, res, _next) {
-  const result = store.getContentStream(cid);
-  if (!result) return res.status(502).json({ error: 'Content unavailable' });
-  res.set('content-length', String(result.meta.size));
-  res.status(200);
-  result.stream.pipe(res);
-}
-
-// Base RASL router: serves locally held content. On miss, calls next() so
-// overlay routing middleware (or a 404 terminator) can take over.
 export function makeRaslRouter({ store }) {
   const router = Router();
 
-  function handle(req, res, next) {
+  async function handle(req, res, next) {
     const { cid } = req.params;
-    const meta = store.getContentMeta(cid);
-    if (!meta) return next();
+    const pathSuffix = getPathAfterCid(req, cid);
+    const result = await resolveRaslRequest(store, cid, pathSuffix);
 
-    store.recordRequest(cid);
+    if (result === null) return next();
 
-    const afterCid = getPathAfterCid(req, cid);
-    const isPathFree = afterCid === '';
-
-    if (isPathFree) {
-      // Path-free form: always raw bytes. No MASL path resolution.
-      if (isMaslCid(cid)) {
-        // MASL CIDs are always in the blob store (never static).
-        const entry = store.getContent(cid);
-        if (!entry) return next();
-        res.set({ 'content-type': 'application/octet-stream' });
-        res.set('unencoded-digest', cidToUnencodedDigest(cid));
-        return res.status(200).send(entry.bytes);
-      }
-      // Data CID: surface the MASL-derived Content-Type when available.
-      // This is content negotiation, not path resolution. For bundle MASLs
-      // (used by static roots), the content-type lives on the resource entry,
-      // not the top-level document.
-      let headers = { 'content-type': 'application/octet-stream' };
-      if (meta.masl_cid) {
-        const maslEntry = store.getContent(meta.masl_cid);
-        if (maslEntry) {
-          try {
-            const doc = parseMasl(maslEntry.bytes);
-            headers = maslIsBundle(doc)
-              ? (findBundleHeadersForCid(doc, cid) ?? headers)
-              : maslContentHeaders(doc);
-          } catch { /* ignore */ }
-        }
-      }
-      res.set(headers);
-      res.set('unencoded-digest', cidToUnencodedDigest(cid));
-      return pipeContent(store, cid, res, next);
+    if (result.stream) {
+      res.set(result.headers);
+      res.set('content-length', String(result.size));
+      res.status(result.status);
+      return result.stream.pipe(res);
     }
 
-    // Path-bearing form: resolve path against MASL document structure.
-    // afterCid always begins with '/', e.g. '/', '/style.css', '/a/b/c.html'.
-    const path = afterCid;
-
-    if (isMaslCid(cid)) {
-      const entry = store.getContent(cid);
-      if (!entry) return next();
-      let doc;
-      try { doc = parseMasl(entry.bytes); } catch {
-        return res.status(500).json({ error: 'Invalid MASL document' });
-      }
-
-      if (maslIsBundle(doc)) {
-        // Bundle Mode: look up path in the resources map.
-        const resolved = resolveBundleEntry(doc, path);
-        if (!resolved) return res.status(404).json({ error: 'Not found' });
-        store.recordRequest(resolved.cid);
-        res.set(resolved.headers);
-        res.set('unencoded-digest', cidToUnencodedDigest(resolved.cid));
-        return pipeContent(store, resolved.cid, res, next);
-      }
-
-      // Single Mode: has src but no resources. Only path '/' is valid.
-      const links = maslLinkedCids(doc);
-      const srcCid = links.length > 0 ? links[0].cid : null;
-      if (srcCid) {
-        if (path !== '/') return res.status(404).json({ error: 'Not found' });
-        store.recordRequest(srcCid);
-        res.set(maslContentHeaders(doc));
-        res.set('unencoded-digest', cidToUnencodedDigest(srcCid));
-        return pipeContent(store, srcCid, res, next);
-      }
-
-      // Other DRISL map (neither resources nor src): fall through to non-MASL handling.
+    if (result.bytes) {
+      res.set(result.headers);
+      return res.status(result.status).send(result.bytes);
     }
 
-    // Non-MASL CID (or unrecognised DRISL map): only path '/' returns raw bytes;
-    // any other path is not found.
-    if (path !== '/') return res.status(404).json({ error: 'Not found' });
-    res.set({ 'content-type': 'application/octet-stream' });
-    res.set('unencoded-digest', cidToUnencodedDigest(cid));
-    return pipeContent(store, cid, res, next);
+    return res.status(result.status).json(result.body);
   }
 
   router.get('/.well-known/rasl/:cid', handle);
@@ -127,7 +39,6 @@ export function makeRaslRouter({ store }) {
   return router;
 }
 
-// Terminator: turns a fully-fallthrough RASL request into a 404.
 export function makeRaslNotFoundHandler() {
   const router = Router();
   const notFound = (req, res) => res.status(404).json({ error: 'Not found' });

package/src/static.js

@@ -4,24 +4,16 @@ import micromatch from 'micromatch';
 import { computeDataCid } from './crypto/cid.js';
 import { createBundleMasl, parseMasl } from './masl/document.js';
 import { mimeType } from './util/mime.js';
-import {
-  dbPutStaticContent,
-  dbGetContentBySourcePath,
-  dbListStaticContent,
-  dbDeleteContent,
-} from './storage/db.js';
-
-// Walks the prev chain from prevMaslCid (depth 2 relative to the new MASL)
-// and unpins any entry whose depth exceeds maxHistory.
+
 function pruneHistory(store, prevMaslCid, maxHistory) {
   let cid = prevMaslCid;
-  let depth = 2; // new MASL is depth 1, its prev is depth 2
+  let depth = 2;
   while (cid) {
-    const entry = store.getContent(cid);
+    const entry = store.db.getContent(cid);
     if (!entry) break;
-    if (depth > maxHistory) store.setPinned(cid, false);
+    if (depth > maxHistory) store.db.setPinned(cid, false);
     try {
-      cid = parseMasl(entry.bytes).prev?.$link ?? null;
+      cid = parseMasl(store.blobs.get(cid, entry))?.prev?.$link ?? null;
     } catch { break; }
     depth++;
   }
@@ -39,19 +31,6 @@ async function* walkDir(dir, rootDir, ignore) {
   }
 }
 
-// Scans rootPath, registers each file's CID in the store's DB (with
-// source_path set), and — when generateMasl is true (the default) —
-// generates a bundle MASL for the root and returns its CID. Files are never
-// copied to the blob store. Symlinks that resolve outside the root are
-// silently skipped.
-//
-// When generateMasl is false, files are stored as plain blobs only (no MASL
-// document is created and null is returned). This is useful for roots that
-// exist purely to make a set of named blobs available by CID.
-//
-// On repeated calls, files whose size and mtime match the stored values are
-// not re-read or re-hashed. DB entries for files that no longer exist are
-// removed.
 export async function indexStaticRoot(rootPath, store, { maxHistory = null, ignore = [], generateMasl = true } = {}) {
   const realRoot = await realpath(rootPath);
   const fileInfos = [];
@@ -68,8 +47,7 @@ export async function indexStaticRoot(rootPath, store, { maxHistory = null, igno
     const { size, mtimeMs } = await stat(realFile);
     const mtime = Math.round(mtimeMs);
 
-    // Cache hit: size and mtime both match → file unchanged → reuse stored CID.
-    const existing = dbGetContentBySourcePath(store.db, realFile);
+    const existing = store.db.getContentBySourcePath(realFile);
     let cid;
     if (existing && existing.size === size && existing.source_mtime === mtime) {
       cid = existing.cid;
@@ -84,41 +62,36 @@ export async function indexStaticRoot(rootPath, store, { maxHistory = null, igno
     fileInfos.push({ realPath: realFile, relPath, cid, size, mtime, contentType });
   }
 
-  // Remove DB entries for files deleted since the last startup.
-  for (const entry of dbListStaticContent(store.db)) {
+  for (const entry of store.db.listStaticContent()) {
     if (entry.source_path?.startsWith(realRoot + sep) && !visitedPaths.has(entry.source_path)) {
       changed = true;
-      dbDeleteContent(store.db, entry.cid);
+      store.db.deleteContent(entry.cid);
     }
   }
 
   if (fileInfos.length === 0) return null;
 
   if (!generateMasl) {
-    // Nothing changed: files are already registered in the DB — no work needed.
     if (!changed) return null;
     const seen = new Set();
     for (const { cid, size, mtime, realPath } of fileInfos) {
       if (!seen.has(cid)) {
         seen.add(cid);
-        dbPutStaticContent(store.db, cid, { maslCid: null, size, sourcePath: realPath, sourceMtime: mtime });
+        store.db.putStaticContent(cid, { maslCid: null, size, sourcePath: realPath, sourceMtime: mtime });
       }
     }
     return null;
   }
 
-  // Find the existing MASL CID for this root (if any) to link as prev.
-  const prevEntry = dbListStaticContent(store.db)
+  const prevEntry = store.db.listStaticContent()
     .find(e => e.source_path?.startsWith(realRoot + sep));
   const prevMaslCid = prevEntry?.masl_cid ?? null;
 
-  // Nothing changed — reuse the existing MASL rather than generating a new one.
   if (!changed && prevMaslCid) {
     store.staticRootMasls.set(realRoot, prevMaslCid);
     return prevMaslCid;
   }
 
-  // Sort for deterministic MASL CIDs across restarts.
   fileInfos.sort((a, b) => a.relPath.localeCompare(b.relPath));
 
   const resources = [];
@@ -133,7 +106,8 @@ export async function indexStaticRoot(rootPath, store, { maxHistory = null, igno
   const name = basename(realRoot);
   const { cborBytes, maslCid } = await createBundleMasl({ name, resources, prevMaslCid });
 
-  store.putContent(maslCid, Buffer.from(cborBytes), { pinned: true });
+  store.db.putContent(maslCid, { maslCid: null, size: cborBytes.length, pinned: true, lastRequested: null });
+  store.blobs.put(maslCid, Buffer.from(cborBytes));
   store.staticRootMasls.set(realRoot, maslCid);
 
   if (maxHistory != null && prevMaslCid) pruneHistory(store, prevMaslCid, maxHistory);
@@ -142,7 +116,7 @@ export async function indexStaticRoot(rootPath, store, { maxHistory = null, igno
   for (const { cid, size, mtime, realPath } of fileInfos) {
     if (!seen.has(cid)) {
       seen.add(cid);
-      dbPutStaticContent(store.db, cid, { maslCid, size, sourcePath: realPath, sourceMtime: mtime });
+      store.db.putStaticContent(cid, { maslCid, size, sourcePath: realPath, sourceMtime: mtime });
     }
   }