canopycms 0.0.62 → 0.0.64

package/dist/content-listing.js

@@ -8,13 +8,14 @@ import path from 'node:path';
 import matter from 'gray-matter';
 import { parse as yamlParse } from 'yaml';
 import { findBodyFieldName } from './utils/body-field.js';
+import { computeEntryUrl } from './utils/entry-url.js';
 import { asRecord, getFormatExtension } from './utils/format.js';
 import { resolveCollectionPath } from './content-id-index.js';
 import { validateAndNormalizePath } from './paths/index.js';
 import { isNotFoundError, getErrorMessage } from './utils/error.js';
 import { createDebugLogger } from './utils/debug.js';
-import { isValidId } from './id.js';
-import { ContentStoreError } from './content-store.js';
+import { ContentStore, ContentStoreError, createReferenceResolveCache, } from './content-store.js';
+import { isBuildMode } from './build-mode.js';
 const log = createDebugLogger({ prefix: 'ContentListing' });
 /**
  * Validate and normalize a path relative to root.
@@ -44,7 +45,17 @@ export const readEntryData = async (filePath, format, bodyFieldName = 'body') =>
             return asRecord(yamlParse(raw));
         }
         const parsed = matter(raw);
-        const data = parsed.data ?? {};
+        // Copy before writing the body in. gray-matter keeps a PROCESS-GLOBAL cache keyed by file
+        // content and hands every caller the same `data` object instance, so mutating it in place
+        // wrote the body into a shared object that later, unrelated `matter()` calls then saw as
+        // frontmatter. Concretely, before this copy: listing a collection that contains an md entry
+        // poisoned the cache, and a subsequent reference resolution to that same entry — which goes
+        // through `ContentStore.read()`, whose md branch calls `matter()` again — returned the body
+        // as a frontmatter field. So a resolved md snippet came back WITH `body` on a whole-site
+        // listing and WITHOUT it on one scoped past its own collection: the same entry, two shapes,
+        // decided by unrelated scoping. Regression coverage lives with the reference-resolution
+        // tests in content-listing.test.ts.
+        const data = { ...(parsed.data ?? {}) };
         if (parsed.content) {
             data[bodyFieldName] = parsed.content;
         }
@@ -57,48 +68,82 @@ export const readEntryData = async (filePath, format, bodyFieldName = 'body') =>
         return {};
     }
 };
+// `parseTypedFilename` now lives in utils/typed-filename.ts so dependency-light modules can
+// use it without importing this one (which pulls in ContentStore). Re-exported here because
+// this is where callers -- and `canopycms/server` -- have always imported it from.
+export { parseTypedFilename } from './utils/typed-filename.js';
+import { parseTypedFilename } from './utils/typed-filename.js';
+// ---------------------------------------------------------------------------
+// Reference resolution for batch listings
+// ---------------------------------------------------------------------------
 /**
- * Parse a filename: {type}.{slug}.{id}.{ext}
- * Returns { type, slug, id } or null if the filename doesn't match the pattern.
+ * Build the `ContentStore` + shared cache that a batch listing resolves references through.
+ *
+ * Unrelated to the `ReferenceResolver` class in reference-resolver.ts despite the adjacent
+ * name — that one resolves an id to a human-readable *display label* for the editor UI. This
+ * resolves a reference to the referenced entry's *data* for server-side listings.
+ *
+ * Constructed lazily by each listing surface, and ONLY when the caller opted in — a store
+ * builds a ContentId index on first use, which is a full scan of the content tree, and the
+ * default (`resolveReferences` off) must stay a pure filesystem walk with no index at all.
+ *
+ * One store and one cache per listing call, not per collection: the cache is the reason a
+ * shared block referenced from 40 pages costs one read instead of 40, so it has to span the
+ * whole batch. Per-call construction is the established shape here — content-reader.ts's
+ * `resolveStore` builds a store per read, and content-index-registry.ts holds stores through
+ * `WeakRef` + a `FinalizationRegistry` precisely so short-lived instances stay collectable.
  */
