@originals/sdk 1.4.3 → 1.5.0

package/dist/kinds/validators/AgentValidator.js

@@ -0,0 +1,155 @@
+/**
+ * Agent Kind Validator
+ *
+ * Validates manifests for AI agents or autonomous systems with capabilities and model info.
+ */
+import { OriginalKind } from '../types';
+import { BaseKindValidator, ValidationUtils } from './base';
+/**
+ * Known AI model providers
+ */
+const KNOWN_PROVIDERS = [
+    'openai', 'anthropic', 'google', 'meta', 'mistral', 'cohere',
+    'huggingface', 'replicate', 'together', 'groq', 'perplexity',
+    'fireworks', 'local', 'custom',
+];
+/**
+ * Valid memory types
+ */
+const VALID_MEMORY_TYPES = ['stateless', 'session', 'persistent'];
+/**
+ * Validator for Agent Originals
+ */
+export class AgentValidator extends BaseKindValidator {
+    constructor() {
+        super(...arguments);
+        this.kind = OriginalKind.Agent;
+    }
+    validateKind(manifest) {
+        const errors = [];
+        const warnings = [];
+        const metadata = manifest.metadata;
+        // Validate metadata exists
+        if (!metadata || typeof metadata !== 'object') {
+            return ValidationUtils.failure([
+                ValidationUtils.error('MISSING_METADATA', 'Agent manifest must have metadata', 'metadata'),
+            ]);
+        }
+        // Validate capabilities (required)
+        if (!metadata.capabilities) {
+            errors.push(ValidationUtils.error('MISSING_CAPABILITIES', 'Agent must specify capabilities', 'metadata.capabilities'));
+        }
+        else if (!Array.isArray(metadata.capabilities)) {
+            errors.push(ValidationUtils.error('INVALID_CAPABILITIES', 'Capabilities must be an array of strings', 'metadata.capabilities'));
+        }
+        else if (metadata.capabilities.length === 0) {
+            errors.push(ValidationUtils.error('EMPTY_CAPABILITIES', 'Agent must have at least one capability', 'metadata.capabilities'));
+        }
+        else {
+            for (let i = 0; i < metadata.capabilities.length; i++) {
+                if (typeof metadata.capabilities[i] !== 'string') {
+                    errors.push(ValidationUtils.error('INVALID_CAPABILITY', `Capability at index ${i} must be a string`, `metadata.capabilities[${i}]`));
+                }
+                else if (metadata.capabilities[i].length === 0) {
+                    errors.push(ValidationUtils.error('EMPTY_CAPABILITY', `Capability at index ${i} cannot be empty`, `metadata.capabilities[${i}]`));
+                }
+            }
+        }
+        // Validate model if specified
+        if (metadata.model) {
+            if (typeof metadata.model !== 'object') {
+                errors.push(ValidationUtils.error('INVALID_MODEL', 'Model must be an object', 'metadata.model'));
+            }
+            else {
+                // Model name is required
+                if (!metadata.model.name || typeof metadata.model.name !== 'string') {
+                    errors.push(ValidationUtils.error('MISSING_MODEL_NAME', 'Model must have a name', 'metadata.model.name'));
+                }
+                // Validate provider if specified
+                if (metadata.model.provider) {
+                    const normalizedProvider = metadata.model.provider.toLowerCase();
+                    if (!KNOWN_PROVIDERS.includes(normalizedProvider)) {
+                        warnings.push(ValidationUtils.warning('UNKNOWN_PROVIDER', `Model provider "${metadata.model.provider}" is not a commonly recognized provider`, 'metadata.model.provider', `Consider using one of: ${KNOWN_PROVIDERS.join(', ')}`));
+                    }
+                }
+            }
+        }
+        // Validate input/output types if specified
+        if (metadata.inputTypes) {
+            if (!Array.isArray(metadata.inputTypes)) {
+                errors.push(ValidationUtils.error('INVALID_INPUT_TYPES', 'Input types must be an array', 'metadata.inputTypes'));
+            }
+        }
+        if (metadata.outputTypes) {
+            if (!Array.isArray(metadata.outputTypes)) {
+                errors.push(ValidationUtils.error('INVALID_OUTPUT_TYPES', 'Output types must be an array', 'metadata.outputTypes'));
+            }
+        }
+        // Validate memory if specified
+        if (metadata.memory) {
+            if (typeof metadata.memory !== 'object') {
+                errors.push(ValidationUtils.error('INVALID_MEMORY', 'Memory must be an object', 'metadata.memory'));
+            }
+            else {
+                if (!metadata.memory.type || !VALID_MEMORY_TYPES.includes(metadata.memory.type)) {
+                    errors.push(ValidationUtils.error('INVALID_MEMORY_TYPE', `Memory type must be one of: ${VALID_MEMORY_TYPES.join(', ')}`, 'metadata.memory.type', metadata.memory.type));
+                }
+                if (metadata.memory.maxSize !== undefined &&
+                    (typeof metadata.memory.maxSize !== 'number' || metadata.memory.maxSize <= 0)) {
+                    errors.push(ValidationUtils.error('INVALID_MEMORY_SIZE', 'Memory maxSize must be a positive number', 'metadata.memory.maxSize'));
+                }
+            }
+        }
+        // Validate tools if specified
+        if (metadata.tools) {
+            if (!Array.isArray(metadata.tools)) {
+                errors.push(ValidationUtils.error('INVALID_TOOLS', 'Tools must be an array', 'metadata.tools'));
+            }
+            else {
+                for (let i = 0; i < metadata.tools.length; i++) {
+                    const tool = metadata.tools[i];
+                    const toolPath = `metadata.tools[${i}]`;
+                    if (!tool || typeof tool !== 'object') {
+                        errors.push(ValidationUtils.error('INVALID_TOOL', `Tool at index ${i} must be an object`, toolPath));
+                        continue;
+                    }
+                    if (!tool.name || typeof tool.name !== 'string') {
+                        errors.push(ValidationUtils.error('MISSING_TOOL_NAME', `Tool at index ${i} must have a name`, `${toolPath}.name`));
+                    }
+                    if (!tool.description || typeof tool.description !== 'string') {
+                        warnings.push(ValidationUtils.warning('MISSING_TOOL_DESC', `Tool "${tool.name || i}" should have a description`, `${toolPath}.description`));
+                    }
+                }
+            }
+        }
+        // Validate rate limits if specified
+        if (metadata.rateLimit) {
+            if (typeof metadata.rateLimit !== 'object') {
+                errors.push(ValidationUtils.error('INVALID_RATE_LIMIT', 'Rate limit must be an object', 'metadata.rateLimit'));
+            }
+            else {
+                if (metadata.rateLimit.requestsPerMinute !== undefined &&
+                    (typeof metadata.rateLimit.requestsPerMinute !== 'number' ||
+                        metadata.rateLimit.requestsPerMinute <= 0)) {
+                    errors.push(ValidationUtils.error('INVALID_RPM', 'requestsPerMinute must be a positive number', 'metadata.rateLimit.requestsPerMinute'));
+                }
+                if (metadata.rateLimit.tokensPerMinute !== undefined &&
+                    (typeof metadata.rateLimit.tokensPerMinute !== 'number' ||
+                        metadata.rateLimit.tokensPerMinute <= 0)) {
+                    errors.push(ValidationUtils.error('INVALID_TPM', 'tokensPerMinute must be a positive number', 'metadata.rateLimit.tokensPerMinute'));
+                }
+            }
+        }
+        // Suggest adding model info for AI agents
+        if (!metadata.model) {
+            warnings.push(ValidationUtils.warning('MISSING_MODEL', 'Consider adding model information if this is an AI-based agent', 'metadata.model'));
+        }
+        // Suggest adding system prompt
+        if (!metadata.systemPrompt) {
+            warnings.push(ValidationUtils.warning('MISSING_SYSTEM_PROMPT', 'Consider adding a system prompt to define the agent\'s behavior', 'metadata.systemPrompt'));
+        }
+        return errors.length > 0
+            ? ValidationUtils.failure(errors, warnings)
+            : ValidationUtils.success(warnings);
+    }
+}

