@anydocs/core 1.0.0

package/dist/services/authoring-service.js

@@ -0,0 +1,583 @@
+import path from 'node:path';
+import { ValidationError } from "../errors/validation-error.js";
+import { isPageApprovedForPublication } from "../publishing/publication-filter.js";
+import { validatePageDoc } from "../schemas/docs-schema.js";
+import { createDocsRepository, deletePage as deletePageFromRepository, findPageBySlug, listPages, loadPage, loadProjectContract, loadNavigation, updateProjectConfig, savePage, saveNavigation, } from "../fs/index.js";
+import { DOCS_YOOPTA_ALLOWED_MARKS, DOCS_YOOPTA_ALLOWED_TYPES, assertValidYooptaContentValue, normalizeSlug, renderYooptaContent, } from "../utils/index.js";
+function pageFilePath(projectRoot, lang, pageId) {
+    return path.join(projectRoot, 'pages', lang, `${pageId}.json`);
+}
+function currentTimestamp() {
+    return new Date().toISOString();
+}
+function assertValidAuthoringContent(content, pageId) {
+    try {
+        assertValidYooptaContentValue(content);
+    }
+    catch (error) {
+        throw new ValidationError('Page content must use the supported Yoopta block structure.', {
+            entity: 'page-doc',
+            rule: 'page-content-must-be-valid-yoopta',
+            remediation: 'Provide content as a Yoopta block map using supported block types, block ids, block value arrays, and numeric meta.order/meta.depth fields.',
+            metadata: {
+                pageId: pageId ?? null,
+                cause: error instanceof Error ? error.message : String(error),
+                allowedBlockTypes: [...DOCS_YOOPTA_ALLOWED_TYPES],
+                allowedMarks: [...DOCS_YOOPTA_ALLOWED_MARKS],
+            },
+        });
+    }
+}
+function ensureUniqueBatchPageIds(pageIds, rule) {
+    const seen = new Set();
+    for (const pageId of pageIds) {
+        if (!seen.has(pageId)) {
+            seen.add(pageId);
+            continue;
+        }
+        throw new ValidationError(`Duplicate page id "${pageId}" in batch operation.`, {
+            entity: 'page-doc',
+            rule,
+            remediation: 'Provide each page id at most once in a single batch request.',
+            metadata: { pageId },
+        });
+    }
+}
+function collectRequiredTopLevelGroupIds(contract) {
+    return (contract.config.site.navigation?.topNav ?? [])
+        .filter((item) => item.type === 'nav-group')
+        .map((item) => item.groupId);
+}
+function navigationFilePath(projectRoot, lang) {
+    return path.join(projectRoot, 'navigation', `${lang}.json`);
+}
+function createNavigationPathError(rule, remediation, metadata) {
+    return new ValidationError(`Navigation path validation failed for rule "${rule}".`, {
+        entity: 'navigation-doc',
+        rule,
+        remediation,
+        metadata,
+    });
+}
+function parseNavigationItemPath(pathValue, key) {
+    if (pathValue == null || pathValue.trim().length === 0) {
+        return [];
+    }
+    const segments = pathValue.split('/');
+    if (segments.some((segment) => !/^\d+$/.test(segment))) {
+        throw createNavigationPathError('navigation-item-path-format', `Provide "${key}" as slash-separated zero-based indexes, for example "0/1/2".`, { key, path: pathValue });
+    }
+    return segments.map((segment) => Number.parseInt(segment, 10));
+}
+function assertValidInsertIndex(index, length, key) {
+    if (!Number.isInteger(index) || index < 0 || index > length) {
+        throw createNavigationPathError('navigation-insert-index-range', `Provide "${key}" as an integer between 0 and ${length}.`, { key, index, maxInclusive: length });
+    }
+}
+function cloneNavItems(items) {
+    return items.map((item) => {
+        if (item.type === 'section' || item.type === 'folder') {
+            return {
+                ...item,
+                children: cloneNavItems(item.children),
+            };
+        }
+        return { ...item };
+    });
+}
+function updateNavItemsAtParent(items, parentPath, update, originalPath = '') {
+    if (parentPath.length === 0) {
+        return update(items);
+    }
+    const [index, ...rest] = parentPath;
+    const target = items[index];
+    const pathLabel = originalPath ? `${originalPath}/${index}` : String(index);
+    if (!target) {
+        throw createNavigationPathError('navigation-item-path-must-exist', 'Use an existing navigation item path.', { path: pathLabel });
+    }
+    if (target.type !== 'section' && target.type !== 'folder') {
+        throw createNavigationPathError('navigation-parent-path-must-target-group', 'Use a section or folder path as the navigation parent target.', { path: pathLabel, itemType: target.type });
+    }
+    const nextItems = [...items];
+    nextItems[index] = {
+        ...target,
+        children: updateNavItemsAtParent(target.children, rest, update, pathLabel),
+    };
+    return nextItems;
+}
+function removeNavItemAtPath(items, itemPath, originalPath = '') {
+    if (itemPath.length === 0) {
+        throw createNavigationPathError('navigation-item-path-required', 'Provide a non-empty navigation item path for delete or move operations.', { path: originalPath });
+    }
+    const [index, ...rest] = itemPath;
+    const pathLabel = originalPath ? `${originalPath}/${index}` : String(index);
+    const target = items[index];
+    if (!target) {
+        throw createNavigationPathError('navigation-item-path-must-exist', 'Use an existing navigation item path.', { path: pathLabel });
+    }
+    if (rest.length === 0) {
+        return {
+            items: items.filter((_, itemIndex) => itemIndex !== index),
+            removedItem: target,
+            parentPath: itemPath.slice(0, -1),
+            removedIndex: index,
+        };
+    }
+    if (target.type !== 'section' && target.type !== 'folder') {
+        throw createNavigationPathError('navigation-item-path-must-target-group-for-descendants', 'Only section and folder items can contain nested navigation children.', { path: pathLabel, itemType: target.type });
+    }
+    const nested = removeNavItemAtPath(target.children, rest, pathLabel);
+    const nextItems = [...items];
+    nextItems[index] = {
+        ...target,
+        children: nested.items,
+    };
+    return {
+        items: nextItems,
+        removedItem: nested.removedItem,
+        parentPath: [index, ...nested.parentPath],
+        removedIndex: nested.removedIndex,
+    };
+}
+function insertNavItemAtParent(items, parentPath, item, index) {
+    return updateNavItemsAtParent(items, parentPath, (children) => {
+        const nextChildren = [...children];
+        const insertIndex = index ?? nextChildren.length;
+        assertValidInsertIndex(insertIndex, nextChildren.length, 'index');
+        nextChildren.splice(insertIndex, 0, item);
+        return nextChildren;
+    });
+}
+function isSamePath(left, right) {
+    return left.length === right.length && left.every((segment, index) => segment === right[index]);
+}
+function isDescendantPath(pathValue, ancestor) {
+    return ancestor.length < pathValue.length && ancestor.every((segment, index) => segment === pathValue[index]);
+}
+async function loadAuthoringContext(projectRoot, lang) {
+    const contractResult = await loadProjectContract(projectRoot);
+    if (!contractResult.ok) {
+        throw contractResult.error;
+    }
+    const contract = contractResult.value;
+    if (!contract.config.languages.includes(lang)) {
+        throw new ValidationError(`Language "${lang}" is not enabled for the project.`, {
+            entity: 'page-doc',
+            rule: 'page-language-must-be-enabled-for-project',
+            remediation: 'Use one of the enabled languages from anydocs.config.json before mutating pages.',
+            metadata: {
+                lang,
+                enabledLanguages: contract.config.languages,
+                projectRoot: contract.paths.projectRoot,
+            },
+        });
+    }
+    return {
+        contract,
+        repository: createDocsRepository(contract.paths.projectRoot),
+    };
+}
+async function assertSlugAvailable(projectRoot, lang, pageId, slug, findExisting) {
+    const existing = await findExisting();
+    if (!existing || existing.id === pageId) {
+        return;
+    }
+    throw new ValidationError(`Duplicate slug "${slug}" detected.`, {
+        entity: 'page-doc',
+        rule: 'page-slug-unique-per-language',
+        remediation: 'Choose a unique slug for the page within the same language.',
+        metadata: {
+            pageId,
+            duplicatePageId: existing.id,
+            slug,
+            lang,
+            projectRoot,
+        },
+    });
+}
+function validateAndNormalizePageCandidate(page, lang) {
+    const validatedPage = validatePageDoc(page);
+    if (validatedPage.lang !== lang) {
+        throw new ValidationError(`Page language "${validatedPage.lang}" does not match requested language "${lang}".`, {
+            entity: 'page-doc',
+            rule: 'page-language-matches-target-language',
+            remediation: 'Save the page under the same language as its page.lang field.',
+            metadata: { pageId: validatedPage.id, pageLang: validatedPage.lang, targetLang: lang },
+        });
+    }
+    const slug = normalizeSlug(validatedPage.slug);
+    if (!slug) {
+        throw new ValidationError('Page slug is required.', {
+            entity: 'page-doc',
+            rule: 'page-slug-required',
+            remediation: 'Provide a non-empty slug before saving the page.',
+            metadata: { pageId: validatedPage.id },
+        });
+    }
+    const normalizedPage = {
+        ...validatedPage,
+        slug,
+    };
+    if (normalizedPage.status === 'published' && !isPageApprovedForPublication(normalizedPage)) {
+        throw new ValidationError('Page review must be explicitly approved before publication.', {
+            entity: 'page-doc',
+            rule: 'page-review-must-be-approved-before-publication',
+            remediation: 'Use the explicit approve-for-publication action on reviewed imported or AI-generated content before setting status to published.',
+            metadata: {
+                pageId: normalizedPage.id,
+                lang,
+                reviewRequired: normalizedPage.review?.required ?? false,
+                approvedAt: normalizedPage.review?.approvedAt ?? null,
+            },
+        });
+    }
+    return normalizedPage;
+}
+function resolveNextRender(existingPage, patch, regenerateRender) {
+    if (patch.render) {
+        return patch.render;
+    }
+    if (!regenerateRender) {
+        return existingPage.render;
+    }
+    const nextContent = 'content' in patch ? patch.content : existingPage.content;
+    return renderYooptaContent(nextContent);
+}
+function assertSlugAvailableInPageMap(pagesById, candidate, projectRoot, lang) {
+    const duplicate = [...pagesById.values()].find((page) => page.id !== candidate.id && page.slug === candidate.slug);
+    if (!duplicate) {
+        return;
+    }
+    throw new ValidationError(`Duplicate slug "${candidate.slug}" detected.`, {
+        entity: 'page-doc',
+        rule: 'page-slug-unique-per-language',
+        remediation: 'Choose a unique slug for the page within the same language.',
+        metadata: {
+            pageId: candidate.id,
+            duplicatePageId: duplicate.id,
+            slug: candidate.slug,
+            lang,
+            projectRoot,
+        },
+    });
+}
+async function persistBatchPages(repository, projectRoot, lang, pages) {
+    const persistedPages = [];
+    const files = [];
+    for (const page of pages) {
+        const persisted = await savePage(repository, lang, page);
+        persistedPages.push(persisted);
+        files.push(pageFilePath(projectRoot, lang, persisted.id));
+    }
+    return {
+        count: persistedPages.length,
+        files,
+        pages: persistedPages,
+    };
+}
+export async function createPage(input) {
+    assertValidAuthoringContent(input.page.content ?? {}, input.page.id);
+    const { contract, repository } = await loadAuthoringContext(input.projectRoot, input.lang);
+    const existingPage = await loadPage(repository, input.lang, input.page.id);
+    if (existingPage) {
+        throw new ValidationError(`Page "${input.page.id}" already exists.`, {
+            entity: 'page-doc',
+            rule: 'page-create-target-must-not-exist',
+            remediation: 'Use a new page id for page_create, or use page_update to modify an existing page.',
+            metadata: {
+                lang: input.lang,
+                pageId: input.page.id,
+                projectRoot: contract.paths.projectRoot,
+            },
+        });
+    }
+    await assertSlugAvailable(contract.paths.projectRoot, input.lang, input.page.id, input.page.slug, () => findPageBySlug(repository, input.lang, input.page.slug));
+    const page = await savePage(repository, input.lang, {
+        id: input.page.id,
+        lang: input.lang,
+        slug: input.page.slug,
+        title: input.page.title,
+        description: input.page.description,
+        tags: input.page.tags,
+        status: input.page.status ?? 'draft',
+        content: (input.page.content ?? {}),
+        render: input.page.render,
+        review: input.page.review,
+        updatedAt: currentTimestamp(),
+    });
+    return {
+        filePath: pageFilePath(contract.paths.projectRoot, input.lang, page.id),
+        page,
+    };
+}
+export async function createPagesBatch(input) {
+    const { contract, repository } = await loadAuthoringContext(input.projectRoot, input.lang);
+    ensureUniqueBatchPageIds(input.pages.map((page) => page.id), 'page-batch-create-page-ids-must-be-unique');
+    const existingPages = await listPages(repository, input.lang);
+    const pagesById = new Map(existingPages.map((page) => [page.id, page]));
+    const timestamp = currentTimestamp();
+    const plannedPages = [];
+    for (const pageInput of input.pages) {
+        assertValidAuthoringContent(pageInput.content ?? {}, pageInput.id);
+        if (pagesById.has(pageInput.id)) {
+            throw new ValidationError(`Page "${pageInput.id}" already exists.`, {
+                entity: 'page-doc',
+                rule: 'page-create-target-must-not-exist',
+                remediation: 'Use a new page id for page_batch_create, or use page_batch_update to modify existing pages.',
+                metadata: {
+                    lang: input.lang,
+                    pageId: pageInput.id,
+                    projectRoot: contract.paths.projectRoot,
+                },
+            });
+        }
+        const candidate = validateAndNormalizePageCandidate({
+            id: pageInput.id,
+            lang: input.lang,
+            slug: pageInput.slug,
+            title: pageInput.title,
+            ...(pageInput.description ? { description: pageInput.description } : {}),
+            ...(pageInput.tags ? { tags: pageInput.tags } : {}),
+            status: pageInput.status ?? 'draft',
+            content: (pageInput.content ?? {}),
+            ...(pageInput.render ? { render: pageInput.render } : {}),
+            ...(pageInput.review ? { review: pageInput.review } : {}),
+            updatedAt: timestamp,
+        }, input.lang);
+        assertSlugAvailableInPageMap(pagesById, candidate, contract.paths.projectRoot, input.lang);
+        pagesById.set(candidate.id, candidate);
+        plannedPages.push(candidate);
+    }
+    return persistBatchPages(repository, contract.paths.projectRoot, input.lang, plannedPages);
+}
+export async function updatePage(input) {
+    if ('content' in input.patch) {
+        assertValidAuthoringContent(input.patch.content, input.pageId);
+    }
+    const { contract, repository } = await loadAuthoringContext(input.projectRoot, input.lang);
+    const existingPage = await loadPage(repository, input.lang, input.pageId);
+    if (!existingPage) {
+        throw new ValidationError(`Page "${input.pageId}" not found.`, {
+            entity: 'page-doc',
+            rule: 'page-must-exist',
+            remediation: 'Use page_list or page_find to inspect available pages before retrying.',
+            metadata: {
+                lang: input.lang,
+                pageId: input.pageId,
+                projectRoot: contract.paths.projectRoot,
+            },
+        });
+    }
+    const nextSlug = input.patch.slug ?? existingPage.slug;
+    await assertSlugAvailable(contract.paths.projectRoot, input.lang, existingPage.id, nextSlug, () => findPageBySlug(repository, input.lang, nextSlug));
+    const page = await savePage(repository, input.lang, {
+        ...existingPage,
+        ...input.patch,
+        lang: input.lang,
+        id: existingPage.id,
+        status: existingPage.status,
+        render: resolveNextRender(existingPage, input.patch, input.regenerateRender),
+        updatedAt: currentTimestamp(),
+    });
+    return {
+        filePath: pageFilePath(contract.paths.projectRoot, input.lang, page.id),
+        page,
+    };
+}
+export async function updatePagesBatch(input) {
+    const { contract, repository } = await loadAuthoringContext(input.projectRoot, input.lang);
+    ensureUniqueBatchPageIds(input.updates.map((entry) => entry.pageId), 'page-batch-update-page-ids-must-be-unique');
+    const existingPages = await listPages(repository, input.lang);
+    const pagesById = new Map(existingPages.map((page) => [page.id, page]));
+    const timestamp = currentTimestamp();
+    const plannedPages = [];
+    for (const entry of input.updates) {
+        if ('content' in entry.patch) {
+            assertValidAuthoringContent(entry.patch.content, entry.pageId);
+        }
+        const existingPage = pagesById.get(entry.pageId);
+        if (!existingPage) {
+            throw new ValidationError(`Page "${entry.pageId}" not found.`, {
+                entity: 'page-doc',
+                rule: 'page-must-exist',
+                remediation: 'Use page_list or page_find to inspect available pages before retrying.',
+                metadata: {
+                    lang: input.lang,
+                    pageId: entry.pageId,
+                    projectRoot: contract.paths.projectRoot,
+                },
+            });
+        }
+        const candidate = validateAndNormalizePageCandidate({
+            ...existingPage,
+            ...entry.patch,
+            lang: input.lang,
+            id: existingPage.id,
+            status: existingPage.status,
+            render: resolveNextRender(existingPage, entry.patch, entry.regenerateRender),
+            updatedAt: timestamp,
+        }, input.lang);
+        assertSlugAvailableInPageMap(pagesById, candidate, contract.paths.projectRoot, input.lang);
+        pagesById.set(candidate.id, candidate);
+        plannedPages.push(candidate);
+    }
+    return persistBatchPages(repository, contract.paths.projectRoot, input.lang, plannedPages);
+}
+export async function setPageStatus(input) {
+    const { contract, repository } = await loadAuthoringContext(input.projectRoot, input.lang);
+    const existingPage = await loadPage(repository, input.lang, input.pageId);
+    if (!existingPage) {
+        throw new ValidationError(`Page "${input.pageId}" not found.`, {
+            entity: 'page-doc',
+            rule: 'page-must-exist',
+            remediation: 'Use page_list or page_find to inspect available pages before retrying.',
+            metadata: {
+                lang: input.lang,
+                pageId: input.pageId,
+                projectRoot: contract.paths.projectRoot,
+            },
+        });
+    }
+    const page = await savePage(repository, input.lang, {
+        ...existingPage,
+        status: input.status,
+        updatedAt: currentTimestamp(),
+    });
+    return {
+        filePath: pageFilePath(contract.paths.projectRoot, input.lang, page.id),
+        page,
+    };
+}
+export async function setPageStatusesBatch(input) {
+    const { contract, repository } = await loadAuthoringContext(input.projectRoot, input.lang);
+    ensureUniqueBatchPageIds(input.updates.map((entry) => entry.pageId), 'page-batch-status-page-ids-must-be-unique');
+    const existingPages = await listPages(repository, input.lang);
+    const pagesById = new Map(existingPages.map((page) => [page.id, page]));
+    const timestamp = currentTimestamp();
+    const plannedPages = [];
+    for (const entry of input.updates) {
+        const existingPage = pagesById.get(entry.pageId);
+        if (!existingPage) {
+            throw new ValidationError(`Page "${entry.pageId}" not found.`, {
+                entity: 'page-doc',
+                rule: 'page-must-exist',
+                remediation: 'Use page_list or page_find to inspect available pages before retrying.',
+                metadata: {
+                    lang: input.lang,
+                    pageId: entry.pageId,
+                    projectRoot: contract.paths.projectRoot,
+                },
+            });
+        }
+        const candidate = validateAndNormalizePageCandidate({
+            ...existingPage,
+            status: entry.status,
+            updatedAt: timestamp,
+        }, input.lang);
+        pagesById.set(candidate.id, candidate);
+        plannedPages.push(candidate);
+    }
+    return persistBatchPages(repository, contract.paths.projectRoot, input.lang, plannedPages);
+}
+export async function deleteAuthoredPage(input) {
+    const { contract, repository } = await loadAuthoringContext(input.projectRoot, input.lang);
+    const result = await deletePageFromRepository(repository, input.lang, input.pageId);
+    return {
+        filePath: pageFilePath(contract.paths.projectRoot, input.lang, input.pageId),
+        ...result,
+    };
+}
+export async function setNavigation(input) {
+    const { contract, repository } = await loadAuthoringContext(input.projectRoot, input.lang);
+    const pages = await listPages(repository, input.lang);
+    const navigation = await saveNavigation(repository, input.lang, input.navigation, {
+        existingPageIds: pages.map((page) => page.id),
+        requiredTopLevelGroupIds: collectRequiredTopLevelGroupIds(contract),
+    });
+    return {
+        filePath: navigationFilePath(contract.paths.projectRoot, input.lang),
+        navigation,
+    };
+}
+export async function replaceNavigationItems(input) {
+    const { repository } = await loadAuthoringContext(input.projectRoot, input.lang);
+    const existingNavigation = await loadNavigation(repository, input.lang);
+    return setNavigation({
+        projectRoot: input.projectRoot,
+        lang: input.lang,
+        navigation: {
+            ...existingNavigation,
+            items: input.items,
+        },
+    });
+}
+export async function insertNavigationItem(input) {
+    const parentPath = parseNavigationItemPath(input.parentPath, 'parentPath');
+    const { repository } = await loadAuthoringContext(input.projectRoot, input.lang);
+    const existingNavigation = await loadNavigation(repository, input.lang);
+    const nextItems = insertNavItemAtParent(cloneNavItems(existingNavigation.items), parentPath, input.item, input.index);
+    return setNavigation({
+        projectRoot: input.projectRoot,
+        lang: input.lang,
+        navigation: {
+            ...existingNavigation,
+            items: nextItems,
+        },
+    });
+}
+export async function deleteNavigationItem(input) {
+    const itemPath = parseNavigationItemPath(input.itemPath, 'itemPath');
+    const { repository } = await loadAuthoringContext(input.projectRoot, input.lang);
+    const existingNavigation = await loadNavigation(repository, input.lang);
+    const nextItems = removeNavItemAtPath(cloneNavItems(existingNavigation.items), itemPath).items;
+    return setNavigation({
+        projectRoot: input.projectRoot,
+        lang: input.lang,
+        navigation: {
+            ...existingNavigation,
+            items: nextItems,
+        },
+    });
+}
+export async function moveNavigationItem(input) {
+    const itemPath = parseNavigationItemPath(input.itemPath, 'itemPath');
+    const parentPath = parseNavigationItemPath(input.parentPath, 'parentPath');
+    if (isDescendantPath(parentPath, itemPath) || isSamePath(parentPath, itemPath)) {
+        throw createNavigationPathError('navigation-move-target-must-not-be-source-descendant', 'Move a navigation item to the root or to a different section/folder outside the moved subtree.', { itemPath: input.itemPath, parentPath: input.parentPath ?? '' });
+    }
+    const { repository } = await loadAuthoringContext(input.projectRoot, input.lang);
+    const existingNavigation = await loadNavigation(repository, input.lang);
+    const removed = removeNavItemAtPath(cloneNavItems(existingNavigation.items), itemPath);
+    let nextIndex = input.index;
+    if (nextIndex != null &&
+        isSamePath(removed.parentPath, parentPath) &&
+        removed.removedIndex < nextIndex) {
+        nextIndex -= 1;
+    }
+    const nextItems = insertNavItemAtParent(removed.items, parentPath, removed.removedItem, nextIndex);
+    return setNavigation({
+        projectRoot: input.projectRoot,
+        lang: input.lang,
+        navigation: {
+            ...existingNavigation,
+            items: nextItems,
+        },
+    });
+}
+export async function setProjectLanguages(input) {
+    const result = await updateProjectConfig(input.projectRoot, {
+        languages: input.languages,
+        ...(input.defaultLanguage ? { defaultLanguage: input.defaultLanguage } : {}),
+    });
+    if (!result.ok) {
+        throw result.error;
+    }
+    const contractResult = await loadProjectContract(input.projectRoot);
+    if (!contractResult.ok) {
+        throw contractResult.error;
+    }
+    return {
+        filePath: contractResult.value.paths.configFile,
+        config: result.value,
+    };
+}

