@contentbit/core 0.2.0 → 0.3.0

package/dist/frontmatter.js

@@ -68,12 +68,64 @@ function parseValue(value, indented) {
         if (indented.length === 0)
             return null;
         const items = dedent(indented);
-        if (items.every((l) => l.startsWith('- ')))
-            return items.map((l) => parseScalar(l.slice(2).trim()));
+        const list = parseDashList(items);
+        if (list)
+            return list;
+        const mapping = parseNestedMapping(items);
+        if (mapping)
+            return mapping;
         return items.join('\n');
     }
     return parseScalar(value);
 }
+// A one-level mapping: every dedented line is `key: scalar` (or `key:` with an
+// inline array value). Returns null if any line isn't a flat mapping entry —
+// e.g. a deeper-indented line or a `key:` with no inline value, which would
+// need its own nested block — so the caller keeps the raw-text fallback.
+function parseNestedMapping(items) {
+    const out = {};
+    for (const line of items) {
+        if (/^[ \t]/.test(line))
+            return null;
+        const m = line.match(KEY_RE);
+        if (!m)
+            return null;
+        const [, key, rawValue] = m;
+        const v = rawValue.trim();
+        if (v === '')
+            return null;
+        out[key] = parseScalar(v);
+    }
+    return Object.keys(out).length > 0 ? out : null;
+}
+function parseDashList(items) {
+    const groups = [];
+    let current = null;
+    for (const line of items) {
+        if (line.startsWith('- ')) {
+            if (current)
+                groups.push(current);
+            current = [line.slice(2)];
+        }
+        else if (current && /^[ \t]/.test(line)) {
+            current.push(line);
+        }
+        else {
+            return null;
+        }
+    }
+    if (current)
+        groups.push(current);
+    return groups.map((group) => parseDashItem(group));
+}
+function parseDashItem(lines) {
+    const first = lines[0].trim();
+    if (lines.length === 1)
+        return parseNestedMapping([first]) ?? parseScalar(first);
+    const rest = dedent(lines.slice(1));
+    const mapping = parseNestedMapping([first, ...rest]);
+    return mapping ?? lines.join('\n');
+}
 function dedent(lines) {
     const indent = Math.min(...lines.map((l) => l.match(/^[ \t]*/)[0].length));
     return lines.map((l) => l.slice(indent));
@@ -106,6 +158,20 @@ function parseScalar(value) {
             return [];
         return splitInlineItems(inner).map((item) => parseScalar(item.trim()));
     }
+    if (value.startsWith('{') && value.endsWith('}')) {
+        const inner = value.slice(1, -1).trim();
+        if (inner === '')
+            return {};
+        const out = {};
+        for (const item of splitInlineItems(inner)) {
+            const m = item.trim().match(KEY_RE);
+            if (!m)
+                return value;
+            const [, key, rawValue] = m;
+            out[key] = parseScalar(rawValue.trim());
+        }
+        return out;
+    }
     return value;
 }
 /** Split inline array items on top-level commas, respecting quotes. */

package/dist/index.d.ts