package/dist/kinds/validators/AppValidator.d.ts

@@ -0,0 +1,14 @@
+/**
+ * App Kind Validator
+ *
+ * Validates manifests for executable applications with runtime and entrypoint.
+ */
+import { OriginalKind, type OriginalManifest, type ValidationResult } from '../types';
+import { BaseKindValidator } from './base';
+/**
+ * Validator for App Originals
+ */
+export declare class AppValidator extends BaseKindValidator<OriginalKind.App> {
+    readonly kind = OriginalKind.App;
+    protected validateKind(manifest: OriginalManifest<OriginalKind.App>): ValidationResult;
+}

package/dist/kinds/validators/AppValidator.js

@@ -0,0 +1,135 @@
+/**
+ * App Kind Validator
+ *
+ * Validates manifests for executable applications with runtime and entrypoint.
+ */
+import { OriginalKind } from '../types';
+import { BaseKindValidator, ValidationUtils } from './base';
+/**
+ * Valid runtime environments
+ */
+const VALID_RUNTIMES = [
+    'node', 'deno', 'bun', 'browser', 'electron',
+    'react-native', 'python', 'ruby', 'go', 'rust',
+    'java', 'dotnet', 'wasm',
+];
+/**
+ * Valid platforms
+ */
+const VALID_PLATFORMS = ['linux', 'darwin', 'windows', 'web'];
+/**
+ * Validator for App Originals
+ */
+export class AppValidator extends BaseKindValidator {
+    constructor() {
+        super(...arguments);
+        this.kind = OriginalKind.App;
+    }
+    validateKind(manifest) {
+        const errors = [];
+        const warnings = [];
+        const metadata = manifest.metadata;
+        // Validate metadata exists
+        if (!metadata || typeof metadata !== 'object') {
+            return ValidationUtils.failure([
+                ValidationUtils.error('MISSING_METADATA', 'App manifest must have metadata', 'metadata'),
+            ]);
+        }
+        // Validate runtime (required)
+        if (!metadata.runtime || typeof metadata.runtime !== 'string') {
+            errors.push(ValidationUtils.error('MISSING_RUNTIME', 'App must specify a runtime environment', 'metadata.runtime'));
+        }
+        else if (!VALID_RUNTIMES.includes(metadata.runtime.toLowerCase())) {
+            warnings.push(ValidationUtils.warning('UNKNOWN_RUNTIME', `Runtime "${metadata.runtime}" is not a commonly recognized runtime`, 'metadata.runtime', `Consider using one of: ${VALID_RUNTIMES.join(', ')}`));
+        }
+        // Validate entrypoint (required)
+        if (!metadata.entrypoint || typeof metadata.entrypoint !== 'string') {
+            errors.push(ValidationUtils.error('MISSING_ENTRYPOINT', 'App must specify an entrypoint', 'metadata.entrypoint'));
+        }
+        else {
+            // Check if entrypoint references an existing resource
+            if (!ValidationUtils.resourceExists(metadata.entrypoint, manifest.resources)) {
+                // It might be a path within a resource, so just warn
+                warnings.push(ValidationUtils.warning('ENTRYPOINT_NOT_RESOURCE', `Entrypoint "${metadata.entrypoint}" does not match a resource ID`, 'metadata.entrypoint', 'Ensure the entrypoint is a valid resource ID or path within a resource'));
+            }
+        }
+        // Validate platforms if specified
+        if (metadata.platforms) {
+            if (!Array.isArray(metadata.platforms)) {
+                errors.push(ValidationUtils.error('INVALID_PLATFORMS', 'Platforms must be an array', 'metadata.platforms'));
+            }
+            else {
+                for (const platform of metadata.platforms) {
+                    if (!VALID_PLATFORMS.includes(platform)) {
+                        errors.push(ValidationUtils.error('INVALID_PLATFORM', `Invalid platform: "${platform}"`, 'metadata.platforms', platform));
+                    }
+                }
+            }
+        }
+        // Validate permissions if specified
+        if (metadata.permissions) {
+            if (!Array.isArray(metadata.permissions)) {
+                errors.push(ValidationUtils.error('INVALID_PERMISSIONS', 'Permissions must be an array of strings', 'metadata.permissions'));
+            }
+            else {
+                for (let i = 0; i < metadata.permissions.length; i++) {
+                    if (typeof metadata.permissions[i] !== 'string') {
+                        errors.push(ValidationUtils.error('INVALID_PERMISSION', `Permission at index ${i} must be a string`, `metadata.permissions[${i}]`));
+                    }
+                }
+            }
+        }
+        // Validate env if specified
+        if (metadata.env) {
+            if (typeof metadata.env !== 'object' || Array.isArray(metadata.env)) {
+                errors.push(ValidationUtils.error('INVALID_ENV', 'Env must be an object', 'metadata.env'));
+            }
+            else {
+                for (const [key, value] of Object.entries(metadata.env)) {
+                    if (!/^[A-Z][A-Z0-9_]*$/.test(key)) {
+                        warnings.push(ValidationUtils.warning('ENV_VAR_NAMING', `Environment variable "${key}" should use SCREAMING_SNAKE_CASE`, `metadata.env.${key}`));
+                    }
+                    if (typeof value !== 'object' || value === null) {
+                        errors.push(ValidationUtils.error('INVALID_ENV_VALUE', `Env variable "${key}" must have an object value`, `metadata.env.${key}`));
+                    }
+                }
+            }
+        }
+        // Validate icons if specified
+        if (metadata.icons) {
+            if (typeof metadata.icons !== 'object' || Array.isArray(metadata.icons)) {
+                errors.push(ValidationUtils.error('INVALID_ICONS', 'Icons must be an object mapping sizes to resource IDs', 'metadata.icons'));
+            }
+            else {
+                for (const [size, resourceId] of Object.entries(metadata.icons)) {
+                    if (!/^\d+x\d+$/.test(size) && !/^\d+$/.test(size)) {
+                        warnings.push(ValidationUtils.warning('ICON_SIZE_FORMAT', `Icon size "${size}" should be in format "WxH" or just "N"`, `metadata.icons.${size}`));
+                    }
+                }
+            }
+        }
+        // Validate commands if specified
+        if (metadata.commands) {
+            if (typeof metadata.commands !== 'object' || Array.isArray(metadata.commands)) {
+                errors.push(ValidationUtils.error('INVALID_COMMANDS', 'Commands must be an object', 'metadata.commands'));
+            }
+            else {
+                for (const [name, cmd] of Object.entries(metadata.commands)) {
+                    if (!cmd || typeof cmd !== 'object') {
+                        errors.push(ValidationUtils.error('INVALID_COMMAND', `Command "${name}" must be an object`, `metadata.commands.${name}`));
+                    }
+                    else if (!cmd.description || typeof cmd.description !== 'string') {
+                        warnings.push(ValidationUtils.warning('MISSING_COMMAND_DESC', `Command "${name}" should have a description`, `metadata.commands.${name}.description`));
+                    }
+                }
+            }
+        }
+        // Suggest adding runtime version
+        if (!metadata.runtimeVersion && !metadata.minRuntimeVersion) {
+            warnings.push(ValidationUtils.warning('MISSING_RUNTIME_VERSION', 'Consider specifying runtimeVersion or minRuntimeVersion for compatibility', 'metadata.runtimeVersion'));
+        }
+        return errors.length > 0
+            ? ValidationUtils.failure(errors, warnings)
+            : ValidationUtils.success(warnings);
+    }
+}

