@anydocs/core 1.0.0

package/dist/publishing/build-openapi-artifacts.js

@@ -0,0 +1,253 @@
+import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { createApiSourceRepository, listApiSources } from "../fs/api-source-repository.js";
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+async function writeJson(filePath, value) {
+    await mkdir(path.dirname(filePath), { recursive: true });
+    await writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
+}
+async function writeText(filePath, value) {
+    await mkdir(path.dirname(filePath), { recursive: true });
+    await writeFile(filePath, `${value}\n`, 'utf8');
+}
+async function cleanupOpenApiArtifacts(root) {
+    await rm(root, { recursive: true, force: true });
+    await mkdir(root, { recursive: true });
+}
+async function resolveSourcePayload(contract, source) {
+    if (source.source.kind === 'url') {
+        const response = await fetch(source.source.url);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch api source "${source.id}" from "${source.source.url}": ${response.status} ${response.statusText}`);
+        }
+        return response.json();
+    }
+    const targetPath = path.isAbsolute(source.source.path)
+        ? source.source.path
+        : path.join(contract.paths.projectRoot, source.source.path);
+    return JSON.parse(await readFile(targetPath, 'utf8'));
+}
+function normalizeRouteBase(source) {
+    if (source.runtime?.routeBase) {
+        return source.runtime.routeBase.startsWith('/') ? source.runtime.routeBase : `/${source.runtime.routeBase}`;
+    }
+    return `/${source.lang}/reference/${source.id}`;
+}
+function schemaToText(schema) {
+    if (!isRecord(schema)) {
+        return 'unknown';
+    }
+    if (typeof schema.$ref === 'string') {
+        return schema.$ref.split('/').at(-1) ?? schema.$ref;
+    }
+    if (schema.type === 'array') {
+        return `array<${schemaToText(schema.items)}>`;
+    }
+    if (Array.isArray(schema.oneOf)) {
+        return schema.oneOf.map((item) => schemaToText(item)).join(' | ');
+    }
+    if (Array.isArray(schema.allOf)) {
+        return schema.allOf.map((item) => schemaToText(item)).join(' & ');
+    }
+    if (Array.isArray(schema.anyOf)) {
+        return schema.anyOf.map((item) => schemaToText(item)).join(' | ');
+    }
+    if (typeof schema.type === 'string') {
+        return typeof schema.format === 'string' ? `${schema.type}(${schema.format})` : schema.type;
+    }
+    return 'object';
+}
+function collectSchemaRefs(node, refs = new Set()) {
+    if (Array.isArray(node)) {
+        for (const item of node) {
+            collectSchemaRefs(item, refs);
+        }
+        return refs;
+    }
+    if (!isRecord(node)) {
+        return refs;
+    }
+    if (typeof node.$ref === 'string') {
+        refs.add(node.$ref.split('/').at(-1) ?? node.$ref);
+    }
+    for (const value of Object.values(node)) {
+        collectSchemaRefs(value, refs);
+    }
+    return refs;
+}
+function toOperationId(method, endpointPath, operation) {
+    if (typeof operation.operationId === 'string' && operation.operationId.trim().length > 0) {
+        return operation.operationId.trim();
+    }
+    return `${method.toLowerCase()}-${endpointPath.replace(/[^a-zA-Z0-9]+/g, '-').replace(/^-|-$/g, '')}`;
+}
+function toOperationDocs(source, spec) {
+    const routeBase = normalizeRouteBase(source);
+    const rawPaths = isRecord(spec.paths) ? spec.paths : {};
+    const rawSchemas = isRecord(spec.components) && isRecord(spec.components.schemas) ? spec.components.schemas : {};
+    const operations = [];
+    const operationIdsBySchema = new Map();
+    for (const [endpointPath, rawMethods] of Object.entries(rawPaths)) {
+        if (!isRecord(rawMethods)) {
+            continue;
+        }
+        for (const [method, rawOperation] of Object.entries(rawMethods)) {
+            if (!isRecord(rawOperation)) {
+                continue;
+            }
+            const operationId = toOperationId(method, endpointPath, rawOperation);
+            const summary = typeof rawOperation.summary === 'string' && rawOperation.summary.trim().length > 0
+                ? rawOperation.summary.trim()
+                : `${method.toUpperCase()} ${endpointPath}`;
+            const description = typeof rawOperation.description === 'string' && rawOperation.description.trim().length > 0
+                ? rawOperation.description.trim()
+                : summary;
+            const tag = Array.isArray(rawOperation.tags) && typeof rawOperation.tags[0] === 'string'
+                ? rawOperation.tags[0]
+                : 'Untagged';
+            const schemaRefs = [...collectSchemaRefs(rawOperation)].sort((left, right) => left.localeCompare(right));
+            for (const ref of schemaRefs) {
+                if (!operationIdsBySchema.has(ref)) {
+                    operationIdsBySchema.set(ref, new Set());
+                }
+                operationIdsBySchema.get(ref)?.add(operationId);
+            }
+            const plainText = [
+                `${method.toUpperCase()} ${endpointPath}`,
+                summary,
+                description,
+                `tag ${tag}`,
+                ...(schemaRefs.length > 0 ? [`schemas ${schemaRefs.join(', ')}`] : []),
+            ].join('. ');
+            operations.push({
+                id: operationId,
+                method: method.toUpperCase(),
+                path: endpointPath,
+                summary,
+                description,
+                tag,
+                schemaRefs,
+                href: routeBase,
+                plainText,
+            });
+        }
+    }
+    const schemas = Object.entries(rawSchemas)
+        .filter(([, value]) => isRecord(value))
+        .map(([name, rawSchema]) => {
+        const schemaRecord = rawSchema;
+        const properties = isRecord(schemaRecord.properties) ? schemaRecord.properties : {};
+        const propertyDocs = Object.entries(properties).map(([propertyName, propertySchema]) => ({
+            name: propertyName,
+            type: schemaToText(propertySchema),
+            description: isRecord(propertySchema) && typeof propertySchema.description === 'string'
+                ? propertySchema.description
+                : '',
+        }));
+        const required = Array.isArray(schemaRecord.required)
+            ? schemaRecord.required.filter((entry) => typeof entry === 'string')
+            : [];
+        const usedByOperations = [...(operationIdsBySchema.get(name) ?? new Set())].sort((left, right) => left.localeCompare(right));
+        const plainText = [
+            name,
+            `type ${typeof schemaRecord.type === 'string' ? schemaRecord.type : 'object'}`,
+            ...(required.length > 0 ? [`required ${required.join(', ')}`] : []),
+            ...(propertyDocs.length > 0
+                ? [`properties ${propertyDocs.map((property) => `${property.name}:${property.type}`).join(', ')}`]
+                : []),
+        ].join('. ');
+        return {
+            name,
+            type: typeof schemaRecord.type === 'string' ? schemaRecord.type : 'object',
+            required,
+            properties: propertyDocs,
+            usedByOperations,
+            plainText,
+        };
+    })
+        .sort((left, right) => left.name.localeCompare(right.name));
+    const chunks = [
+        ...operations.map((operation) => ({
+            id: `${source.id}:${operation.id}:summary`,
+            entityType: 'operation',
+            entityId: operation.id,
+            title: operation.summary,
+            text: operation.plainText,
+            href: routeBase,
+        })),
+        ...schemas.map((schema) => ({
+            id: `${source.id}:${schema.name}:schema`,
+            entityType: 'schema',
+            entityId: schema.name,
+            title: schema.name,
+            text: schema.plainText,
+            href: routeBase,
+        })),
+    ];
+    const sourceIndex = {
+        id: source.id,
+        title: source.display.title,
+        lang: source.lang,
+        href: routeBase,
+        operationCount: operations.length,
+        schemaCount: schemas.length,
+    };
+    return { operations, schemas, chunks, sourceIndex };
+}
+function buildLlmsOpenApiTxt(indexesByLanguage) {
+    const lines = ['# OpenAPI Sources', ''];
+    for (const [lang, sources] of Object.entries(indexesByLanguage).sort(([left], [right]) => left.localeCompare(right))) {
+        lines.push(`## ${lang}`);
+        lines.push('');
+        for (const source of sources) {
+            lines.push(`- ${source.title} — ${source.href} — operations: ${source.operationCount}, schemas: ${source.schemaCount}`);
+        }
+        lines.push('');
+    }
+    return lines.join('\n').trimEnd();
+}
+export async function writePublishedOpenApiArtifacts(contract) {
+    const repository = createApiSourceRepository(contract.paths.projectRoot);
+    const publishedSources = await listApiSources(repository, { status: 'published' });
+    const openApiRoot = path.join(contract.paths.machineReadableRoot, 'openapi');
+    await cleanupOpenApiArtifacts(openApiRoot);
+    const indexesByLanguage = Object.fromEntries(contract.config.languages.map((lang) => [lang, []]));
+    for (const source of publishedSources) {
+        const rawSpec = await resolveSourcePayload(contract, source);
+        if (!isRecord(rawSpec)) {
+            continue;
+        }
+        const { operations, schemas, chunks, sourceIndex } = toOperationDocs(source, rawSpec);
+        indexesByLanguage[source.lang]?.push(sourceIndex);
+        await writeJson(path.join(openApiRoot, `source.${source.id}.json`), rawSpec);
+        await writeJson(path.join(openApiRoot, `operations.${source.id}.${source.lang}.json`), {
+            version: 1,
+            sourceId: source.id,
+            items: operations,
+        });
+        await writeJson(path.join(openApiRoot, `schemas.${source.id}.${source.lang}.json`), {
+            version: 1,
+            sourceId: source.id,
+            items: schemas,
+        });
+        await writeJson(path.join(openApiRoot, `chunks.${source.id}.${source.lang}.json`), {
+            version: 1,
+            sourceId: source.id,
+            items: chunks,
+        });
+    }
+    for (const lang of contract.config.languages) {
+        await writeJson(path.join(openApiRoot, `index.${lang}.json`), {
+            version: 1,
+            sources: indexesByLanguage[lang] ?? [],
+        });
+    }
+    const hasPublishedSources = Object.values(indexesByLanguage).some((sources) => sources.length > 0);
+    if (!hasPublishedSources) {
+        await rm(path.join(contract.paths.artifactRoot, 'llms-openapi.txt'), { force: true });
+        return;
+    }
+    await writeText(path.join(contract.paths.artifactRoot, 'llms-openapi.txt'), buildLlmsOpenApiTxt(indexesByLanguage));
+}