@@ -12,4 +12,5 @@ export { markdownBody, pipeRows, listItems, childBlocks, type MarkdownBodyData,
 export { validateDocument, isValidatedBlock, type ValidateOptions, type ValidationResult, type ValidatedBlockNode, } from './validate.js';
 export { generateAuthoringGuide, type AuthoringGuideOptions } from './authoring.js';
 export { renderToMarkdown, type MarkdownBlockRenderer, type MarkdownRenderContext, type RenderToMarkdownOptions, } from './render-markdown.js';
+export { parseLinkFrontmatter, buildLinkIndex, validateLinks, serializeLinkIndex, aliasReplacementsForPage, type LinkResolveMode, type LinkResolverOptions, type LinkTarget, type LinkFrontmatter, type ParseLinkResult, type LinkReference, type IndexedPage, type LinkAliasEntry, type LinkIndex, type LinkInput, type LinkDiagnostic, type SerializedLinkIndex, } from './links.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AACtC,YAAY,EAAE,WAAW,EAAE,WAAW,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AACtF,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAA;AACnD,YAAY,EAAE,YAAY,EAAE,WAAW,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAClF,OAAO,EAAE,aAAa,EAAE,KAAK,WAAW,EAAE,MAAM,aAAa,CAAA;AAC7D,OAAO,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,KAAK,WAAW,EAAE,MAAM,kBAAkB,CAAA;AACzF,OAAO,EACL,eAAe,EACf,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,QAAQ,GACd,MAAM,cAAc,CAAA;AACrB,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AACvC,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;AAC7C,OAAO,EACL,mBAAmB,EACnB,WAAW,EACX,aAAa,EACb,KAAK,eAAe,EACpB,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,MAAM,GACZ,MAAM,eAAe,CAAA;AACtB,OAAO,EACL,YAAY,EACZ,QAAQ,EACR,SAAS,EACT,WAAW,EACX,KAAK,gBAAgB,EACrB,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,QAAQ,EACb,KAAK,eAAe,GACrB,MAAM,qBAAqB,CAAA;AAC5B,OAAO,EACL,gBAAgB,EAChB,gBAAgB,EAChB,KAAK,eAAe,EACpB,KAAK,gBAAgB,EACrB,KAAK,kBAAkB,GACxB,MAAM,eAAe,CAAA;AACtB,OAAO,EAAE,sBAAsB,EAAE,KAAK,qBAAqB,EAAE,MAAM,gBAAgB,CAAA;AACnF,OAAO,EACL,gBAAgB,EAChB,KAAK,qBAAqB,EAC1B,KAAK,qBAAqB,EAC1B,KAAK,uBAAuB,GAC7B,MAAM,sBAAsB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AACtC,YAAY,EAAE,WAAW,EAAE,WAAW,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AACtF,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAA;AACnD,YAAY,EAAE,YAAY,EAAE,WAAW,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAClF,OAAO,EAAE,aAAa,EAAE,KAAK,WAAW,EAAE,MAAM,aAAa,CAAA;AAC7D,OAAO,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,KAAK,WAAW,EAAE,MAAM,kBAAkB,CAAA;AACzF,OAAO,EACL,eAAe,EACf,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,QAAQ,GACd,MAAM,cAAc,CAAA;AACrB,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AACvC,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;AAC7C,OAAO,EACL,mBAAmB,EACnB,WAAW,EACX,aAAa,EACb,KAAK,eAAe,EACpB,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,MAAM,GACZ,MAAM,eAAe,CAAA;AACtB,OAAO,EACL,YAAY,EACZ,QAAQ,EACR,SAAS,EACT,WAAW,EACX,KAAK,gBAAgB,EACrB,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,QAAQ,EACb,KAAK,eAAe,GACrB,MAAM,qBAAqB,CAAA;AAC5B,OAAO,EACL,gBAAgB,EAChB,gBAAgB,EAChB,KAAK,eAAe,EACpB,KAAK,gBAAgB,EACrB,KAAK,kBAAkB,GACxB,MAAM,eAAe,CAAA;AACtB,OAAO,EAAE,sBAAsB,EAAE,KAAK,qBAAqB,EAAE,MAAM,gBAAgB,CAAA;AACnF,OAAO,EACL,gBAAgB,EAChB,KAAK,qBAAqB,EAC1B,KAAK,qBAAqB,EAC1B,KAAK,uBAAuB,GAC7B,MAAM,sBAAsB,CAAA;AAC7B,OAAO,EACL,oBAAoB,EACpB,cAAc,EACd,aAAa,EACb,kBAAkB,EAClB,wBAAwB,EACxB,KAAK,eAAe,EACpB,KAAK,mBAAmB,EACxB,KAAK,UAAU,EACf,KAAK,eAAe,EACpB,KAAK,eAAe,EACpB,KAAK,aAAa,EAClB,KAAK,WAAW,EAChB,KAAK,cAAc,EACnB,KAAK,SAAS,EACd,KAAK,SAAS,EACd,KAAK,cAAc,EACnB,KAAK,mBAAmB,GACzB,MAAM,YAAY,CAAA"}

package/dist/index.js

@@ -10,3 +10,4 @@ export { markdownBody, pipeRows, listItems, childBlocks, } from './content-model
 export { validateDocument, isValidatedBlock, } from './validate.js';
 export { generateAuthoringGuide } from './authoring.js';
 export { renderToMarkdown, } from './render-markdown.js';
+export { parseLinkFrontmatter, buildLinkIndex, validateLinks, serializeLinkIndex, aliasReplacementsForPage, } from './links.js';

package/dist/links.d.ts

@@ -0,0 +1,96 @@
+import { z } from 'zod';
+import type { Diagnostic } from './diagnostics.js';
+declare const LinkTarget: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    slug: z.ZodOptional<z.ZodString>;
+    key: z.ZodOptional<z.ZodString>;
+    locale: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>]>;
+declare const LinkFrontmatter: z.ZodObject<{
+    slug: z.ZodString;
+    key: z.ZodOptional<z.ZodString>;
+    locale: z.ZodOptional<z.ZodString>;
+    title: z.ZodOptional<z.ZodString>;
+    linksTo: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        slug: z.ZodOptional<z.ZodString>;
+        key: z.ZodOptional<z.ZodString>;
+        locale: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>>;
+    aliases: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    keywords: z.ZodOptional<z.ZodObject<{
+        primary: z.ZodOptional<z.ZodString>;
+        secondary: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type LinkTarget = z.infer<typeof LinkTarget>;
+export type LinkFrontmatter = z.infer<typeof LinkFrontmatter>;
+export type LinkResolveMode = 'global-slug' | 'same-locale-slug' | 'same-locale-key' | 'prefer-same-locale-key-fallback-slug';
+export interface LinkResolverOptions {
+    resolve?: LinkResolveMode;
+    localeField?: string;
+    slugField?: string;
+    keyField?: string;
+    defaultLocale?: string;
+}
+export type ParseLinkResult = {
+    ok: true;
+    value: LinkFrontmatter | null;
+} | {
+    ok: false;
+    errors: string[];
+};
+export interface LinkReference {
+    target?: string;
+    locale?: string;
+    slug: string;
+    key?: string;
+}
+export interface IndexedPage {
+    slug: string;
+    key?: string;
+    locale?: string;
+    path: string;
+    title?: string;
+    keywords?: {
+        primary?: string;
+        secondary?: string[];
+    };
+    linksTo: string[];
+    linkedFrom: string[];
+    aliases: string[];
+    linkRefs: LinkReference[];
+    linkedFromRefs: LinkReference[];
+}
+export interface LinkAliasEntry {
+    alias: string;
+    locale?: string;
+    replacement: string;
+    page: IndexedPage;
+}
+export interface LinkIndex {
+    pages: Map<string, IndexedPage>;
+    aliases: Map<string, string>;
+    aliasEntries: LinkAliasEntry[];
+    options: Required<Pick<LinkResolverOptions, 'resolve'>> & Omit<LinkResolverOptions, 'resolve'>;
+}
+export interface LinkInput {
+    path: string;
+    data: Record<string, unknown>;
+}
+export interface SerializedLinkIndex {
+    pages: Array<Omit<IndexedPage, 'linkRefs' | 'linkedFromRefs' | 'linksTo' | 'linkedFrom'> & {
+        linksTo: string[] | LinkReference[];
+        linkedFrom: string[] | LinkReference[];
+    }>;
+    aliases: Record<string, string | LinkReference>;
+}
+export interface LinkDiagnostic {
+    file: string;
+    diagnostic: Diagnostic;
+}
+export declare function parseLinkFrontmatter(data: Record<string, unknown>, options?: LinkResolverOptions): ParseLinkResult;
+export declare function buildLinkIndex(inputs: LinkInput[], options?: LinkResolverOptions): LinkIndex;
+export declare function serializeLinkIndex(index: LinkIndex): SerializedLinkIndex;
+export declare function aliasReplacementsForPage(index: LinkIndex, data: Record<string, unknown>): Map<string, string>;
+export declare function validateLinks(inputs: LinkInput[], options?: LinkResolverOptions): LinkDiagnostic[];
+export {};
+//# sourceMappingURL=links.d.ts.map

package/dist/links.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"links.d.ts","sourceRoot":"","sources":["../src/links.ts"],"names":[],"mappings":"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"}

package/dist/links.js

@@ -0,0 +1,435 @@
+import { z } from 'zod';
+const Keywords = z.object({
+    primary: z.string().optional(),
+    secondary: z.array(z.string()).optional(),
+});
+const LinkTarget = z.union([
+    z.string(),
+    z
+        .object({
+        slug: z.string().min(1).optional(),
+        key: z.string().min(1).optional(),
+        locale: z.string().min(1).optional(),
+    })
+        .refine((target) => target.slug || target.key, {
+        message: 'object linksTo targets must include slug or key',
+    }),
+]);
+const LinkFrontmatter = z.object({
+    slug: z.string().min(1),
+    key: z.string().min(1).optional(),
+    locale: z.string().min(1).optional(),
+    title: z.string().optional(),
+    linksTo: z.array(LinkTarget).optional(),
+    aliases: z.array(z.string()).optional(),
+    keywords: Keywords.optional(),
+});
+const DEFAULT_OPTIONS = {
+    resolve: 'global-slug',
+};
+const FM_POSITION = {
+    start: { line: 1, column: 1, offset: 0 },
+    end: { line: 1, column: 1, offset: 0 },
+};
+// Returns { value: null } when there is no `slug` (a non-participating page),
+// parsed data when the link shape is valid, or shape errors otherwise. Never
+// throws — callers turn errors into diagnostics.
+export function parseLinkFrontmatter(data, options = {}) {
+    const normalized = normalizeFrontmatter(data, options);
+    if (!('slug' in normalized))
+        return { ok: true, value: null };
+    const parsed = LinkFrontmatter.safeParse(normalized);
+    if (parsed.success)
+        return { ok: true, value: parsed.data };
+    return { ok: false, errors: parsed.error.issues.map((i) => `${i.path.join('.')}: ${i.message}`) };
+}
+// Pure: builds the resolved link graph from per-file frontmatter data. Pass 1
+// collects pages and registers aliases; pass 2 resolves each linksTo through
+// the configured identity maps and inverts edges to derive linkedFrom.
+export function buildLinkIndex(inputs, options = {}) {
+    const resolvedOptions = { ...DEFAULT_OPTIONS, ...options };
+    const pages = new Map();
+    const aliases = new Map();
+    const aliasEntries = [];
+    for (const { path, data } of inputs) {
+        const parsed = parseLinkFrontmatter(data, resolvedOptions);
+        if (!parsed.ok || parsed.value === null)
+            continue;
+        const fm = parsed.value;
+        const page = {
+            slug: fm.slug,
+            key: fm.key,
+            locale: effectiveLocale(fm, resolvedOptions),
+            path,
+            title: fm.title,
+            keywords: fm.keywords,
+            linksTo: [],
+            linkedFrom: [],
+            aliases: fm.aliases ?? [],
+            linkRefs: [],
+            linkedFromRefs: [],
+        };
+        pages.set(pageMapKey(page, resolvedOptions), page);
+    }
+    for (const page of pages.values()) {
+        for (const alias of page.aliases) {
+            const replacement = replacementFor(page, resolvedOptions);
+            const key = aliasMapKey(alias, page.locale, resolvedOptions);
+            aliases.set(key, replacement);
+            aliasEntries.push({ alias, locale: page.locale, replacement, page });
+        }
+    }
+    const lookup = buildLookup(pages, resolvedOptions);
+    for (const page of pages.values()) {
+        const source = parseLinkFrontmatter(inputForPage(page, inputs, resolvedOptions), resolvedOptions);
+        if (!source.ok || source.value === null)
+            continue;
+        for (const rawTarget of source.value.linksTo ?? []) {
+            const resolved = resolveTarget(rawTarget, page, lookup, resolvedOptions);
+            if (!resolved.page) {
+                page.linksTo.push(resolved.target);
+                continue;
+            }
+            page.linksTo.push(replacementFor(resolved.page, resolvedOptions));
+            page.linkRefs.push(referenceFor(resolved.page, resolved.target));
+            if (resolved.page === page)
+                continue;
+            const from = replacementFor(page, resolvedOptions);
+            if (!resolved.page.linkedFrom.includes(from))
+                resolved.page.linkedFrom.push(from);
+            if (!resolved.page.linkedFromRefs.some((r) => sameReference(r, page))) {
+                resolved.page.linkedFromRefs.push(referenceFor(page));
+            }
+        }
+    }
+    return { pages, aliases, aliasEntries, options: resolvedOptions };
+}
+// Stable, sorted JSON form for .contentbit/link-index.json. Global-slug projects
+// keep the original compact string arrays; locale/key projects receive richer
+// references so agents can see which local target was resolved.
+export function serializeLinkIndex(index) {
+    const scoped = [...index.pages.values()].some((page) => page.locale || page.key);
+    const pages = [...index.pages.values()]
+        .map((p) => {
+        const base = {
+            slug: p.slug,
+            ...(p.key ? { key: p.key } : {}),
+            ...(p.locale ? { locale: p.locale } : {}),
+            path: p.path,
+            ...(p.title ? { title: p.title } : {}),
+            ...(p.keywords ? { keywords: p.keywords } : {}),
+            linksTo: scoped ? p.linkRefs : [...p.linksTo],
+            linkedFrom: scoped ? sortedRefs(p.linkedFromRefs) : [...p.linkedFrom].sort(),
+            aliases: [...p.aliases],
+        };
+        return base;
+    })
+        .sort((a, b) => sortIdentity(a.locale, a.slug).localeCompare(sortIdentity(b.locale, b.slug)));
+    const aliases = {};
+    if (scoped) {
+        for (const entry of [...index.aliasEntries].sort((a, b) => sortIdentity(a.locale, a.alias).localeCompare(sortIdentity(b.locale, b.alias)))) {
+            aliases[aliasMapKey(entry.alias, entry.locale, index.options)] = referenceFor(entry.page);
+        }
+    }
+    else {
+        for (const key of [...index.aliases.keys()].sort())
+            aliases[key] = index.aliases.get(key);
+    }
+    return { pages, aliases };
+}
+export function aliasReplacementsForPage(index, data) {
+    const parsed = parseLinkFrontmatter(data, index.options);
+    const out = new Map();
+    if (!parsed.ok || parsed.value === null)
+        return out;
+    const locale = effectiveLocale(parsed.value, index.options);
+    for (const entry of index.aliasEntries) {
+        if (index.options.resolve === 'global-slug' || entry.locale === locale) {
+            out.set(entry.alias, entry.replacement);
+        }
+    }
+    return out;
+}
+// Cross-file link validation. Emits shape errors, duplicate-slug and
+// alias-conflict errors, dangling-link errors (with did-you-mean), and
+// self-link / orphan warnings. Returns file-tagged diagnostics so the CLI can
+// format each with its own filename.
+export function validateLinks(inputs, options = {}) {
+    const resolvedOptions = { ...DEFAULT_OPTIONS, ...options };
+    const out = [];
+    const validInputs = [];
+    const seenSlug = new Map(); // identity -> first file
+    const seenKey = new Map(); // identity -> first file
+    const seenAlias = new Map(); // identity -> file
+    // Shape + duplicate/alias-conflict pass (operates on raw inputs).
+    for (const { path, data } of inputs) {
+        const parsed = parseLinkFrontmatter(data, resolvedOptions);
+        if (!parsed.ok) {
+            for (const e of parsed.errors)
+                out.push(diag(path, 'CB_LINK_SHAPE', 'error', `invalid link frontmatter: ${e}`));
+            continue;
+        }
+        if (parsed.value === null)
+            continue;
+        const fm = parsed.value;
+        const locale = effectiveLocale(fm, resolvedOptions);
+        validInputs.push({ path, fm });
+        const slugKey = scopedKey(fm.slug, locale, resolvedOptions);
+        const prior = seenSlug.get(slugKey);
+        if (prior)
+            out.push(diag(path, 'CB_SLUG_DUPLICATE', 'error', `slug "${fm.slug}" also used by ${prior}`));
+        else
+            seenSlug.set(slugKey, path);
+        if (usesKeyResolution(resolvedOptions) && !fm.key) {
+            out.push(diag(path, 'CB_KEY_MISSING', 'error', `page "${fm.slug}" is missing key`));
+        }
+        if (fm.key) {
+            const keyKey = scopedKey(fm.key, locale, resolvedOptions);
+            const priorKey = seenKey.get(keyKey);
+            if (priorKey)
+                out.push(diag(path, 'CB_KEY_DUPLICATE', 'error', `key "${fm.key}" also used by ${priorKey}`));
+            else
+                seenKey.set(keyKey, path);
+        }
+        for (const alias of fm.aliases ?? []) {
+            const aliasKey = scopedKey(alias, locale, resolvedOptions);
+            if (seenAlias.has(aliasKey))
+                out.push(diag(path, 'CB_ALIAS_CONFLICT', 'error', `alias "${alias}" already declared by ${seenAlias.get(aliasKey)}`));
+            else
+                seenAlias.set(aliasKey, path);
+        }
+    }
+    const index = buildLinkIndex(inputs, resolvedOptions);
+    const lookup = buildLookup(index.pages, resolvedOptions);
+    for (const { path, fm } of validInputs) {
+        const page = index.pages.get(pageMapKey(frontmatterIdentity(fm, resolvedOptions), resolvedOptions));
+        if (!page)
+            continue;
+        // alias colliding with a real slug/key in the same scope
+        for (const alias of page.aliases) {
+            if (collidesWithPageIdentity(alias, page.locale, lookup, resolvedOptions))
+                out.push(diag(page.path, 'CB_ALIAS_CONFLICT', 'error', `alias "${alias}" collides with an existing page identity`));
+        }
+        for (const target of fm.linksTo ?? []) {
+            const resolved = resolveTarget(target, page, lookup, resolvedOptions);
+            if (resolved.page === page) {
+                out.push(diag(page.path, 'CB_LINK_SELF', 'warning', `page "${page.slug}" links to itself`));
+                continue;
+            }
+            if (resolved.page && resolved.crossLocale) {
+                out.push(diag(page.path, 'CB_LINK_CROSS_LOCALE', 'warning', `linksTo "${resolved.target}" resolves to locale "${resolved.page.locale}"`));
+                continue;
+            }
+            if (!resolved.page) {
+                if (targetExistsOutsideLocale(resolved.target, page.locale, lookup, resolvedOptions)) {
+                    out.push(diag(page.path, 'CB_LINK_LOCALE_MISSING', 'error', `linksTo "${resolved.target}" exists in another locale but not "${page.locale ?? 'default'}"`));
+                    continue;
+                }
+                const hint = closest(resolved.target, candidatesFor(page.locale, lookup, resolvedOptions));
+                out.push(diag(page.path, 'CB_LINK_UNRESOLVED', 'error', `linksTo "${resolved.target}" does not resolve to any page`, hint ? `Did you mean "${hint}"?` : undefined));
+            }
+        }
+        if (page.linkedFrom.length === 0)
+            out.push(diag(page.path, 'CB_LINK_ORPHAN', 'warning', `page "${page.slug}" has no inbound links`));
+    }
+    return out;
+}
+function normalizeFrontmatter(data, options) {
+    const out = { ...data };
+    copyConfiguredField(out, data, options.slugField, 'slug');
+    copyConfiguredField(out, data, options.keyField, 'key');
+    copyConfiguredField(out, data, options.localeField, 'locale');
+    return out;
+}
+function copyConfiguredField(out, data, from, to) {
+    if (!from || from === to || !(from in data) || to in out)
+        return;
+    out[to] = data[from];
+}
+function effectiveLocale(fm, options) {
+    return fm.locale ?? options.defaultLocale;
+}
+function frontmatterIdentity(fm, options) {
+    return { slug: fm.slug, key: fm.key, locale: effectiveLocale(fm, options) };
+}
+function pageMapKey(page, options) {
+    if (options.resolve === 'global-slug')
+        return page.slug;
+    return scopedKey(page.slug, page.locale, options);
+}
+function scopedKey(value, locale, options) {
+    if (options.resolve === 'global-slug')
+        return value;
+    return `${locale ?? ''}\0${value}`;
+}
+function aliasMapKey(alias, locale, options) {
+    return options.resolve === 'global-slug' ? alias : `${locale ?? ''}:${alias}`;
+}
+function replacementFor(page, options) {
+    if (options.resolve === 'same-locale-key')
+        return page.key ?? page.slug;
+    if (options.resolve === 'prefer-same-locale-key-fallback-slug')
+        return page.key ?? page.slug;
+    return page.slug;
+}
+function referenceFor(page, target) {
+    return {
+        ...(target ? { target } : {}),
+        ...(page.locale ? { locale: page.locale } : {}),
+        slug: page.slug,
+        ...(page.key ? { key: page.key } : {}),
+    };
+}
+function sameReference(ref, page) {
+    return ref.slug === page.slug && ref.locale === page.locale && ref.key === page.key;
+}
+function sortedRefs(refs) {
+    return [...refs].sort((a, b) => sortIdentity(a.locale, a.key ?? a.slug).localeCompare(sortIdentity(b.locale, b.key ?? b.slug)));
+}
+function sortIdentity(locale, value) {
+    return `${locale ?? ''}\0${value}`;
+}
+function buildLookup(pages, options) {
+    const lookup = {
+        bySlug: new Map(),
+        byScopedSlug: new Map(),
+        byKey: new Map(),
+        byScopedKey: new Map(),
+        aliasBySlug: new Map(),
+        aliasByScopedSlug: new Map(),
+        aliasByKey: new Map(),
+        aliasByScopedKey: new Map(),
+    };
+    for (const page of pages.values()) {
+        pushMulti(lookup.bySlug, page.slug, page);
+        lookup.byScopedSlug.set(scopedKey(page.slug, page.locale, options), page);
+        if (page.key) {
+            pushMulti(lookup.byKey, page.key, page);
+            lookup.byScopedKey.set(scopedKey(page.key, page.locale, options), page);
+        }
+        for (const alias of page.aliases) {
+            lookup.aliasBySlug.set(alias, page);
+            lookup.aliasByScopedSlug.set(scopedKey(alias, page.locale, options), page);
+            if (page.key) {
+                lookup.aliasByKey.set(alias, page);
+                lookup.aliasByScopedKey.set(scopedKey(alias, page.locale, options), page);
+            }
+        }
+    }
+    return lookup;
+}
+function pushMulti(map, key, page) {
+    const existing = map.get(key);
+    if (existing)
+        existing.push(page);
+    else
+        map.set(key, [page]);
+}
+function resolveTarget(rawTarget, source, lookup, options) {
+    if (typeof rawTarget !== 'string') {
+        const locale = rawTarget.locale ?? source.locale;
+        const page = rawTarget.key
+            ? lookup.byScopedKey.get(scopedKey(rawTarget.key, locale, options))
+            : rawTarget.slug
+                ? lookup.byScopedSlug.get(scopedKey(rawTarget.slug, locale, options))
+                : undefined;
+        const target = rawTarget.key ?? rawTarget.slug ?? '';
+        return {
+            page,
+            target,
+            explicitLocale: rawTarget.locale,
+            crossLocale: Boolean(page && rawTarget.locale && rawTarget.locale !== source.locale),
+            matchedBy: rawTarget.key ? 'key' : 'slug',
+        };
+    }
+    const locale = source.locale;
+    if (options.resolve === 'global-slug') {
+        const page = lookup.aliasBySlug.get(rawTarget) ?? single(lookup.bySlug.get(rawTarget));
+        return { page, target: rawTarget, crossLocale: false, matchedBy: page ? 'slug' : undefined };
+    }
+    if (options.resolve === 'same-locale-key') {
+        const scoped = scopedKey(rawTarget, locale, options);
+        const page = lookup.byScopedKey.get(scoped) ?? lookup.aliasByScopedKey.get(scoped);
+        return { page, target: rawTarget, crossLocale: false, matchedBy: page ? 'key' : undefined };
+    }
+    if (options.resolve === 'prefer-same-locale-key-fallback-slug') {
+        const scoped = scopedKey(rawTarget, locale, options);
+        const page = lookup.byScopedKey.get(scoped) ??
+            lookup.aliasByScopedKey.get(scoped) ??
+            lookup.byScopedSlug.get(scoped) ??
+            lookup.aliasByScopedSlug.get(scoped);
+        return { page, target: rawTarget, crossLocale: false, matchedBy: page ? 'key' : undefined };
+    }
+    const scoped = scopedKey(rawTarget, locale, options);
+    const page = lookup.byScopedSlug.get(scoped) ?? lookup.aliasByScopedSlug.get(scoped);
+    return { page, target: rawTarget, crossLocale: false, matchedBy: page ? 'slug' : undefined };
+}
+function single(values) {
+    return values?.length === 1 ? values[0] : undefined;
+}
+function usesKeyResolution(options) {
+    return options.resolve === 'same-locale-key';
+}
+function collidesWithPageIdentity(alias, locale, lookup, options) {
+    if (options.resolve === 'global-slug')
+        return lookup.bySlug.has(alias);
+    const scoped = scopedKey(alias, locale, options);
+    return (lookup.byScopedSlug.has(scoped) ||
+        (usesKeyResolution(options) && lookup.byScopedKey.has(scoped)));
+}
+function targetExistsOutsideLocale(target, locale, lookup, options) {
+    if (options.resolve === 'global-slug')
+        return false;
+    const byIdentity = usesKeyResolution(options) ? lookup.byKey : lookup.bySlug;
+    return (byIdentity.get(target) ?? []).some((page) => page.locale !== locale);
+}
+function candidatesFor(locale, lookup, options) {
+    if (options.resolve === 'global-slug')
+        return [...lookup.bySlug.keys()];
+    const out = [];
+    for (const page of lookup.byScopedSlug.values()) {
+        if (page.locale === locale)
+            out.push(usesKeyResolution(options) && page.key ? page.key : page.slug);
+    }
+    return out;
+}
+function inputForPage(page, inputs, options) {
+    for (const input of inputs) {
+        const parsed = parseLinkFrontmatter(input.data, options);
+        if (!parsed.ok || parsed.value === null)
+            continue;
+        const identity = frontmatterIdentity(parsed.value, options);
+        if (pageMapKey(identity, options) === pageMapKey(page, options))
+            return input.data;
+    }
+    return {};
+}
+function diag(file, code, severity, message, hint) {
+    return { file, diagnostic: { code, severity, message, hint, position: FM_POSITION } };
+}
+// Levenshtein distance for did-you-mean hints. Small inputs (slugs), so the
+// simple O(n*m) matrix is fine.
+function editDistance(a, b) {
+    const dp = Array.from({ length: a.length + 1 }, (_, i) => [i, ...Array(b.length).fill(0)]);
+    for (let j = 0; j <= b.length; j++)
+        dp[0][j] = j;
+    for (let i = 1; i <= a.length; i++) {
+        for (let j = 1; j <= b.length; j++) {
+            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+            dp[i][j] = Math.min(dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1] + cost);
+        }
+    }
+    return dp[a.length][b.length];
+}
+function closest(target, candidates) {
+    let best;
+    let bestD = Infinity;
+    for (const c of candidates) {
+        const d = editDistance(target, c);
+        if (d < bestD) {
+            bestD = d;
+            best = c;
+        }
+    }
+    return best && bestD <= Math.max(2, Math.floor(target.length / 3)) ? best : undefined;
+}

package/dist/version.d.ts

@@ -1,2 +1,2 @@
-export declare const VERSION = "0.1.0";
+export declare const VERSION = "0.2.0";
 //# sourceMappingURL=version.d.ts.map

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '0.1.0';
+export const VERSION = '0.2.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentbit/core",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Parser, validator, and registry for Content Blocks: structured Markdown components without framework lock-in.",
   "keywords": [
     "ast",