-export const parseTypedFilename = (filename, entryTypes) => {
-    // Remove extension
-    const lastDot = filename.lastIndexOf('.');
-    if (lastDot === -1)
-        return null;
-    const nameWithoutExt = filename.slice(0, lastDot);
-    // Parse: {type}.{slug}.{id}
-    const parts = nameWithoutExt.split('.');
-    if (parts.length >= 3) {
-        // Check if first part matches a known entry type
-        const potentialType = parts[0];
-        const matchingType = entryTypes.find((e) => e.name === potentialType);
-        if (matchingType) {
-            const id = parts[parts.length - 1];
-            if (!isValidId(id))
-                return null;
-            const slug = parts.slice(1, -1).join('.').toLowerCase();
-            return {
-                type: potentialType,
-                slug: slug,
-                id: id,
-            };
-        }
-    }
-    return null;
-};
+export const createReferenceResolver = (branchRoot, flatSchema, contentRootName) => ({
+    store: new ContentStore(branchRoot, flatSchema, { contentRootName }),
+    cache: createReferenceResolveCache(),
+});
+/**
+ * Resolve `reference` fields in a collection's listed entries, in place of their raw data.
+ *
+ * Shared by `listEntries` and `buildContentTree` so both opt into resolution through one
+ * implementation. Each entry resolves against its OWN entry type's field list, since that is
+ * what says which fields are references at all; an entry whose type has no resolvable schema
+ * is returned untouched rather than guessed at.
+ */
+export const resolveCollectionItemReferences = async (items, collection, resolver) => Promise.all(items.map(async (item) => {
+    const fields = collection.entries?.find((e) => e.name === item.entryType)?.schema;
+    if (!fields)
+        return item;
+    return {
+        ...item,
+        data: await resolver.store.resolveReferences(item.data, fields, resolver.cache),
+    };
+}));
 /**
  * List all content entries as a flat array.
  *
  * Walks the schema to discover collections, reads entries from each,
  * and returns a flat list suitable for generateStaticParams, search indexing, sitemaps, etc.
  *
+ * Build-time-only failure: a file with a recognized content extension (`.md`/`.mdx`/`.json`/
+ * `.yaml`) sitting in a collection directory that *looks like an attempted entry* (see
+ * `looksLikeMalformedEntry` below) but doesn't match `{type}.{slug}.{id}.{ext}` is, by default,
+ * silently dropped (see `listCollectionEntries`'s debug-gated warning). That is exactly the
+ * silent-page-loss failure mode static generation must not have — a schema rename without a
+ * matching file rename, or an entry type declared in one collection but not another, would
+ * otherwise vanish a page with zero build output. So when `isBuildMode()` is true, any such file
+ * turns the listing into a thrown error instead (see `findInvalidEntries`/`assertBuildEntriesValid`
+ * in `static/index.ts` for the sibling schema-validity guard this mirrors). Outside build mode
+ * (admin UI, content tree, `next dev`) the file is still just skipped, since a fresh scaffold or
+ * mid-rename file legitimately exists there.
+ *
+ * A file that was never entry-shaped to begin with — a `README.md`, or a colocated sibling
+ * artifact named `{contentId}.suffix.ext` per the `entryTransforms`/`readSibling` convention
+ * documented in the README — is not this guard's failure mode and never throws, in or out of
+ * build mode. See `looksLikeMalformedEntry` for the exact shape test.
+ *
  * @param branchRoot - Absolute path to the branch workspace root
  * @param flatSchema - Flattened schema items (from flattenSchema)
  * @param contentRootName - The content root name (e.g. "content")
- * @param options - Listing options (extract, filter, rootPath, sort)
+ * @param options - Listing options (extract, filter, rootPath, sort, resolveReferences)
+ * @param visibility - Internal path-ACL predicate; see `ContentVisibilityOptions`
  */