package/dist/publishing/index.d.ts

@@ -0,0 +1,4 @@
+export * from './build-artifacts.ts';
+export * from './build-openapi-artifacts.ts';
+export * from './publication-filter.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/publishing/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/publishing/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,yBAAyB,CAAC"}

package/dist/publishing/index.js

@@ -0,0 +1,3 @@
+export * from "./build-artifacts.js";
+export * from "./build-openapi-artifacts.js";
+export * from "./publication-filter.js";

package/dist/publishing/publication-filter.d.ts

@@ -0,0 +1,22 @@
+import type { DocsLang, NavigationDoc, NavItem, PageDoc } from '../types/docs.ts';
+export type PublishedLanguageContent<TContent = unknown> = {
+    navigation: NavigationDoc;
+    pages: PageDoc<TContent>[];
+};
+export type PublishedRoute = {
+    pageId: string;
+    slug: string;
+    segments: string[];
+    href: string;
+    title: string;
+};
+export type PublishedSiteLanguageContent<TContent = unknown> = PublishedLanguageContent<TContent> & {
+    routes: PublishedRoute[];
+};
+export declare function isPageApprovedForPublication<TContent>(page: PageDoc<TContent>): boolean;
+export declare function filterPublishedPages<TContent>(pages: PageDoc<TContent>[]): PageDoc<TContent>[];
+export declare function filterNavigationToPublished(items: NavItem[], publishedPageIds: Set<string>): NavItem[];
+export declare function buildPublishedLanguageContent<TContent>(navigation: NavigationDoc, pages: PageDoc<TContent>[]): PublishedLanguageContent<TContent>;
+export declare function orderPublishedPagesByNavigation<TContent>(navigation: NavigationDoc, pages: PageDoc<TContent>[]): PageDoc<TContent>[];
+export declare function buildPublishedSiteLanguageContent<TContent>(lang: DocsLang, navigation: NavigationDoc, pages: PageDoc<TContent>[]): PublishedSiteLanguageContent<TContent>;
+//# sourceMappingURL=publication-filter.d.ts.map

