@originals/sdk 1.4.2 → 1.4.5

package/dist/kinds/types.js

@@ -0,0 +1,25 @@
+/**
+ * Originals Kind System Types
+ *
+ * Defines the typed "Kinds" for Originals - a classification system that
+ * enables kind-specific validation, metadata schemas, and behaviors.
+ */
+/**
+ * The supported Original kinds
+ * Each kind represents a category of digital asset with specific requirements
+ */
+export var OriginalKind;
+(function (OriginalKind) {
+    /** Executable application with runtime and entrypoint */
+    OriginalKind["App"] = "originals:kind:app";
+    /** AI agent or autonomous system with capabilities and model info */
+    OriginalKind["Agent"] = "originals:kind:agent";
+    /** Reusable code module with exports and dependencies */
+    OriginalKind["Module"] = "originals:kind:module";
+    /** Structured data collection with schema definition */
+    OriginalKind["Dataset"] = "originals:kind:dataset";
+    /** Media content (image, audio, video) with format metadata */
+    OriginalKind["Media"] = "originals:kind:media";
+    /** Text document with formatting and sections */
+    OriginalKind["Document"] = "originals:kind:document";
+})(OriginalKind || (OriginalKind = {}));

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

@@ -0,0 +1,14 @@
+/**
+ * Agent Kind Validator
+ *
+ * Validates manifests for AI agents or autonomous systems with capabilities and model info.
+ */
+import { OriginalKind, type OriginalManifest, type ValidationResult } from '../types';
+import { BaseKindValidator } from './base';
+/**
+ * Validator for Agent Originals
+ */
+export declare class AgentValidator extends BaseKindValidator<OriginalKind.Agent> {
+    readonly kind = OriginalKind.Agent;
+    protected validateKind(manifest: OriginalManifest<OriginalKind.Agent>): ValidationResult;
+}

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;
+}