-export async function listEntries(branchRoot, flatSchema, contentRootName, options) {
+export async function listEntries(branchRoot, flatSchema, contentRootName, options, visibility) {
     const rootPath = options?.rootPath ?? contentRootName;
     const extract = options?.extract;
     const filter = options?.filter;
@@ -107,11 +152,44 @@ export async function listEntries(branchRoot, flatSchema, contentRootName, optio
     const collections = flatSchema.filter((item) => item.type === 'collection' &&
         item.entries !== undefined &&
         (item.logicalPath === rootPath || item.logicalPath.startsWith(`${rootPath}/`)));
-    // List entries from all collections in parallel
+    // List entries from all collections in parallel.
+    // The visibility predicate is applied here, before the map below, so a denied entry's
+    // data never reaches `extract` (let alone the returned items).
+    const shouldInclude = visibility?.shouldInclude;
+    const skippedFiles = [];
+    // One store + cache for the whole call, or nothing at all when the caller did not opt in.
+    // See the `resolveReferences` option for the cost this buys back.
+    const resolver = options?.resolveReferences
+        ? createReferenceResolver(branchRoot, flatSchema, contentRootName)
+        : null;
     const collectionResults = await Promise.all(collections.map(async (collection) => {
-        const entries = await listCollectionEntries(branchRoot, collection);
-        return entries.map((entry) => ({ entry, collection }));
+        const entries = await listCollectionEntries(branchRoot, collection, (file) => skippedFiles.push(file));
+        const visible = shouldInclude ? entries.filter((e) => shouldInclude(e.physicalPath)) : entries;
+        // Resolve AFTER the visibility filter (a denied entry is never resolved, so its
+        // references cost nothing and leak nothing) and BEFORE the mapping below, so
+        // `extract` and `filter` both see resolved data — which is the entire point.
+        const resolved = resolver
+            ? await resolveCollectionItemReferences(visible, collection, resolver)
+            : visible;
+        return resolved.map((entry) => ({ entry, collection }));
     }));
+    // Build-time only: fail loudly rather than silently shipping a build with a page missing. See
+    // the build-time-only-failure note in this function's own doc comment above. Only files that
+    // structurally look like a malformed entry reach `skippedFiles` at all -- see
+    // `looksLikeMalformedEntry` and `listCollectionEntries`.
+    if (isBuildMode() && skippedFiles.length > 0) {
+        const lines = skippedFiles.map(({ filename, collectionPath }) => `  - ${collectionPath}/${filename}`);
+        throw new Error(`CanopyCMS static build: found ${skippedFiles.length} file(s) that look like malformed ` +
+            `content entries inside a content collection:\n${lines.join('\n')}\n` +
+            'Expected {type}.{slug}.{id}.{ext} with a known entry type (a name declared in that ' +
+            "collection's entries config) and a valid 12-char Base58 ID. This usually means a schema " +
+            'rename without a matching file rename, an entry type declared in one collection but not ' +
+            'another, or a stray file placed directly in a collection directory. If this is meant to ' +
+            "be a colocated sibling artifact (e.g. an entry's contentId-prefixed data file read via " +
+            'an entryTransforms readSibling call), keep its name to three or fewer dot-separated ' +
+            'segments (id.suffix.ext) so it is never mistaken for an entry attempt. Otherwise rename ' +
+            'or move the file, or fix the schema, then rebuild.');
+    }
     // Flatten and map to ListEntriesItem
     const contentPrefix = contentRootName ? `${contentRootName}/` : '';
     const items = [];
@@ -122,9 +200,17 @@ export async function listEntries(branchRoot, flatSchema, contentRootName, optio
                 ? entry.logicalPath.slice(contentPrefix.length)
                 : entry.logicalPath;
             const pathSegments = pathWithoutRoot.split('/').filter(Boolean);
-            // Compute urlPath: collapse index entries to parent collection path
-            const urlSegments = entry.slug === 'index' ? pathSegments.slice(0, -1) : pathSegments;
-            const urlPath = urlSegments.length > 0 ? `/${urlSegments.join('/')}`.toLowerCase() : '/';
+            // Compute urlPath (collapses an `index` entry to its parent collection path) through
+            // the SHARED rule rather than a local copy of it. A resolved reference now carries a
+            // `urlPath` too, and the whole point of that field is that it addresses the same entry
+            // this listing does, so the two must not be free to drift apart.
+            //
+            // One deliberate copy of this rule remains: `content-tree.ts`'s `defaultBuildPath`,
+            // which is exported for adopters to extend and also handles the collection case
+            // `computeEntryUrl` does not model. It agrees today; folding it in is tracked in
+            // `.claude/future-tasks/default-build-path-url-rule-copy.md`.
+            // `content-listing.test.ts` pins the listing-vs-resolved-reference agreement.
+            const urlPath = computeEntryUrl(entry.collectionPath, entry.slug, contentRootName);
             const raw = entry.data;
             const meta = {
                 entryPath: entry.logicalPath,
@@ -144,6 +230,7 @@ export async function listEntries(branchRoot, flatSchema, contentRootName, optio
                 format: entry.format,
                 data,
                 schema: collection.entries?.find((e) => e.name === entry.entryType)?.schema,
+                updatedAt: entry.updatedAt,
             };
             if (filter && !filter(item))
                 continue;
@@ -187,11 +274,56 @@ export const sortByOrder = (items, order, fallbackKey) => {
         return fallbackKey(a).localeCompare(fallbackKey(b));
     });
 };
+/**
+ * True when a content-extension filename structurally resembles an attempted entry — as opposed
+ * to a file that was never entry-shaped to begin with.
+ *
+ * A successfully-parsed entry always has at least 4 dot-separated segments: `type` (1+),
+ * `slug` (1+, since `parseTypedFilename` always takes at least the one segment between type and
+ * id), `id` (1), `ext` (1). So a file with 4+ segments that still failed to parse is malformed
+ * on its face — a wrong-length or invalid-Base58 ID, most often (`post.hello-world.BADID.md`).
+ *
+ * That segment-count test alone missed the MORE common accident: losing the ID segment
+ * entirely. `post.hello-world.md` (3 segments) fails `parseTypedFilename` exactly like the
+ * 4-segment case does, but a bare 3-or-fewer-segment cutoff would treat it as never having been
+ * entry-shaped and drop it silently — the page just vanishes with a green build. So a 3-segment
+ * file whose FIRST segment matches a real entry type name in this collection is ALSO treated as
+ * malformed: `parseTypedFilename` requires type+slug+id (3 segments) after stripping the
+ * extension, so a 3-total-segment filename already has only 2 left over — it could only have
+ * been attempting `type.slug` with no id, or `type.id` with no slug, either way a lost segment,
+ * not a coincidence. This still leaves the two motivating "was never an entry" cases alone: a
+ * bare `README.md` (2 segments, and "README" is essentially never a configured entry type name)
+ * and an entry's colocated sibling artifact named `{contentId}.suffix.ext` per the
+ * `entryTransforms`/`readSibling` convention documented in the README (3 segments, e.g.
+ * `5NVkkrB1MJUv.profile.json` — a content ID is never itself an entry type name, so the same
+ * "first segment matches a known type" test correctly leaves it unflagged).
+ *
+ * Dot-prefixed (hidden files, editor swap/backup files) and underscore-prefixed (a common
+ * adopter convention for "not an entry") names are excluded outright regardless of segment
+ * count, matching `parseTypedFilename`'s own dotfile rejection.
+ */
+const looksLikeMalformedEntry = (filename, entryTypes) => {
+    if (filename.startsWith('.') || filename.startsWith('_'))
+        return false;
+    const segments = filename.split('.');
+    if (segments.length >= 4)
+        return true;
+    return segments.length === 3 && entryTypes.some((e) => e.name === segments[0]);
+};
 /**
  * List all entries in a collection directory.
  * Reads each entry's data (frontmatter or JSON).
+ *
+ * @param onSkip - Called for every file that has a recognized content extension, doesn't match
+ *   the `{type}.{slug}.{id}.{ext}` grammar (see `parseTypedFilename`), AND structurally looks
+ *   like an attempted entry (see `looksLikeMalformedEntry`). A file that was never entry-shaped
+ *   (too few dot-separated segments to ever be a valid entry — a `README.md`, a colocated
+ *   sibling artifact) is always silently dropped with a debug-gated `log.warn`, never passed to
+ *   `onSkip`. Optional and purely a diagnostic hook — existing callers that omit it keep the
+ *   exact prior behavior. `listEntries` below uses this to turn the skip into a hard build-time
+ *   failure instead of a silent one.
  */
-export const listCollectionEntries = async (root, collection) => {
+export const listCollectionEntries = async (root, collection, onSkip) => {
     if (collection.type !== 'collection' || !collection.entries) {
         return [];
     }
@@ -231,6 +363,9 @@ export const listCollectionEntries = async (root, collection) => {
         const parsed = parseTypedFilename(file.name, entryTypes);
         if (!parsed) {
             log.warn('listCollectionEntries', `Skipping file with unrecognized filename format: ${file.name} (expected {type}.{slug}.{id}.{ext} with a known entry type and valid 12-char Base58 ID)`);
+            if (looksLikeMalformedEntry(file.name, entryTypes)) {
+                onSkip?.({ filename: file.name, collectionPath: collection.logicalPath });
+            }
             return null;
         }
         const { type: entryTypeName, slug, id: contentId } = parsed;
@@ -257,4 +392,3 @@ export const listCollectionEntries = async (root, collection) => {
     }));
     return entries.filter((e) => e !== null);
 };
-//# sourceMappingURL=content-listing.js.map

package/dist/content-reader.d.ts

@@ -1,7 +1,7 @@
-import { type LogicalPath, type PhysicalPath, type Slug } from './paths';
-import type { CanopyServices } from './services';
-import type { BranchContext } from './types';
-import type { CanopyUser } from './user';
+import { type ContentId, type LogicalPath, type PhysicalPath, type Slug } from './paths/index.js';
+import type { CanopyServices } from './services.js';
+import type { BranchContext } from './types.js';
+import type { CanopyUser } from './user.js';
 export interface ContentReaderOptions {
     services: CanopyServices;
     basePathOverride?: string;
@@ -22,13 +22,50 @@ export interface ReadContentInput {
     /** Whether to resolve entry:ID links in body/markdown fields. Defaults to true. */
     resolveEntryLinks?: boolean;
 }
+/**
+ * Structural metadata surfaced alongside a resolved content read. Shared by
+ * `ContentReader['read']` here and by `CanopyBuildContext`'s `read`/`readByUrlPath`
+ * (context.ts), which both wrap this same reader.
+ */
+export interface ContentReadMeta {
+    /**
+     * Absolute filesystem path to the resolved entry file. It is **server-only**
+     * -- do not serialize it to the client or embed it in public output, as it
+     * reveals the deployment's filesystem layout (home dir / EFS mount / branch
+     * name).
+     */
+    physicalPath: PhysicalPath;
+    /**
+     * The resolved entry type name, read from the entry's own filename
+     * (`{type}.{slug}.{id}.{ext}`) -- immutable once the file is created, and
+     * NOT re-validated against the collection's current `entries` config on
+     * every read. It is therefore usually, but not guaranteed to be, a key in
+     * the collection's `entries` config: it can diverge if an entry type was
+     * renamed or removed from the schema after files using the old name were
+     * created, or if the file was hand-authored with an unrecognized type
+     * token.
+     *
+     * For a legacy entry file predating embedded-type filenames (`{slug}.{ext}`),
+     * there is no type recorded on disk at all -- `entryType` silently falls
+     * back to the collection's DEFAULT entry type, which may or may not be what
+     * the file actually is. `entryId` being `undefined` (below) is the signal
+     * that this happened: when `entryId` is `undefined`, `entryType` is
+     * inferred rather than read.
+     */
+    entryType: string;
+    /**
+     * The entry's 12-char Base58 content ID, when the resolved file carries one.
+     * Undefined only for legacy entry files predating embedded-ID filenames
+     * (`{slug}.{ext}` rather than `{type}.{slug}.{id}.{ext}`) -- see the
+     * `entryType` caveat above for what that implies about it.
+     */
+    entryId?: ContentId;
+}
 export interface ContentReader {
     read: <T = unknown>(input: ReadContentInput, message?: string) => Promise<{
         data: T;
         path: string;
-        meta: {
-            physicalPath: PhysicalPath;
-        };
+        meta: ContentReadMeta;
     }>;
 }
 /**
@@ -36,4 +73,3 @@ export interface ContentReader {
  * Falls back to creating the branch workspace (metadata + checkout) if missing.
  */
 export declare const createContentReader: (options: ContentReaderOptions) => ContentReader;
-//# sourceMappingURL=content-reader.d.ts.map

package/dist/content-reader.js

@@ -1,7 +1,8 @@
 import { loadBranchContext, loadOrCreateBranchContext } from './branch-workspace.js';
 import { ContentStore, ContentStoreError } from './content-store.js';
-import { resolveBranchPaths } from './paths/index.js';
+import { resolveBranchPaths, } from './paths/index.js';
 import { trimSlashes } from './paths/normalize.js';
+import { isIndexSlug } from './utils/entry-url.js';
 import { isDeployedStatic, isBuildMode } from './build-mode.js';
 import { isNotFoundError } from './utils/error.js';
 import { resolveEntryLinksInData } from './entry-link-resolver.js';
@@ -86,7 +87,20 @@ export const createContentReader = (options) => {
         .join('/');
     // Build preview paths using simple path construction
     const contentRoot = trimSlashes(services.config.contentRoot ?? 'content');
-    const stripRoot = (val) => contentRoot && val.startsWith(`${contentRoot}/`) ? val.slice(contentRoot.length + 1) : val;
+    // The `val === contentRoot` branch matters as much as the prefix one: a root-level entry's
+    // collectionPath IS the content root, which does not start with `${contentRoot}/`, so without
+    // it the root index reported `path: '/content'` (and a root entry `/content/about`) -- paths
+    // that resolve to nothing. `computeEntryUrl` has always had both branches; this had one.
+    //
+    // Both branches stay guarded on `contentRoot` so an empty one passes the value through
+    // unchanged, exactly as `computeEntryUrl` does. Unreachable today (`contentRootSchema` is
+    // `relativePathSchema.default('content')` with `.min(1)`), but a blanket short-circuit would
+    // be the WRONG answer if it ever were reachable -- it would flatten every entry to root.
+    const stripRoot = (val) => contentRoot && val === contentRoot
+        ? ''
+        : contentRoot && val.startsWith(`${contentRoot}/`)
+            ? val.slice(contentRoot.length + 1)
+            : val;
     const buildEntryPath = (opts) => {
         // Construct preview path from collectionPath
         const stripped = stripRoot(opts.collectionPath);
@@ -95,7 +109,13 @@ export const createContentReader = (options) => {
             ? `${url}${url.includes('?') ? '&' : '?'}branch=${encodeURIComponent(opts.branch)}`
             : url;
         const trimmed = base.endsWith('/') ? base.slice(0, -1) : base;
-        const encodedSlug = encodeSlug(opts.slug);
+        // An index entry's URL is its COLLECTION's path. Without this collapse `path` handed back
+        // `/docs/index` for an entry advertised at `/docs` -- `resolveUrlPathCandidates`
+        // deliberately does not resolve the former, so a caller linking `path` linked to a 404.
+        // Same index decision as computeEntryUrl/listEntries/buildPreviewSrc, through the same
+        // predicate. NOTE this builder still keeps its own content-root strip and its own encoding
+        // rather than delegating wholesale -- see .claude/future-tasks/default-build-path-url-rule-copy.md.
+        const encodedSlug = isIndexSlug(opts.slug) ? '' : encodeSlug(opts.slug);
         const url = encodedSlug ? `${trimmed}/${encodedSlug}` : trimmed || '/';
         return appendBranch(url);
     };
@@ -108,10 +128,23 @@ export const createContentReader = (options) => {
         // for server-side colocated-artifact reads (e.g. a sibling profile.json). Already
         // computed here for permission checks; just carried through.
         let physicalPath;
+        // Entry type + content ID are already resolved as part of path resolution
+        // (buildPaths() derives both from the schema item / filename) — surfaced on
+        // read() / readByUrlPath() so callers can route or key by them without a
+        // separate listEntries lookup or filename parse.
+        let entryType;
+        let entryId;
         try {
             const resolved = await store.resolveDocumentPath(entryPath, slug ?? '');
             relativePath = resolved.relativePath;
             physicalPath = resolved.absolutePath;
+            // resolveDocumentPath() always sets entryTypeName for a valid schema item
+            // (collection entries fall back to 'entry'; entry-type items delegate to
+            // their parent collection with their own name), so no further fallback
+            // is needed here — id is the one field that can be legitimately absent,
+            // for legacy entry files without an embedded ID (see ContentReadMeta).
+            entryType = resolved.entryTypeName;
+            entryId = resolved.id;
         }
         catch (err) {
             const message = err instanceof ContentStoreError ? err.message : 'Invalid content request';
@@ -145,7 +178,7 @@ export const createContentReader = (options) => {
             const doc = await store.read(entryPath, slug ?? '', {
                 resolveReferences: input.resolveReferences ?? true,
             });
-            return { doc, store, physicalPath };
+            return { doc, store, physicalPath, entryType, entryId };
         }
         catch (err) {
             if (isNotFoundError(err))
@@ -160,7 +193,7 @@ export const createContentReader = (options) => {
             const defaultMessage = `Content not found for ${entryPath}${slug ? `/${slug}` : ''} on branch ${branchName}`;
             throw new ContentStoreError(message ?? defaultMessage, 'NOT_FOUND');
         }
-        const { doc, store, physicalPath } = result;
+        const { doc, store, physicalPath, entryType, entryId } = result;
         // For md/mdx format, merge the body into the data so callers get a complete object.
         // The field name comes from the schema's isBody flag (defaults to 'body').
         const docRecord = doc;
@@ -179,8 +212,7 @@ export const createContentReader = (options) => {
             slug,
             branch: branchName,
         });
-        return { data, path, meta: { physicalPath } };
+        return { data, path, meta: { physicalPath, entryType, entryId } };
     };
     return { read };
 };
-//# sourceMappingURL=content-reader.js.map