package/dist/services/build-service.d.ts

@@ -0,0 +1,35 @@
+import { type PublishedLanguageContent, type PublishedSiteLanguageContent } from '../publishing/publication-filter.ts';
+import type { DocsLanguage } from '../types/project.ts';
+export type BuildWorkflowOptions = {
+    repoRoot: string;
+    projectId?: string;
+    outputDir?: string;
+};
+export type BuildWorkflowLanguageSummary = {
+    lang: DocsLanguage;
+    totalPages: number;
+    publishedPages: number;
+    navigationItems: number;
+};
+export type BuildWorkflowLanguageResult<TContent = unknown> = {
+    lang: DocsLanguage;
+    content: PublishedLanguageContent<TContent>;
+    summary: BuildWorkflowLanguageSummary;
+};
+export type BuildWorkflowPublishedSiteResult<TContent = unknown> = {
+    lang: DocsLanguage;
+    content: PublishedSiteLanguageContent<TContent>;
+    summary: BuildWorkflowLanguageSummary;
+};
+export type BuildWorkflowResult = {
+    projectId: string;
+    artifactRoot: string;
+    machineReadableRoot: string;
+    entryHtmlFile: string;
+    defaultDocsPath: string;
+    languages: BuildWorkflowLanguageSummary[];
+};
+export declare function runBuildWorkflow(options: BuildWorkflowOptions): Promise<BuildWorkflowResult>;
+export declare function loadPublishedBuildArtifacts<TContent = unknown>(options: BuildWorkflowOptions): Promise<BuildWorkflowLanguageResult<TContent>[]>;
+export declare function loadPublishedSiteBuildArtifacts<TContent = unknown>(options: BuildWorkflowOptions): Promise<BuildWorkflowPublishedSiteResult<TContent>[]>;
+//# sourceMappingURL=build-service.d.ts.map