package/dist/publishing/publication-filter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"publication-filter.d.ts","sourceRoot":"","sources":["../../src/publishing/publication-filter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,aAAa,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAElF,MAAM,MAAM,wBAAwB,CAAC,QAAQ,GAAG,OAAO,IAAI;IACzD,UAAU,EAAE,aAAa,CAAC;IAC1B,KAAK,EAAE,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;CAC5B,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,4BAA4B,CAAC,QAAQ,GAAG,OAAO,IAAI,wBAAwB,CAAC,QAAQ,CAAC,GAAG;IAClG,MAAM,EAAE,cAAc,EAAE,CAAC;CAC1B,CAAC;AAEF,wBAAgB,4BAA4B,CAAC,QAAQ,EAAE,IAAI,EAAE,OAAO,CAAC,QAAQ,CAAC,GAAG,OAAO,CAUvF;AAED,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,KAAK,EAAE,OAAO,CAAC,QAAQ,CAAC,EAAE,GAAG,OAAO,CAAC,QAAQ,CAAC,EAAE,CAI9F;AAED,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,OAAO,EAAE,EAChB,gBAAgB,EAAE,GAAG,CAAC,MAAM,CAAC,GAC5B,OAAO,EAAE,CAyBX;AAED,wBAAgB,6BAA6B,CAAC,QAAQ,EACpD,UAAU,EAAE,aAAa,EACzB,KAAK,EAAE,OAAO,CAAC,QAAQ,CAAC,EAAE,GACzB,wBAAwB,CAAC,QAAQ,CAAC,CAWpC;AAqBD,wBAAgB,+BAA+B,CAAC,QAAQ,EACtD,UAAU,EAAE,aAAa,EACzB,KAAK,EAAE,OAAO,CAAC,QAAQ,CAAC,EAAE,GACzB,OAAO,CAAC,QAAQ,CAAC,EAAE,CA2BrB;AAED,wBAAgB,iCAAiC,CAAC,QAAQ,EACxD,IAAI,EAAE,QAAQ,EACd,UAAU,EAAE,aAAa,EACzB,KAAK,EAAE,OAAO,CAAC,QAAQ,CAAC,EAAE,GACzB,4BAA4B,CAAC,QAAQ,CAAC,CAexC"}

