@o-a/cms-agent 0.1.7 → 0.2.1

package/dist/search/rebuild-index.js

@@ -1,10 +1,20 @@
-import { mkdirSync, readFileSync, unlinkSync } from 'node:fs';
+import { randomUUID } from 'node:crypto';
+import { mkdirSync, readFileSync, renameSync, unlinkSync } from 'node:fs';
 import { join } from 'node:path';
+import { setImmediate as yieldToEventLoop } from 'node:timers/promises';
 import { listFilesRecursively } from "../services/fs-walk.js";
-import { postPathToUrl } from "../services/post-urls.js";
+import { loadThemeSchemas } from "../services/theme-schemas.js";
 import { pagePathToUrl } from "../services/urls.js";
 import { enqueue } from "../services/write-queue.js";
 import { openNodeSqliteDriver } from "./drivers/node-sqlite-driver.js";
+// How many content files the rebuild loop processes between yields to
+// the event loop (see the yield's own comment below for why this
+// exists at all). Large enough that setImmediate's own overhead is
+// negligible next to the real per-file work (a parse plus several
+// SQLite inserts); small enough that no single slice runs long enough
+// to meaningfully stall another request. Not a config knob - no
+// evidence yet this needs to be tunable per site.
+const YIELD_EVERY_N_FILES = 25;
 function collectStrings(value, out) {
     if (typeof value === 'string') {
         out.push(value);
@@ -39,73 +49,256 @@ function extractBody(instances) {
     walk(instances);
     return strings.join(' ');
 }
-async function rebuildIndexJob(config) {
-    mkdirSync(config.dataRoot, { recursive: true });
-    // Delete-then-recreate, not existsSync-then-unlinkSync (a TOCTOU
-    // gap): this makes every rebuild start from a genuinely clean file,
-    // which is also what makes "delete the index and rebuild produces
-    // equivalent results" (G2) a structural consequence rather than a
-    // special case.
+// Epoch milliseconds for a date-like string - undefined if it doesn't
+// parse, so a malformed date is silently skipped rather than indexed
+// as a nonsensical NaN row (the same "malformed input skipped, not a
+// rebuild failure" tolerance every other part of this pipeline
+// already has for a bad file or a missing theme type).
+function parseDateValue(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+// Turns one raw value into ApiFieldRow entries for a given field key -
+// shared by both theme-flagged fields (extractInstanceApiFields below)
+// and the built-in post envelope fields (extractEnvelopeApiFields),
+// since both need the identical "what does this value actually mean
+// for indexing" logic. Three shapes:
+// - an array: one row per scalar element, all under the same
+//   fieldKey (e.g. a post's own "tags") - a plain "eq" filter then
+//   matches via the exact same mechanism a single-valued field already
+//   uses, no separate array-aware query logic needed anywhere else.
+// - a date-like string (isDateField true - a theme field schema'd
+//   "type": "string", "format": "date", reusing the existing format
+//   convention, or the post envelope's own publishDate): stored as an
+//   epoch-ms number in valueNumber, not text, so range operators work
+//   on it through the same numeric path a flagged price field uses.
+// - a plain scalar (string/number/boolean): stored in its own typed
+//   column. Anything else (object, null, undefined) has nothing
+//   sensible to store or compare and is silently skipped, the same way
+//   a malformed schema block already is elsewhere in this pipeline.
+function pushFieldValue(blockType, instanceId, fieldKey, value, isDateField, out) {
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            pushFieldValue(blockType, instanceId, fieldKey, item, isDateField, out);
+        }
+        return;
+    }
+    if (typeof value === 'string' && isDateField) {
+        const epoch = parseDateValue(value);
+        if (epoch !== undefined) {
+            out.push({ blockType, instanceId, fieldKey, valueText: null, valueNumber: epoch, valueBool: null });
+        }
+        return;
+    }
+    if (typeof value === 'string') {
+        out.push({ blockType, instanceId, fieldKey, valueText: value, valueNumber: null, valueBool: null });
+    }
+    else if (typeof value === 'number') {
+        out.push({ blockType, instanceId, fieldKey, valueText: null, valueNumber: value, valueBool: null });
+    }
+    else if (typeof value === 'boolean') {
+        out.push({ blockType, instanceId, fieldKey, valueText: null, valueNumber: null, valueBool: value ? 1 : 0 });
+    }
+}
+// Reads schema.properties for the given instance's own type, keeping
+// only properties explicitly flagged "api": true (an unvalidated,
+// theme-authored JSON Schema keyword - same status as "format"/
+// "allowedBlocks", see docs/guide-theme-authoring.md and
+// services/validation.ts's own allowedBlockTypesOf) - and pairs each
+// with its actual value out of instance.settings via pushFieldValue.
+function extractInstanceApiFields(instance, schemaMap, out) {
+    const type = typeof instance.type === 'string' ? instance.type : undefined;
+    const id = typeof instance.id === 'string' ? instance.id : undefined;
+    if (!type || !id) {
+        return;
+    }
+    const properties = schemaMap[type]?.properties;
+    if (!properties || typeof properties !== 'object') {
+        return;
+    }
+    const settings = (instance.settings && typeof instance.settings === 'object' ? instance.settings : {});
+    for (const [key, propSchema] of Object.entries(properties)) {
+        const schema = propSchema;
+        if (schema?.api !== true) {
+            continue;
+        }
+        const isDateField = schema.type === 'string' && schema.format === 'date';
+        pushFieldValue(type, id, key, settings[key], isDateField, out);
+    }
+}
+// Built-in envelope fields, auto-indexed with no "api": true needed -
+// author/publishDate/tags are optional on every page (page.schema.json),
+// so indexing is presence-based rather than gated on a specific "type"
+// value: any page carrying one of these fields gets it indexed,
+// regardless of what its own type string is. block_type '__page__' is a
+// sentinel (never a real theme type, which always matches a *.liquid
+// filename) marking these rows as envelope-level rather than a real
+// section/block instance; instanceId is the page's own url - stable
+// and unique enough, since there's exactly one envelope per page.
+function extractEnvelopeApiFields(page, url) {
+    const rows = [];
+    pushFieldValue('__page__', url, 'author', page.author, false, rows);
+    pushFieldValue('__page__', url, 'publishDate', page.publishDate, true, rows);
+    pushFieldValue('__page__', url, 'tags', page.tags, false, rows);
+    return rows;
+}
+// Top-level page.sections entries are sections; every level of nested
+// .blocks (arbitrarily deep - instance.schema.json's blocks is self-
+// referential, same reasoning extractBody's own walk above already
+// documents) is a block, so which theme-schema map applies flips
+// exactly once, at the top, and stays fixed for everything nested
+// underneath.
+function extractApiFields(sections, sectionSchemas, blockSchemas) {
+    const rows = [];
+    const walk = (list, schemaMap) => {
+        if (!list) {
+            return;
+        }
+        for (const instance of list) {
+            extractInstanceApiFields(instance, schemaMap, rows);
+            walk(instance.blocks, blockSchemas);
+        }
+    };
+    walk(sections, sectionSchemas);
+    return rows;
+}
+function unlinkIfExists(path) {
     try {
-        unlinkSync(config.searchIndexPath);
+        unlinkSync(path);
     }
     catch (error) {
         if (error.code !== 'ENOENT') {
             throw error;
         }
     }
-    const driver = openNodeSqliteDriver(config.searchIndexPath);
+}
+// A fresh sqlite file is never actually left in WAL mode by this
+// module (nothing here turns that on), but cleaning up any stray
+// -wal/-shm sidecar files defensively costs nothing and avoids ever
+// leaving one behind next to an abandoned temp build.
+function cleanupSqliteArtifacts(path) {
+    unlinkIfExists(path);
+    unlinkIfExists(`${path}-wal`);
+    unlinkIfExists(`${path}-shm`);
+}
+async function rebuildIndexJob(config) {
+    mkdirSync(config.dataRoot, { recursive: true });
+    // Built into a fresh temp file, then renamed atomically over the
+    // real path (below) - not the old delete-then-recreate-in-place
+    // approach, which left a real window where a concurrent read saw
+    // either a missing file or one that exists but has no tables in it
+    // yet. POSIX rename() is atomic: a reader always sees either the
+    // complete old index or the complete new one, never an in-between
+    // state, and never has to retry an open that landed in the gap.
+    const tmpPath = `${config.searchIndexPath}.tmp-${randomUUID()}`;
+    cleanupSqliteArtifacts(tmpPath);
+    const themeSchemas = loadThemeSchemas(config.themeRoot);
     try {
-        driver.exec('CREATE VIRTUAL TABLE pages_fts USING fts5(url UNINDEXED, title, body)');
-        const insert = driver.prepare('INSERT INTO pages_fts (url, title, body) VALUES (?, ?, ?)');
-        // Posts are genuinely public, URL-addressable content search
-        // should cover, same as pages - only the root and the URL mapping
-        // differ. Menus are deliberately never walked here at all: they
-        // have no public URL to point a search result at.
-        const collections = [
-            { root: config.pagesRoot, toUrl: pagePathToUrl },
-            { root: config.postsRoot, toUrl: postPathToUrl },
-        ];
-        driver.exec('BEGIN');
-        for (const { root, toUrl } of collections) {
-            for (const relativePath of listFilesRecursively(root, root, '.json')) {
-                let page;
-                try {
-                    page = JSON.parse(readFileSync(join(root, relativePath), 'utf-8'));
+        const driver = openNodeSqliteDriver(tmpPath);
+        try {
+            driver.exec('CREATE VIRTUAL TABLE pages_fts USING fts5(url UNINDEXED, title, body, page_type UNINDEXED)');
+            // A plain table, not FTS5 - page_fields holds typed, exact/range-
+            // comparable values (a price, a rating), the opposite of pages_fts's
+            // own free-text matching. One row per exposed field per instance
+            // (not one column per field name): a page can carry several
+            // instances of the same block type (several "product" blocks on one
+            // listing page), each with its own value, and different pages may
+            // expose entirely different field sets - a fixed column-per-field
+            // schema can't accommodate either. No foreign key back to
+            // pages_fts.url - this whole index is disposable and rebuilt wholly
+            // from scratch every time, same as pages_fts itself.
+            driver.exec('CREATE TABLE page_fields (url TEXT NOT NULL, block_type TEXT NOT NULL, instance_id TEXT NOT NULL, field_key TEXT NOT NULL, value_text TEXT, value_number REAL, value_bool INTEGER)');
+            // Composite, not a bare field_key index - field_key alone only
+            // narrows to one field's rows; leading with it here still serves
+            // that same narrowing (the leftmost-column rule), but the second
+            // column also covers the typed value comparison itself (an
+            // equality or range check) without a further per-row scan. url
+            // supports the self-join a multi-field query ANDs together
+            // (queryContent, query-content.ts) - with no index there, ANDing a
+            // second filter means scanning page_fields in full for every row
+            // the first filter matched.
+            driver.exec('CREATE INDEX page_fields_key_number ON page_fields (field_key, value_number)');
+            driver.exec('CREATE INDEX page_fields_key_text ON page_fields (field_key, value_text)');
+            driver.exec('CREATE INDEX page_fields_url ON page_fields (url)');
+            const insert = driver.prepare('INSERT INTO pages_fts (url, title, body, page_type) VALUES (?, ?, ?, ?)');
+            const insertField = driver.prepare('INSERT INTO page_fields (url, block_type, instance_id, field_key, value_text, value_number, value_bool) VALUES (?, ?, ?, ?, ?, ?, ?)');
+            // Menus are deliberately never walked here at all: they have no
+            // public URL to point a search result at.
+            const collections = [{ root: config.pagesRoot, toUrl: pagePathToUrl }];
+            driver.exec('BEGIN');
+            let filesExamined = 0;
+            for (const { root, toUrl } of collections) {
+                for (const relativePath of listFilesRecursively(root, root, '.json')) {
+                    // A genuine macrotask yield (setImmediate, not a microtask like
+                    // Promise.resolve()/queueMicrotask - Node drains every queued
+                    // microtask before the event loop ever reaches its I/O phases,
+                    // so a chain of only-microtask yields still fully blocks an
+                    // incoming HTTP request from being processed). Without this,
+                    // this loop's entire body - potentially thousands of files -
+                    // runs as one uninterruptible synchronous block: since Node is
+                    // single-threaded, that means every other request the server
+                    // is handling (auth, content reads, publishes) stalls for the
+                    // rebuild's whole duration, not just other search queries.
+                    // Counted once per file examined regardless of whether it
+                    // ends up skipped below, so the cadence tracks total work
+                    // done, not just files actually indexed.
+                    filesExamined += 1;
+                    if (filesExamined % YIELD_EVERY_N_FILES === 0) {
+                        await yieldToEventLoop();
+                    }
+                    let page;
+                    try {
+                        page = JSON.parse(readFileSync(join(root, relativePath), 'utf-8'));
+                    }
+                    catch {
+                        // A malformed individual file is skipped, not an all-or-nothing
+                        // abort: the index is explicitly disposable/best-effort, and
+                        // aborting the whole rebuild over one bad file would leave no
+                        // working index at all - strictly worse than skipping one page.
+                        continue;
+                    }
+                    // Never walks draftsRoot at all, and skips unpublished content
+                    // here - both halves of "drafts and unpublished content are
+                    // absent from the index" (G3) are true by construction, not by
+                    // a filter that could be gotten wrong.
+                    if (page.published === false) {
+                        continue;
+                    }
+                    const url = toUrl(relativePath);
+                    const title = typeof page.title === 'string' ? page.title : '';
+                    const pageType = typeof page.type === 'string' ? page.type : '';
+                    const body = extractBody(page.sections);
+                    insert.run(url, title, body, pageType);
+                    const apiFields = [
+                        ...extractApiFields(page.sections, themeSchemas.sections, themeSchemas.blocks),
+                        ...extractEnvelopeApiFields(page, url),
+                    ];
+                    for (const row of apiFields) {
+                        insertField.run(url, row.blockType, row.instanceId, row.fieldKey, row.valueText, row.valueNumber, row.valueBool);
+                    }
                 }
-                catch {
-                    // A malformed individual file is skipped, not an all-or-nothing
-                    // abort: the index is explicitly disposable/best-effort, and
-                    // aborting the whole rebuild over one bad file would leave no
-                    // working index at all - strictly worse than skipping one page.
-                    continue;
-                }
-                // Never walks draftsRoot at all, and skips unpublished content
-                // here - both halves of "drafts and unpublished content are
-                // absent from the index" (G3) are true by construction, not by
-                // a filter that could be gotten wrong.
-                if (page.published === false) {
-                    continue;
-                }
-                const url = toUrl(relativePath);
-                const title = typeof page.title === 'string' ? page.title : '';
-                const body = extractBody(page.sections);
-                insert.run(url, title, body);
             }
+            driver.exec('COMMIT');
         }
-        driver.exec('COMMIT');
+        finally {
+            driver.close();
+        }
+        renameSync(tmpPath, config.searchIndexPath);
     }
-    finally {
-        driver.close();
+    catch (error) {
+        cleanupSqliteArtifacts(tmpPath);
+        throw error;
     }
 }
-// Queued via enqueue(), not because constraint 6 literally demands it
-// for a non-authoritative index, but because of a same-process race
-// specific to this delete-then-recreate design: two concurrent
-// rebuilds can interleave so one's unlink races another's open+CREATE,
-// or one can unlink the file out from under another's in-progress
-// transaction. enqueue() is a generic, domain-agnostic primitive, so
-// reusing it for self-exclusion costs nothing.
+// Queued via enqueue() - two concurrent rebuilds could otherwise both
+// build their own temp file and both attempt the final rename; the
+// second rename would still win cleanly (rename() just replaces
+// whatever is there), but the first rebuild's now-orphaned temp file
+// would never get cleaned up. enqueue() is a generic, domain-agnostic
+// primitive, so reusing it for self-exclusion costs nothing.
 export function rebuildIndex(config) {
     return enqueue(() => rebuildIndexJob(config));
 }

package/dist/server-config.d.ts

@@ -18,5 +18,6 @@ export interface ServerConfig {
     ipAllowlist: string[];
     checkpointIntervalMs: number;
     media: MediaConfig;
+    adminBaseUrl: string | undefined;
 }
 export declare function loadServerConfig(siteRoot: string): ServerConfig;

package/dist/server-config.js

@@ -128,6 +128,31 @@ function parseIpAllowlist(value) {
     });
     return value;
 }
+// Undefined -> undefined: absence means the /admin redirect feature
+// is off entirely, not a default target to redirect to (there's no
+// sensible default admin URL to assume). Validated as a real absolute
+// http(s) URL, not just any non-empty string, since it becomes a
+// redirect target - rejects `javascript:`/`ftp:`/anything else before
+// it can ever reach a Location header.
+function parseAdminBaseUrl(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value !== 'string' || value.length === 0) {
+        throw new StartupCheckError('invalid-site-config', `site.config.json's "adminBaseUrl" must be a non-empty string, got ${JSON.stringify(value)}`);
+    }
+    let parsed;
+    try {
+        parsed = new URL(value);
+    }
+    catch {
+        throw new StartupCheckError('invalid-site-config', `site.config.json's "adminBaseUrl" must be a valid URL, got ${JSON.stringify(value)}`);
+    }
+    if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+        throw new StartupCheckError('invalid-site-config', `site.config.json's "adminBaseUrl" must be an http or https URL, got ${JSON.stringify(value)}`);
+    }
+    return value;
+}
 function parseCheckpointIntervalMs(value) {
     if (value === undefined) {
         return DEFAULT_CHECKPOINT_INTERVAL_MS;
@@ -182,6 +207,7 @@ export function loadServerConfig(siteRoot) {
             ipAllowlist: [],
             checkpointIntervalMs: DEFAULT_CHECKPOINT_INTERVAL_MS,
             media: { maxUploadBytes: DEFAULT_MEDIA_MAX_UPLOAD_BYTES },
+            adminBaseUrl: undefined,
         };
     }
     let parsed;
@@ -206,5 +232,6 @@ export function loadServerConfig(siteRoot) {
     const ipAllowlist = parseIpAllowlist(record.ipAllowlist);
     const checkpointIntervalMs = parseCheckpointIntervalMs(record.checkpointIntervalMs);
     const media = parseMedia(record.media);
-    return { port: resolvePort(port), tokens, rateLimit, trustProxy, ipAllowlist, checkpointIntervalMs, media };
+    const adminBaseUrl = parseAdminBaseUrl(record.adminBaseUrl);
+    return { port: resolvePort(port), tokens, rateLimit, trustProxy, ipAllowlist, checkpointIntervalMs, media, adminBaseUrl };
 }

package/dist/server.js

@@ -2,10 +2,12 @@ import rateLimitPlugin from '@fastify/rate-limit';
 import Fastify, {} from 'fastify';
 import { bootSite } from "./boot.js";
 import { loadServerConfig } from "./server-config.js";
+import { adminRedirectRoutes } from "./routes/admin-redirect.js";
 import { assetsRoutes } from "./routes/assets.js";
 import { v1Routes } from "./routes/index.js";
 import { mediaPublicRoutes } from "./routes/media-public.js";
 import { publicRoutes } from "./routes/public.js";
+import { searchPublicRoutes } from "./routes/search-public.js";
 import { sitemapRoutes } from "./routes/sitemap.js";
 import { CHECKPOINT_AUTHOR, runCheckpoint } from "./services/checkpoint.js";
 import { startDevTunnel } from "./services/dev-tunnel.js";
@@ -76,6 +78,7 @@ export function buildServer(booted, serverConfig, options = {}) {
         themeTemplates: booted.themeTemplates,
         layouts: booted.layouts,
         engine: booted.engine,
+        renderCache: booted.renderCache,
     });
     // A more specific static-prefixed route than the public catch-all's
     // own /* wildcard - Fastify prefers it regardless of registration
@@ -98,6 +101,25 @@ export function buildServer(booted, serverConfig, options = {}) {
     // also always wins over a same-named static file under
     // theme/root/sitemap.xml (see routes/public.ts's root-mirror check).
     app.register(sitemapRoutes, { config: booted.config });
+    // Same "more specific than the public catch-all" reasoning again - a
+    // stable, public, front-end-facing contract (a theme's own JS calls
+    // it directly), not part of the versioned /v1 admin/integration
+    // surface, so it lives alongside these other unprefixed routes
+    // rather than inside v1Routes (search.ts's /v1/search/rebuild is the
+    // authenticated write side that does). GET /search.json, not
+    // GET /search: a single reserved path, not a whole prefix, so a
+    // site's own content page can still live at the bare /search URL
+    // (granite-starter's search-demo section does exactly that).
+    app.register(searchPublicRoutes, { config: booted.config });
+    // Conditional, unlike every other registration above - this is what
+    // makes GET /admin genuinely opt-in rather than a reserved
+    // namespace: with no adminBaseUrl configured, the route is never
+    // registered at all, so an unconfigured site can still use "admin"
+    // as an ordinary page path. See routes/admin-redirect.ts's own
+    // comment for the full reasoning.
+    if (serverConfig.adminBaseUrl) {
+        app.register(adminRedirectRoutes, { adminBaseUrl: serverConfig.adminBaseUrl });
+    }
     return app;
 }
 // Neither a recurring timer nor process signal handling exists

package/dist/services/content-read.js

@@ -4,7 +4,6 @@ import { computeEtag } from "./etag.js";
 import { listFilesRecursively } from "./fs-walk.js";
 import { sanitisePath } from "./path-safety.js";
 import { pagePathToUrl } from "./urls.js";
-import { postPathToUrl } from "./post-urls.js";
 export class ContentReadError extends Error {
     reason;
     constructor(reason, message) {
@@ -29,7 +28,7 @@ export function readContentFile(root, relativePath) {
     return { bytes, etag: computeEtag(bytes) };
 }
 // Both contentRoot-relative live paths and draftsRoot-relative draft
-// paths share the identical pages/posts/menus subroot prefix shape
+// paths share the identical pages/menus subroot prefix shape
 // (content/drafts/ mirrors content/'s own layout), so one function
 // handles both with no branching on which root an entry came from.
 // Menus have no public URL - there is no preview route for them.
@@ -37,9 +36,6 @@ function computeContentUrl(relativePath) {
     if (relativePath.startsWith('pages/')) {
         return pagePathToUrl(relativePath.slice('pages/'.length));
     }
-    if (relativePath.startsWith('posts/')) {
-        return postPathToUrl(relativePath.slice('posts/'.length));
-    }
     return null;
 }
 // The later of the live file's and the draft's own mtime, whichever
@@ -87,20 +83,19 @@ function readSummary(fullPath) {
 // anywhere in the build plan - this is the only place a draft-only
 // page (never yet published) is discoverable at all.
 //
-// Deliberately three named walks (pages/posts/menus), not one broad
-// walk of contentRoot: since Group N nested draftsRoot and redirectsPath
+// Deliberately two named walks (pages/menus), not one broad walk of
+// contentRoot: since Group N nested draftsRoot and redirectsPath
 // inside contentRoot (content/drafts/, content/redirects.json), a
 // single broad contentRoot walk would descend into content/drafts/
 // too, double-listing draft files under two different relative-path
 // keys, and would pick up redirects.json as if it were a page. An
 // inclusion-based walk sidesteps both problems structurally, with no
-// exclusion list to maintain. base stays config.contentRoot for all
-// three (not each subroot) so the resulting relative paths ("pages/x.json")
+// exclusion list to maintain. base stays config.contentRoot for both
+// (not each subroot) so the resulting relative paths ("pages/x.json")
 // line up with draftPaths below for the hasDraft/hasLive union logic.
 export function listContent(config, filters) {
     const contentPaths = new Set([
         ...listFilesRecursively(config.pagesRoot, config.contentRoot, '.json'),
-        ...listFilesRecursively(config.postsRoot, config.contentRoot, '.json'),
         ...listFilesRecursively(config.menusRoot, config.contentRoot, '.json'),
     ]);
     const draftPaths = new Set(listFilesRecursively(config.draftsRoot, config.draftsRoot, '.json'));

package/dist/services/delete-content.js

@@ -2,27 +2,16 @@ import { existsSync, readFileSync, rmSync, statSync, unlinkSync, writeFileSync }
 import { listFilesRecursively } from "./fs-walk.js";
 import { commitPaths } from "./git.js";
 import { sanitisePath } from "./path-safety.js";
-import { postPathToUrl } from "./post-urls.js";
 import { RedirectError, addRedirect, isValidRedirectTarget, loadRedirects, serialiseRedirects, } from "./redirects.js";
 import { pagePathToUrl } from "./urls.js";
 import { enqueue } from "./write-queue.js";
 const PAGES_PREFIX = 'pages/';
-const POSTS_PREFIX = 'posts/';
-// Widens the redirect-on-delete gate to posts alongside pages, without
-// touching the has-children subtree check below (PAGES_PREFIX-only,
-// unchanged - posts never have nested children by construction). A
-// tiny duplicated helper, not a shared "collection" abstraction,
-// matching this codebase's existing precedent (e.g. prepareSaveDraft/
-// prepareDiscardDraft mirror rather than share a base with publish.ts/
-// move.ts). Returns null for anything else (menus have no public URL
-// at all, so redirects are meaningless there).
+// Returns null for anything else (menus have no public URL at all, so
+// redirects are meaningless there).
 function urlForDeletedEntry(relativePath) {
     if (relativePath.startsWith(PAGES_PREFIX)) {
         return pagePathToUrl(relativePath.slice(PAGES_PREFIX.length));
     }
-    if (relativePath.startsWith(POSTS_PREFIX)) {
-        return postPathToUrl(relativePath.slice(POSTS_PREFIX.length));
-    }
     return null;
 }
 export class DeleteContentError extends Error {

package/dist/services/manage-redirects.js

@@ -1,7 +1,6 @@
 import { existsSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { commitPaths } from "./git.js";
 import { sanitisePath } from "./path-safety.js";
-import { isBlogUrl, urlToPostPath } from "./post-urls.js";
 import { RedirectError, addRedirect, isValidRedirectTarget, loadRedirectsStrict, removeRedirectForPath, serialiseRedirects, } from "./redirects.js";
 import { urlToPagePath } from "./urls.js";
 import { enqueue } from "./write-queue.js";
@@ -13,22 +12,13 @@ export class ManageRedirectError extends Error {
         this.reason = reason;
     }
 }
-// Not required for correctness (resolve-url.ts/resolve-blog-url.ts
-// already guarantee live content always wins over a redirect at the
-// same URL), but rejecting here avoids a marketing manager creating a
-// redirect that would silently never fire.
+// Not required for correctness (resolve-url.ts already guarantees live
+// content always wins over a redirect at the same URL), but rejecting
+// here avoids a marketing manager creating a redirect that would
+// silently never fire.
 function liveContentExistsAt(config, url) {
     const pageFile = sanitisePath(config.pagesRoot, urlToPagePath(url));
-    if (existsSync(pageFile)) {
-        return true;
-    }
-    if (isBlogUrl(url) && existsSync(config.postsRoot)) {
-        const postRelative = urlToPostPath(url);
-        if (postRelative !== null && existsSync(sanitisePath(config.postsRoot, postRelative))) {
-            return true;
-        }
-    }
-    return false;
+    return existsSync(pageFile);
 }
 function validateFromAndTo(from, to) {
     if (!isValidRedirectTarget(from)) {