package/dist/kinds/validators/DatasetValidator.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Dataset Kind Validator
+ *
+ * Validates manifests for structured data collections with schema definitions.
+ */
+import { OriginalKind, type OriginalManifest, type ValidationResult } from '../types';
+import { BaseKindValidator } from './base';
+/**
+ * Validator for Dataset Originals
+ */
+export declare class DatasetValidator extends BaseKindValidator<OriginalKind.Dataset> {
+    readonly kind = OriginalKind.Dataset;
+    protected validateKind(manifest: OriginalManifest<OriginalKind.Dataset>): ValidationResult;
+}

package/dist/kinds/validators/DatasetValidator.js

@@ -0,0 +1,148 @@
+/**
+ * Dataset Kind Validator
+ *
+ * Validates manifests for structured data collections with schema definitions.
+ */
+import { OriginalKind } from '../types';
+import { BaseKindValidator, ValidationUtils } from './base';
+/**
+ * Common data formats
+ */
+const KNOWN_FORMATS = [
+    'csv', 'json', 'jsonl', 'ndjson', 'parquet', 'avro', 'orc',
+    'xml', 'yaml', 'toml', 'tsv', 'excel', 'sqlite', 'arrow',
+];
+/**
+ * Valid privacy classifications
+ */
+const VALID_PRIVACY = ['public', 'internal', 'confidential', 'restricted'];
+/**
+ * Valid update frequencies
+ */
+const VALID_UPDATE_FREQUENCIES = ['realtime', 'hourly', 'daily', 'weekly', 'monthly', 'static'];
+/**
+ * Validator for Dataset Originals
+ */
+export class DatasetValidator extends BaseKindValidator {
+    constructor() {
+        super(...arguments);
+        this.kind = OriginalKind.Dataset;
+    }
+    validateKind(manifest) {
+        const errors = [];
+        const warnings = [];
+        const metadata = manifest.metadata;
+        // Validate metadata exists
+        if (!metadata || typeof metadata !== 'object') {
+            return ValidationUtils.failure([
+                ValidationUtils.error('MISSING_METADATA', 'Dataset manifest must have metadata', 'metadata'),
+            ]);
+        }
+        // Validate schema (required)
+        if (!metadata.schema) {
+            errors.push(ValidationUtils.error('MISSING_SCHEMA', 'Dataset must have a schema definition', 'metadata.schema'));
+        }
+        else if (typeof metadata.schema !== 'object' && typeof metadata.schema !== 'string') {
+            errors.push(ValidationUtils.error('INVALID_SCHEMA', 'Schema must be an object (JSON Schema) or string (URL)', 'metadata.schema'));
+        }
+        else if (typeof metadata.schema === 'string') {
+            // If it's a URL, validate it
+            if (!ValidationUtils.isValidURL(metadata.schema)) {
+                errors.push(ValidationUtils.error('INVALID_SCHEMA_URL', 'Schema URL is not a valid URL', 'metadata.schema', metadata.schema));
+            }
+        }
+        // Validate format (required)
+        if (!metadata.format || typeof metadata.format !== 'string') {
+            errors.push(ValidationUtils.error('MISSING_FORMAT', 'Dataset must specify a data format', 'metadata.format'));
+        }
+        else {
+            const normalizedFormat = metadata.format.toLowerCase();
+            if (!KNOWN_FORMATS.includes(normalizedFormat)) {
+                warnings.push(ValidationUtils.warning('UNKNOWN_FORMAT', `Data format "${metadata.format}" is not a commonly recognized format`, 'metadata.format', `Consider using one of: ${KNOWN_FORMATS.join(', ')}`));
+            }
+        }
+        // Validate recordCount if specified
+        if (metadata.recordCount !== undefined) {
+            if (typeof metadata.recordCount !== 'number' || metadata.recordCount < 0 || !Number.isInteger(metadata.recordCount)) {
+                errors.push(ValidationUtils.error('INVALID_RECORD_COUNT', 'Record count must be a non-negative integer', 'metadata.recordCount', metadata.recordCount));
+            }
+        }
+        else {
+            warnings.push(ValidationUtils.warning('MISSING_RECORD_COUNT', 'Consider specifying recordCount for better discoverability', 'metadata.recordCount'));
+        }
+        // Validate columns if specified
+        if (metadata.columns) {
+            if (!Array.isArray(metadata.columns)) {
+                errors.push(ValidationUtils.error('INVALID_COLUMNS', 'Columns must be an array', 'metadata.columns'));
+            }
+            else {
+                const columnNames = new Set();
+                for (let i = 0; i < metadata.columns.length; i++) {
+                    const column = metadata.columns[i];
+                    const columnPath = `metadata.columns[${i}]`;
+                    if (!column || typeof column !== 'object') {
+                        errors.push(ValidationUtils.error('INVALID_COLUMN', `Column at index ${i} must be an object`, columnPath));
+                        continue;
+                    }
+                    if (!column.name || typeof column.name !== 'string') {
+                        errors.push(ValidationUtils.error('MISSING_COLUMN_NAME', `Column at index ${i} must have a name`, `${columnPath}.name`));
+                    }
+                    else {
+                        if (columnNames.has(column.name)) {
+                            errors.push(ValidationUtils.error('DUPLICATE_COLUMN', `Duplicate column name: "${column.name}"`, `${columnPath}.name`));
+                        }
+                        columnNames.add(column.name);
+                    }
+                    if (!column.type || typeof column.type !== 'string') {
+                        errors.push(ValidationUtils.error('MISSING_COLUMN_TYPE', `Column "${column.name || i}" must have a type`, `${columnPath}.type`));
+                    }
+                }
+            }
+        }
+        // Validate source if specified
+        if (metadata.source) {
+            if (typeof metadata.source !== 'object') {
+                errors.push(ValidationUtils.error('INVALID_SOURCE', 'Source must be an object', 'metadata.source'));
+            }
+        }
+        // Validate statistics if specified
+        if (metadata.statistics) {
+            if (typeof metadata.statistics !== 'object') {
+                errors.push(ValidationUtils.error('INVALID_STATISTICS', 'Statistics must be an object', 'metadata.statistics'));
+            }
+            else {
+                if (metadata.statistics.sizeBytes !== undefined &&
+                    (typeof metadata.statistics.sizeBytes !== 'number' || metadata.statistics.sizeBytes < 0)) {
+                    errors.push(ValidationUtils.error('INVALID_SIZE_BYTES', 'sizeBytes must be a non-negative number', 'metadata.statistics.sizeBytes'));
+                }
+            }
+        }
+        // Validate privacy if specified
+        if (metadata.privacy) {
+            if (!VALID_PRIVACY.includes(metadata.privacy)) {
+                errors.push(ValidationUtils.error('INVALID_PRIVACY', `Privacy must be one of: ${VALID_PRIVACY.join(', ')}`, 'metadata.privacy', metadata.privacy));
+            }
+        }
+        else {
+            warnings.push(ValidationUtils.warning('MISSING_PRIVACY', 'Consider specifying a privacy classification for the dataset', 'metadata.privacy'));
+        }
+        // Validate updateFrequency if specified
+        if (metadata.updateFrequency) {
+            if (!VALID_UPDATE_FREQUENCIES.includes(metadata.updateFrequency)) {
+                errors.push(ValidationUtils.error('INVALID_UPDATE_FREQUENCY', `Update frequency must be one of: ${VALID_UPDATE_FREQUENCIES.join(', ')}`, 'metadata.updateFrequency', metadata.updateFrequency));
+            }
+        }
+        // Check that at least one data resource exists
+        const dataResources = manifest.resources.filter(r => r.type === 'data' ||
+            r.contentType.includes('csv') ||
+            r.contentType.includes('json') ||
+            r.contentType.includes('parquet') ||
+            r.contentType.includes('octet-stream'));
+        if (dataResources.length === 0) {
+            warnings.push(ValidationUtils.warning('NO_DATA_RESOURCES', 'No data resources found. Ensure resources have appropriate types', 'resources'));
+        }
+        return errors.length > 0
+            ? ValidationUtils.failure(errors, warnings)
+            : ValidationUtils.success(warnings);
+    }
+}