package/dist/publishing/publication-filter.js

@@ -0,0 +1,98 @@
+export function isPageApprovedForPublication(page) {
+    if (page.status !== 'published') {
+        return false;
+    }
+    if (!page.review?.required) {
+        return true;
+    }
+    return typeof page.review.approvedAt === 'string' && page.review.approvedAt.trim().length > 0;
+}
+export function filterPublishedPages(pages) {
+    return pages
+        .filter((page) => isPageApprovedForPublication(page))
+        .sort((left, right) => left.slug.localeCompare(right.slug));
+}
+export function filterNavigationToPublished(items, publishedPageIds) {
+    const filtered = [];
+    for (const item of items) {
+        if (item.type === 'page') {
+            if (publishedPageIds.has(item.pageId) && !item.hidden) {
+                filtered.push(item);
+            }
+            continue;
+        }
+        if (item.type === 'link') {
+            filtered.push(item);
+            continue;
+        }
+        const children = filterNavigationToPublished(item.children, publishedPageIds);
+        if (children.length === 0) {
+            continue;
+        }
+        filtered.push({ ...item, children });
+    }
+    return filtered;
+}
+export function buildPublishedLanguageContent(navigation, pages) {
+    const publishedPages = filterPublishedPages(pages);
+    const publishedPageIds = new Set(publishedPages.map((page) => page.id));
+    return {
+        navigation: {
+            version: navigation.version,
+            items: filterNavigationToPublished(navigation.items, publishedPageIds),
+        },
+        pages: publishedPages,
+    };
+}
+function collectNavigationPageIds(items) {
+    const orderedPageIds = [];
+    for (const item of items) {
+        if (item.type === 'page') {
+            orderedPageIds.push(item.pageId);
+            continue;
+        }
+        if (item.type === 'link') {
+            continue;
+        }
+        orderedPageIds.push(...collectNavigationPageIds(item.children));
+    }
+    return orderedPageIds;
+}
+export function orderPublishedPagesByNavigation(navigation, pages) {
+    const publishedContent = buildPublishedLanguageContent(navigation, pages);
+    const orderedPageIds = collectNavigationPageIds(publishedContent.navigation.items);
+    const pagesById = new Map(publishedContent.pages.map((page) => [page.id, page]));
+    const orderedPages = [];
+    const seen = new Set();
+    for (const pageId of orderedPageIds) {
+        const page = pagesById.get(pageId);
+        if (!page || seen.has(pageId)) {
+            continue;
+        }
+        seen.add(pageId);
+        orderedPages.push(page);
+    }
+    for (const page of publishedContent.pages) {
+        if (seen.has(page.id)) {
+            continue;
+        }
+        seen.add(page.id);
+        orderedPages.push(page);
+    }
+    return orderedPages;
+}
+export function buildPublishedSiteLanguageContent(lang, navigation, pages) {
+    const publishedContent = buildPublishedLanguageContent(navigation, pages);
+    const orderedPages = orderPublishedPagesByNavigation(navigation, pages);
+    return {
+        navigation: publishedContent.navigation,
+        pages: orderedPages,
+        routes: orderedPages.map((page) => ({
+            pageId: page.id,
+            slug: page.slug,
+            segments: page.slug.split('/').filter(Boolean),
+            href: `/${lang}/${page.slug}`,
+            title: page.title,
+        })),
+    };
+}