package/dist/services/build-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-service.d.ts","sourceRoot":"","sources":["../../src/services/build-service.ts"],"names":[],"mappings":"AAKA,OAAO,EAEL,KAAK,wBAAwB,EAC7B,KAAK,4BAA4B,EAClC,MAAM,qCAAqC,CAAC;AAG7C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAExD,MAAM,MAAM,oBAAoB,GAAG;IACjC,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,4BAA4B,GAAG;IACzC,IAAI,EAAE,YAAY,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC;IACvB,eAAe,EAAE,MAAM,CAAC;CACzB,CAAC;AAEF,MAAM,MAAM,2BAA2B,CAAC,QAAQ,GAAG,OAAO,IAAI;IAC5D,IAAI,EAAE,YAAY,CAAC;IACnB,OAAO,EAAE,wBAAwB,CAAC,QAAQ,CAAC,CAAC;IAC5C,OAAO,EAAE,4BAA4B,CAAC;CACvC,CAAC;AAEF,MAAM,MAAM,gCAAgC,CAAC,QAAQ,GAAG,OAAO,IAAI;IACjE,IAAI,EAAE,YAAY,CAAC;IACnB,OAAO,EAAE,4BAA4B,CAAC,QAAQ,CAAC,CAAC;IAChD,OAAO,EAAE,4BAA4B,CAAC;CACvC,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;IACxB,SAAS,EAAE,4BAA4B,EAAE,CAAC;CAC3C,CAAC;AAaF,wBAAsB,gBAAgB,CAAC,OAAO,EAAE,oBAAoB,GAAG,OAAO,CAAC,mBAAmB,CAAC,CA+BlG;AAED,wBAAsB,2BAA2B,CAAC,QAAQ,GAAG,OAAO,EAClE,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC,2BAA2B,CAAC,QAAQ,CAAC,EAAE,CAAC,CAUlD;AAED,wBAAsB,+BAA+B,CAAC,QAAQ,GAAG,OAAO,EACtE,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC,gCAAgC,CAAC,QAAQ,CAAC,EAAE,CAAC,CA6BvD"}