package/dist/kinds/validators/DocumentValidator.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Document Kind Validator
+ *
+ * Validates manifests for text documents with formatting and sections.
+ */
+import { OriginalKind, type OriginalManifest, type ValidationResult } from '../types';
+import { BaseKindValidator } from './base';
+/**
+ * Validator for Document Originals
+ */
+export declare class DocumentValidator extends BaseKindValidator<OriginalKind.Document> {
+    readonly kind = OriginalKind.Document;
+    protected validateKind(manifest: OriginalManifest<OriginalKind.Document>): ValidationResult;
+}

package/dist/kinds/validators/DocumentValidator.js

@@ -0,0 +1,180 @@
+/**
+ * Document Kind Validator
+ *
+ * Validates manifests for text documents with formatting and sections.
+ */
+import { OriginalKind } from '../types';
+import { BaseKindValidator, ValidationUtils } from './base';
+/**
+ * Valid document formats
+ */
+const VALID_FORMATS = ['markdown', 'html', 'pdf', 'docx', 'txt', 'asciidoc', 'rst', 'latex'];
+/**
+ * Valid document statuses
+ */
+const VALID_STATUSES = ['draft', 'review', 'published', 'archived'];
+/**
+ * Validator for Document Originals
+ */
+export class DocumentValidator extends BaseKindValidator {
+    constructor() {
+        super(...arguments);
+        this.kind = OriginalKind.Document;
+    }
+    validateKind(manifest) {
+        const errors = [];
+        const warnings = [];
+        const metadata = manifest.metadata;
+        // Validate metadata exists
+        if (!metadata || typeof metadata !== 'object') {
+            return ValidationUtils.failure([
+                ValidationUtils.error('MISSING_METADATA', 'Document manifest must have metadata', 'metadata'),
+            ]);
+        }
+        // Validate format (required)
+        if (!metadata.format) {
+            errors.push(ValidationUtils.error('MISSING_FORMAT', 'Document must specify a format', 'metadata.format'));
+        }
+        else if (!VALID_FORMATS.includes(metadata.format)) {
+            errors.push(ValidationUtils.error('INVALID_FORMAT', `Invalid document format: "${metadata.format}". Must be one of: ${VALID_FORMATS.join(', ')}`, 'metadata.format', metadata.format));
+        }
+        // Validate content (required)
+        if (!metadata.content || typeof metadata.content !== 'string') {
+            errors.push(ValidationUtils.error('MISSING_CONTENT', 'Document must specify a content resource', 'metadata.content'));
+        }
+        else {
+            // Check if content references an existing resource
+            if (!ValidationUtils.resourceExists(metadata.content, manifest.resources)) {
+                warnings.push(ValidationUtils.warning('CONTENT_NOT_RESOURCE', `Content "${metadata.content}" does not match a resource ID`, 'metadata.content', 'Ensure the content field references a valid resource ID'));
+            }
+        }
+        // Validate language if specified
+        if (metadata.language) {
+            if (typeof metadata.language !== 'string') {
+                errors.push(ValidationUtils.error('INVALID_LANGUAGE', 'Language must be a string', 'metadata.language'));
+            }
+            else if (!ValidationUtils.isValidLanguageCode(metadata.language)) {
+                warnings.push(ValidationUtils.warning('INVALID_LANGUAGE_CODE', `Language "${metadata.language}" is not a valid ISO 639-1 code`, 'metadata.language', 'Use a 2-letter language code like "en", "es", "fr"'));
+            }
+        }
+        // Validate toc if specified
+        if (metadata.toc) {
+            if (!Array.isArray(metadata.toc)) {
+                errors.push(ValidationUtils.error('INVALID_TOC', 'Table of contents must be an array', 'metadata.toc'));
+            }
+            else {
+                for (let i = 0; i < metadata.toc.length; i++) {
+                    const entry = metadata.toc[i];
+                    const entryPath = `metadata.toc[${i}]`;
+                    if (!entry || typeof entry !== 'object') {
+                        errors.push(ValidationUtils.error('INVALID_TOC_ENTRY', `TOC entry at index ${i} must be an object`, entryPath));
+                        continue;
+                    }
+                    if (!entry.title || typeof entry.title !== 'string') {
+                        errors.push(ValidationUtils.error('MISSING_TOC_TITLE', `TOC entry at index ${i} must have a title`, `${entryPath}.title`));
+                    }
+                    if (typeof entry.level !== 'number' || entry.level < 1 || !Number.isInteger(entry.level)) {
+                        errors.push(ValidationUtils.error('INVALID_TOC_LEVEL', `TOC entry at index ${i} must have a valid level (positive integer)`, `${entryPath}.level`));
+                    }
+                }
+            }
+        }
+        // Validate pageCount if specified
+        if (metadata.pageCount !== undefined) {
+            if (typeof metadata.pageCount !== 'number' || metadata.pageCount <= 0 || !Number.isInteger(metadata.pageCount)) {
+                errors.push(ValidationUtils.error('INVALID_PAGE_COUNT', 'Page count must be a positive integer', 'metadata.pageCount'));
+            }
+        }
+        // Validate wordCount if specified
+        if (metadata.wordCount !== undefined) {
+            if (typeof metadata.wordCount !== 'number' || metadata.wordCount < 0 || !Number.isInteger(metadata.wordCount)) {
+                errors.push(ValidationUtils.error('INVALID_WORD_COUNT', 'Word count must be a non-negative integer', 'metadata.wordCount'));
+            }
+        }
+        // Validate readingTime if specified
+        if (metadata.readingTime !== undefined) {
+            if (typeof metadata.readingTime !== 'number' || metadata.readingTime <= 0) {
+                errors.push(ValidationUtils.error('INVALID_READING_TIME', 'Reading time must be a positive number (minutes)', 'metadata.readingTime'));
+            }
+        }
+        // Validate keywords if specified
+        if (metadata.keywords) {
+            if (!Array.isArray(metadata.keywords)) {
+                errors.push(ValidationUtils.error('INVALID_KEYWORDS', 'Keywords must be an array of strings', 'metadata.keywords'));
+            }
+            else {
+                for (let i = 0; i < metadata.keywords.length; i++) {
+                    if (typeof metadata.keywords[i] !== 'string') {
+                        errors.push(ValidationUtils.error('INVALID_KEYWORD', `Keyword at index ${i} must be a string`, `metadata.keywords[${i}]`));
+                    }
+                }
+            }
+        }
+        // Validate references if specified
+        if (metadata.references) {
+            if (!Array.isArray(metadata.references)) {
+                errors.push(ValidationUtils.error('INVALID_REFERENCES', 'References must be an array', 'metadata.references'));
+            }
+            else {
+                const refIds = new Set();
+                for (let i = 0; i < metadata.references.length; i++) {
+                    const ref = metadata.references[i];
+                    const refPath = `metadata.references[${i}]`;
+                    if (!ref || typeof ref !== 'object') {
+                        errors.push(ValidationUtils.error('INVALID_REFERENCE', `Reference at index ${i} must be an object`, refPath));
+                        continue;
+                    }
+                    if (!ref.id || typeof ref.id !== 'string') {
+                        errors.push(ValidationUtils.error('MISSING_REFERENCE_ID', `Reference at index ${i} must have an id`, `${refPath}.id`));
+                    }
+                    else {
+                        if (refIds.has(ref.id)) {
+                            errors.push(ValidationUtils.error('DUPLICATE_REFERENCE_ID', `Duplicate reference id: "${ref.id}"`, `${refPath}.id`));
+                        }
+                        refIds.add(ref.id);
+                    }
+                    if (!ref.title || typeof ref.title !== 'string') {
+                        errors.push(ValidationUtils.error('MISSING_REFERENCE_TITLE', `Reference at index ${i} must have a title`, `${refPath}.title`));
+                    }
+                    // Validate URL if present
+                    if (ref.url && !ValidationUtils.isValidURL(ref.url)) {
+                        warnings.push(ValidationUtils.warning('INVALID_REFERENCE_URL', `Reference "${ref.id}" has an invalid URL`, `${refPath}.url`));
+                    }
+                }
+            }
+        }
+        // Validate status if specified
+        if (metadata.status) {
+            if (!VALID_STATUSES.includes(metadata.status)) {
+                errors.push(ValidationUtils.error('INVALID_STATUS', `Invalid document status: "${metadata.status}". Must be one of: ${VALID_STATUSES.join(', ')}`, 'metadata.status', metadata.status));
+            }
+        }
+        // Validate revision if specified
+        if (metadata.revision !== undefined) {
+            if (typeof metadata.revision !== 'number' || metadata.revision < 1 || !Number.isInteger(metadata.revision)) {
+                errors.push(ValidationUtils.error('INVALID_REVISION', 'Revision must be a positive integer', 'metadata.revision'));
+            }
+        }
+        // Suggest adding language
+        if (!metadata.language) {
+            warnings.push(ValidationUtils.warning('MISSING_LANGUAGE', 'Consider specifying the document language', 'metadata.language', 'Add a language code like "en" for English'));
+        }
+        // Suggest adding abstract
+        if (!metadata.abstract) {
+            warnings.push(ValidationUtils.warning('MISSING_ABSTRACT', 'Consider adding an abstract or summary', 'metadata.abstract'));
+        }
+        // Check that at least one document resource exists
+        const docResources = manifest.resources.filter(r => r.type === 'document' ||
+            r.type === 'text' ||
+            r.contentType.includes('text/') ||
+            r.contentType.includes('markdown') ||
+            r.contentType.includes('html') ||
+            r.contentType.includes('pdf'));
+        if (docResources.length === 0) {
+            warnings.push(ValidationUtils.warning('NO_DOCUMENT_RESOURCES', 'No document resources found. Ensure resources have appropriate types', 'resources'));
+        }
+        return errors.length > 0
+            ? ValidationUtils.failure(errors, warnings)
+            : ValidationUtils.success(warnings);
+    }
+}