package/dist/schemas/api-source-schema.d.ts

@@ -0,0 +1,3 @@
+import type { ApiSourceDoc } from '../types/api-source.ts';
+export declare function validateApiSourceDoc(input: unknown): ApiSourceDoc;
+//# sourceMappingURL=api-source-schema.d.ts.map

package/dist/schemas/api-source-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-source-schema.d.ts","sourceRoot":"","sources":["../../src/schemas/api-source-schema.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAgK3D,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,YAAY,CA8CjE"}

package/dist/schemas/api-source-schema.js

@@ -0,0 +1,110 @@
+import { ValidationError } from "../errors/validation-error.js";
+import { isApiSourceStatus, isApiSourceType } from "../types/api-source.js";
+import { isDocsLang } from "../types/docs.js";
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function createApiSourceValidationError(rule, remediation, metadata) {
+    return new ValidationError(`API source validation failed for rule "${rule}".`, {
+        entity: 'api-source',
+        rule,
+        remediation,
+        metadata,
+    });
+}
+function assertNonEmptyString(value, rule, remediation, metadata) {
+    if (typeof value !== 'string' || value.trim().length === 0) {
+        throw createApiSourceValidationError(rule, remediation, {
+            ...metadata,
+            received: value,
+        });
+    }
+}
+function validateId(value) {
+    assertNonEmptyString(value, 'api-source-id-required', 'Provide a non-empty string for api source "id".');
+    const trimmed = value.trim();
+    if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(trimmed)) {
+        throw createApiSourceValidationError('api-source-id-format', 'Use lowercase letters, numbers, and hyphens only for api source ids.', { received: value });
+    }
+    return trimmed;
+}
+function validateSource(input) {
+    if (!isRecord(input) || typeof input.kind !== 'string') {
+        throw createApiSourceValidationError('api-source-source-object', 'Use an object with "kind" for api source "source".', { received: input });
+    }
+    if (input.kind === 'url') {
+        assertNonEmptyString(input.url, 'api-source-source-url-required', 'Provide a non-empty "url" when api source kind is "url".');
+        return {
+            kind: 'url',
+            url: input.url.trim(),
+        };
+    }
+    if (input.kind === 'file') {
+        assertNonEmptyString(input.path, 'api-source-source-path-required', 'Provide a non-empty "path" when api source kind is "file".');
+        return {
+            kind: 'file',
+            path: input.path.trim(),
+        };
+    }
+    throw createApiSourceValidationError('api-source-source-kind-supported', 'Use "url" or "file" for api source "source.kind".', { received: input.kind });
+}
+function validateDisplay(input) {
+    if (!isRecord(input)) {
+        throw createApiSourceValidationError('api-source-display-object', 'Use an object for api source "display".', { received: input });
+    }
+    assertNonEmptyString(input.title, 'api-source-display-title-required', 'Provide a non-empty title for api source display settings.');
+    if (input.groupId != null) {
+        assertNonEmptyString(input.groupId, 'api-source-display-group-id-string', 'Use a non-empty string for display.groupId when present.');
+    }
+    return {
+        title: input.title.trim(),
+        ...(typeof input.groupId === 'string' ? { groupId: input.groupId.trim() } : {}),
+    };
+}
+function validateRuntime(input) {
+    if (input == null) {
+        return undefined;
+    }
+    if (!isRecord(input)) {
+        throw createApiSourceValidationError('api-source-runtime-object', 'Use an object for api source "runtime" when present.', { received: input });
+    }
+    if (input.routeBase != null) {
+        assertNonEmptyString(input.routeBase, 'api-source-runtime-route-base-string', 'Use a non-empty string for runtime.routeBase when present.');
+    }
+    if (input.tryIt != null) {
+        if (!isRecord(input.tryIt) || typeof input.tryIt.enabled !== 'boolean') {
+            throw createApiSourceValidationError('api-source-runtime-try-it-object', 'Use an object with a boolean "enabled" for runtime.tryIt when present.', { received: input.tryIt });
+        }
+    }
+    return {
+        ...(typeof input.routeBase === 'string' ? { routeBase: input.routeBase.trim() } : {}),
+        ...(isRecord(input.tryIt) && typeof input.tryIt.enabled === 'boolean'
+            ? { tryIt: { enabled: input.tryIt.enabled } }
+            : {}),
+    };
+}
+export function validateApiSourceDoc(input) {
+    if (!isRecord(input)) {
+        throw createApiSourceValidationError('api-source-object', 'Ensure the api source document is a JSON object.', { received: input });
+    }
+    const id = validateId(input.id);
+    if (!isApiSourceType(input.type)) {
+        throw createApiSourceValidationError('api-source-type-supported', 'Use one of the supported api source types.', { received: input.type });
+    }
+    if (!isDocsLang(input.lang)) {
+        throw createApiSourceValidationError('api-source-lang-supported', 'Use a supported docs language for api sources.', { received: input.lang });
+    }
+    if (!isApiSourceStatus(input.status)) {
+        throw createApiSourceValidationError('api-source-status-supported', 'Use a supported api source status.', { received: input.status });
+    }
+    const runtime = validateRuntime(input.runtime);
+    return {
+        id,
+        type: input.type,
+        lang: input.lang,
+        status: input.status,
+        source: validateSource(input.source),
+        display: validateDisplay(input.display),
+        ...(runtime ? { runtime } : {}),
+    };
+}

package/dist/schemas/docs-schema.d.ts

@@ -0,0 +1,7 @@
+import { type NavigationDoc, type PageDoc } from '../types/docs.ts';
+export declare function validateNavigationDoc(input: unknown): NavigationDoc;
+export type PageDocValidationOptions = {
+    validateContent?: (content: unknown) => void;
+};
+export declare function validatePageDoc<TContent = unknown>(input: unknown, options?: PageDocValidationOptions): PageDoc<TContent>;
+//# sourceMappingURL=docs-schema.d.ts.map

package/dist/schemas/docs-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"docs-schema.d.ts","sourceRoot":"","sources":["../../src/schemas/docs-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,aAAa,EAClB,KAAK,OAAO,EAGb,MAAM,kBAAkB,CAAC;AA8T1B,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,GAAG,aAAa,CA+BnE;AAED,MAAM,MAAM,wBAAwB,GAAG;IACrC,eAAe,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC;CAC9C,CAAC;AAEF,wBAAgB,eAAe,CAAC,QAAQ,GAAG,OAAO,EAChD,KAAK,EAAE,OAAO,EACd,OAAO,GAAE,wBAA6B,GACrC,OAAO,CAAC,QAAQ,CAAC,CAwHnB"}