@originals/sdk 1.4.3 → 1.5.0

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

@@ -0,0 +1,14 @@
+/**
+ * Media Kind Validator
+ *
+ * Validates manifests for media content (image, audio, video) with format metadata.
+ */
+import { OriginalKind, type OriginalManifest, type ValidationResult } from '../types';
+import { BaseKindValidator } from './base';
+/**
+ * Validator for Media Originals
+ */
+export declare class MediaValidator extends BaseKindValidator<OriginalKind.Media> {
+    readonly kind = OriginalKind.Media;
+    protected validateKind(manifest: OriginalManifest<OriginalKind.Media>): ValidationResult;
+}

package/dist/kinds/validators/MediaValidator.js

@@ -0,0 +1,172 @@
+/**
+ * Media Kind Validator
+ *
+ * Validates manifests for media content (image, audio, video) with format metadata.
+ */
+import { OriginalKind } from '../types';
+import { BaseKindValidator, ValidationUtils } from './base';
+/**
+ * Valid media types
+ */
+const VALID_MEDIA_TYPES = ['image', 'audio', 'video', '3d', 'animation'];
+/**
+ * Common MIME types by media type
+ */
+const COMMON_MIME_TYPES = {
+    image: [
+        'image/jpeg', 'image/png', 'image/gif', 'image/webp', 'image/svg+xml',
+        'image/avif', 'image/bmp', 'image/tiff', 'image/heic', 'image/heif',
+    ],
+    audio: [
+        'audio/mpeg', 'audio/mp3', 'audio/wav', 'audio/ogg', 'audio/flac',
+        'audio/aac', 'audio/webm', 'audio/midi', 'audio/x-wav',
+    ],
+    video: [
+        'video/mp4', 'video/webm', 'video/ogg', 'video/quicktime', 'video/x-msvideo',
+        'video/x-matroska', 'video/mpeg',
+    ],
+    '3d': [
+        'model/gltf+json', 'model/gltf-binary', 'model/obj', 'model/stl',
+        'application/octet-stream',
+    ],
+    animation: [
+        'image/gif', 'video/mp4', 'video/webm', 'application/json', // Lottie
+    ],
+};
+/**
+ * Validator for Media Originals
+ */
+export class MediaValidator extends BaseKindValidator {
+    constructor() {
+        super(...arguments);
+        this.kind = OriginalKind.Media;
+    }
+    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', 'Media manifest must have metadata', 'metadata'),
+            ]);
+        }
+        // Validate mediaType (required)
+        if (!metadata.mediaType) {
+            errors.push(ValidationUtils.error('MISSING_MEDIA_TYPE', 'Media must specify a mediaType', 'metadata.mediaType'));
+        }
+        else if (!VALID_MEDIA_TYPES.includes(metadata.mediaType)) {
+            errors.push(ValidationUtils.error('INVALID_MEDIA_TYPE', `Invalid mediaType: "${metadata.mediaType}". Must be one of: ${VALID_MEDIA_TYPES.join(', ')}`, 'metadata.mediaType', metadata.mediaType));
+        }
+        // Validate mimeType (required)
+        if (!metadata.mimeType || typeof metadata.mimeType !== 'string') {
+            errors.push(ValidationUtils.error('MISSING_MIME_TYPE', 'Media must specify a mimeType', 'metadata.mimeType'));
+        }
+        else if (!ValidationUtils.isValidMimeType(metadata.mimeType)) {
+            errors.push(ValidationUtils.error('INVALID_MIME_TYPE', `Invalid mimeType format: "${metadata.mimeType}"`, 'metadata.mimeType', metadata.mimeType));
+        }
+        else if (metadata.mediaType) {
+            // Check if MIME type matches the declared media type
+            const expectedMimeTypes = COMMON_MIME_TYPES[metadata.mediaType];
+            if (expectedMimeTypes && !expectedMimeTypes.includes(metadata.mimeType)) {
+                warnings.push(ValidationUtils.warning('MIME_TYPE_MISMATCH', `mimeType "${metadata.mimeType}" is not typically associated with mediaType "${metadata.mediaType}"`, 'metadata.mimeType'));
+            }
+        }
+        // Validate dimensions for images and video
+        if (metadata.mediaType === 'image' || metadata.mediaType === 'video') {
+            if (metadata.dimensions) {
+                if (typeof metadata.dimensions !== 'object') {
+                    errors.push(ValidationUtils.error('INVALID_DIMENSIONS', 'Dimensions must be an object', 'metadata.dimensions'));
+                }
+                else {
+                    if (typeof metadata.dimensions.width !== 'number' || metadata.dimensions.width <= 0) {
+                        errors.push(ValidationUtils.error('INVALID_WIDTH', 'Width must be a positive number', 'metadata.dimensions.width'));
+                    }
+                    if (typeof metadata.dimensions.height !== 'number' || metadata.dimensions.height <= 0) {
+                        errors.push(ValidationUtils.error('INVALID_HEIGHT', 'Height must be a positive number', 'metadata.dimensions.height'));
+                    }
+                }
+            }
+            else {
+                warnings.push(ValidationUtils.warning('MISSING_DIMENSIONS', `Consider specifying dimensions for ${metadata.mediaType} content`, 'metadata.dimensions'));
+            }
+        }
+        // Validate duration for audio and video
+        if (metadata.mediaType === 'audio' || metadata.mediaType === 'video') {
+            if (metadata.duration !== undefined) {
+                if (typeof metadata.duration !== 'number' || metadata.duration < 0) {
+                    errors.push(ValidationUtils.error('INVALID_DURATION', 'Duration must be a non-negative number (seconds)', 'metadata.duration'));
+                }
+            }
+            else {
+                warnings.push(ValidationUtils.warning('MISSING_DURATION', `Consider specifying duration for ${metadata.mediaType} content`, 'metadata.duration'));
+            }
+        }
+        // Validate frameRate for video
+        if (metadata.mediaType === 'video' || metadata.mediaType === 'animation') {
+            if (metadata.frameRate !== undefined) {
+                if (typeof metadata.frameRate !== 'number' || metadata.frameRate <= 0) {
+                    errors.push(ValidationUtils.error('INVALID_FRAME_RATE', 'Frame rate must be a positive number', 'metadata.frameRate'));
+                }
+            }
+        }
+        // Validate audio-specific fields
+        if (metadata.mediaType === 'audio' || metadata.mediaType === 'video') {
+            if (metadata.audioChannels !== undefined) {
+                if (typeof metadata.audioChannels !== 'number' ||
+                    metadata.audioChannels <= 0 ||
+                    !Number.isInteger(metadata.audioChannels)) {
+                    errors.push(ValidationUtils.error('INVALID_AUDIO_CHANNELS', 'Audio channels must be a positive integer', 'metadata.audioChannels'));
+                }
+            }
+            if (metadata.sampleRate !== undefined) {
+                if (typeof metadata.sampleRate !== 'number' || metadata.sampleRate <= 0) {
+                    errors.push(ValidationUtils.error('INVALID_SAMPLE_RATE', 'Sample rate must be a positive number', 'metadata.sampleRate'));
+                }
+            }
+        }
+        // Validate bitrate if specified
+        if (metadata.bitrate !== undefined) {
+            if (typeof metadata.bitrate !== 'number' || metadata.bitrate <= 0) {
+                errors.push(ValidationUtils.error('INVALID_BITRATE', 'Bitrate must be a positive number (kbps)', 'metadata.bitrate'));
+            }
+        }
+        // Validate thumbnail if specified
+        if (metadata.thumbnail) {
+            if (typeof metadata.thumbnail !== 'string') {
+                errors.push(ValidationUtils.error('INVALID_THUMBNAIL', 'Thumbnail must be a string (resource ID)', 'metadata.thumbnail'));
+            }
+            else if (!ValidationUtils.resourceExists(metadata.thumbnail, manifest.resources)) {
+                warnings.push(ValidationUtils.warning('THUMBNAIL_NOT_RESOURCE', `Thumbnail "${metadata.thumbnail}" does not match a resource ID`, 'metadata.thumbnail'));
+            }
+        }
+        // Validate preview if specified
+        if (metadata.preview) {
+            if (typeof metadata.preview !== 'string') {
+                errors.push(ValidationUtils.error('INVALID_PREVIEW', 'Preview must be a string (resource ID)', 'metadata.preview'));
+            }
+            else if (!ValidationUtils.resourceExists(metadata.preview, manifest.resources)) {
+                warnings.push(ValidationUtils.warning('PREVIEW_NOT_RESOURCE', `Preview "${metadata.preview}" does not match a resource ID`, 'metadata.preview'));
+            }
+        }
+        // Suggest adding alt text for accessibility
+        if (!metadata.altText && metadata.mediaType === 'image') {
+            warnings.push(ValidationUtils.warning('MISSING_ALT_TEXT', 'Consider adding altText for accessibility', 'metadata.altText'));
+        }
+        // Check that at least one media resource exists
+        const mediaResources = manifest.resources.filter(r => r.type === 'media' ||
+            r.type === 'image' ||
+            r.type === 'audio' ||
+            r.type === 'video' ||
+            r.contentType.startsWith('image/') ||
+            r.contentType.startsWith('audio/') ||
+            r.contentType.startsWith('video/') ||
+            r.contentType.startsWith('model/'));
+        if (mediaResources.length === 0) {
+            warnings.push(ValidationUtils.warning('NO_MEDIA_RESOURCES', 'No media resources found. Ensure resources have appropriate types', 'resources'));
+        }
+        return errors.length > 0
+            ? ValidationUtils.failure(errors, warnings)
+            : ValidationUtils.success(warnings);
+    }
+}

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

@@ -0,0 +1,14 @@
+/**
+ * Module Kind Validator
+ *
+ * Validates manifests for reusable code modules with exports and dependencies.
+ */
+import { OriginalKind, type OriginalManifest, type ValidationResult } from '../types';
+import { BaseKindValidator } from './base';
+/**
+ * Validator for Module Originals
+ */
+export declare class ModuleValidator extends BaseKindValidator<OriginalKind.Module> {
+    readonly kind = OriginalKind.Module;
+    protected validateKind(manifest: OriginalManifest<OriginalKind.Module>): ValidationResult;
+}

package/dist/kinds/validators/ModuleValidator.js

@@ -0,0 +1,140 @@
+/**
+ * Module Kind Validator
+ *
+ * Validates manifests for reusable code modules with exports and dependencies.
+ */
+import { OriginalKind } from '../types';
+import { BaseKindValidator, ValidationUtils } from './base';
+/**
+ * Valid module formats
+ */
+const VALID_FORMATS = ['esm', 'commonjs', 'umd', 'amd', 'iife'];
+/**
+ * Validator for Module Originals
+ */
+export class ModuleValidator extends BaseKindValidator {
+    constructor() {
+        super(...arguments);
+        this.kind = OriginalKind.Module;
+    }
+    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', 'Module manifest must have metadata', 'metadata'),
+            ]);
+        }
+        // Validate format (required)
+        if (!metadata.format) {
+            errors.push(ValidationUtils.error('MISSING_FORMAT', 'Module must specify a format', 'metadata.format'));
+        }
+        else if (!VALID_FORMATS.includes(metadata.format)) {
+            errors.push(ValidationUtils.error('INVALID_FORMAT', `Invalid module format: "${metadata.format}". Must be one of: ${VALID_FORMATS.join(', ')}`, 'metadata.format', metadata.format));
+        }
+        // Validate main (required)
+        if (!metadata.main || typeof metadata.main !== 'string') {
+            errors.push(ValidationUtils.error('MISSING_MAIN', 'Module must specify a main entrypoint', 'metadata.main'));
+        }
+        else {
+            // Check if main references an existing resource
+            if (!ValidationUtils.resourceExists(metadata.main, manifest.resources)) {
+                warnings.push(ValidationUtils.warning('MAIN_NOT_RESOURCE', `Main entrypoint "${metadata.main}" does not match a resource ID`, 'metadata.main', 'Ensure the main entrypoint is a valid resource ID'));
+            }
+        }
+        // Validate types if specified
+        if (metadata.types) {
+            if (typeof metadata.types !== 'string') {
+                errors.push(ValidationUtils.error('INVALID_TYPES', 'Types must be a string (resource ID)', 'metadata.types'));
+            }
+            else if (!ValidationUtils.resourceExists(metadata.types, manifest.resources)) {
+                warnings.push(ValidationUtils.warning('TYPES_NOT_RESOURCE', `Types file "${metadata.types}" does not match a resource ID`, 'metadata.types'));
+            }
+        }
+        else {
+            warnings.push(ValidationUtils.warning('MISSING_TYPES', 'Consider adding TypeScript type definitions', 'metadata.types', 'Add a .d.ts file for better TypeScript support'));
+        }
+        // Validate exports if specified
+        if (metadata.exports) {
+            if (typeof metadata.exports !== 'object' || Array.isArray(metadata.exports)) {
+                errors.push(ValidationUtils.error('INVALID_EXPORTS', 'Exports must be an object', 'metadata.exports'));
+            }
+            else {
+                for (const [key, value] of Object.entries(metadata.exports)) {
+                    if (typeof value === 'string') {
+                        // Simple string export is valid
+                        continue;
+                    }
+                    else if (typeof value === 'object' && value !== null) {
+                        // Conditional exports object
+                        const exportObj = value;
+                        if (!exportObj.import && !exportObj.require) {
+                            warnings.push(ValidationUtils.warning('INCOMPLETE_EXPORT', `Export "${key}" should have at least 'import' or 'require' field`, `metadata.exports.${key}`));
+                        }
+                    }
+                    else {
+                        errors.push(ValidationUtils.error('INVALID_EXPORT', `Export "${key}" must be a string or object`, `metadata.exports.${key}`));
+                    }
+                }
+                // Check for "." export (main export)
+                if (!('.' in metadata.exports)) {
+                    warnings.push(ValidationUtils.warning('MISSING_MAIN_EXPORT', 'Consider adding a "." export for the main module entry', 'metadata.exports'));
+                }
+            }
+        }
+        // Validate peer dependencies if specified
+        if (metadata.peerDependencies) {
+            if (typeof metadata.peerDependencies !== 'object' || Array.isArray(metadata.peerDependencies)) {
+                errors.push(ValidationUtils.error('INVALID_PEER_DEPS', 'Peer dependencies must be an object', 'metadata.peerDependencies'));
+            }
+            else {
+                for (const [name, version] of Object.entries(metadata.peerDependencies)) {
+                    if (typeof version !== 'string') {
+                        errors.push(ValidationUtils.error('INVALID_PEER_DEP_VERSION', `Peer dependency "${name}" must have a string version`, `metadata.peerDependencies.${name}`));
+                    }
+                }
+            }
+        }
+        // Validate browser field if specified
+        if (metadata.browser) {
+            if (typeof metadata.browser !== 'string') {
+                errors.push(ValidationUtils.error('INVALID_BROWSER', 'Browser field must be a string (resource ID)', 'metadata.browser'));
+            }
+            else if (!ValidationUtils.resourceExists(metadata.browser, manifest.resources)) {
+                warnings.push(ValidationUtils.warning('BROWSER_NOT_RESOURCE', `Browser entrypoint "${metadata.browser}" does not match a resource ID`, 'metadata.browser'));
+            }
+        }
+        // Validate sideEffects if specified
+        if (metadata.sideEffects !== undefined) {
+            if (typeof metadata.sideEffects !== 'boolean' && !Array.isArray(metadata.sideEffects)) {
+                errors.push(ValidationUtils.error('INVALID_SIDE_EFFECTS', 'sideEffects must be a boolean or array of strings', 'metadata.sideEffects'));
+            }
+            else if (Array.isArray(metadata.sideEffects)) {
+                for (let i = 0; i < metadata.sideEffects.length; i++) {
+                    if (typeof metadata.sideEffects[i] !== 'string') {
+                        errors.push(ValidationUtils.error('INVALID_SIDE_EFFECT_ENTRY', `sideEffects entry at index ${i} must be a string`, `metadata.sideEffects[${i}]`));
+                    }
+                }
+            }
+        }
+        // Validate TypeScript config if specified
+        if (metadata.typescript) {
+            if (typeof metadata.typescript !== 'object') {
+                errors.push(ValidationUtils.error('INVALID_TYPESCRIPT', 'TypeScript config must be an object', 'metadata.typescript'));
+            }
+        }
+        // Check that at least one code resource exists
+        const codeResources = manifest.resources.filter(r => r.contentType.includes('javascript') ||
+            r.contentType.includes('typescript') ||
+            r.contentType.includes('json') ||
+            r.type === 'code');
+        if (codeResources.length === 0) {
+            warnings.push(ValidationUtils.warning('NO_CODE_RESOURCES', 'No code resources found. Ensure resources have appropriate content types', 'resources'));
+        }
+        return errors.length > 0
+            ? ValidationUtils.failure(errors, warnings)
+            : ValidationUtils.success(warnings);
+    }
+}

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

@@ -0,0 +1,96 @@
+/**
+ * Base validator interface and common validation utilities
+ */
+import type { OriginalKind, OriginalManifest, ValidationResult, ValidationError, ValidationWarning, BaseManifest } from '../types';
+import type { AssetResource } from '../../types/common';
+/**
+ * Interface for kind-specific validators
+ */
+export interface KindValidator<K extends OriginalKind = OriginalKind> {
+    /** The kind this validator handles */
+    readonly kind: K;
+    /**
+     * Validate a manifest for this kind
+     * @param manifest - The manifest to validate
+     * @returns Validation result with errors and warnings
+     */
+    validate(manifest: OriginalManifest<K>): ValidationResult;
+}
+/**
+ * Common validation utilities
+ */
+export declare class ValidationUtils {
+    /**
+     * Check if a string is a valid semantic version
+     */
+    static isValidSemver(version: string): boolean;
+    /**
+     * Check if a string is a valid DID
+     */
+    static isValidDID(did: string): boolean;
+    /**
+     * Check if a string is a valid SPDX license identifier
+     */
+    static isValidSPDXLicense(license: string): boolean;
+    /**
+     * Check if a string is a valid MIME type
+     */
+    static isValidMimeType(mimeType: string): boolean;
+    /**
+     * Check if a string is a valid URL
+     */
+    static isValidURL(url: string): boolean;
+    /**
+     * Check if a string is a valid ISO 639-1 language code
+     */
+    static isValidLanguageCode(code: string): boolean;
+    /**
+     * Check if a resource ID exists in the resources array
+     */
+    static resourceExists(resourceId: string, resources: AssetResource[]): boolean;
+    /**
+     * Get a resource by ID
+     */
+    static getResource(resourceId: string, resources: AssetResource[]): AssetResource | undefined;
+    /**
+     * Create a validation error
+     */
+    static error(code: string, message: string, path?: string, value?: unknown): ValidationError;
+    /**
+     * Create a validation warning
+     */
+    static warning(code: string, message: string, path?: string, suggestion?: string): ValidationWarning;
+    /**
+     * Create a successful validation result
+     */
+    static success(warnings?: ValidationWarning[]): ValidationResult;
+    /**
+     * Create a failed validation result
+     */
+    static failure(errors: ValidationError[], warnings?: ValidationWarning[]): ValidationResult;
+    /**
+     * Merge multiple validation results
+     */
+    static merge(...results: ValidationResult[]): ValidationResult;
+}
+/**
+ * Base validator class with common validation logic
+ */
+export declare abstract class BaseKindValidator<K extends OriginalKind> implements KindValidator<K> {
+    abstract readonly kind: K;
+    /**
+     * Validate a manifest
+     * Combines base validation with kind-specific validation
+     */
+    validate(manifest: OriginalManifest<K>): ValidationResult;
+    /**
+     * Validate base manifest fields common to all kinds
+     */
+    protected validateBase(manifest: BaseManifest & {
+        kind: K;
+    }): ValidationResult;
+    /**
+     * Kind-specific validation to be implemented by subclasses
+     */
+    protected abstract validateKind(manifest: OriginalManifest<K>): ValidationResult;
+}

package/dist/kinds/validators/base.js

@@ -0,0 +1,218 @@
+/**
+ * Base validator interface and common validation utilities
+ */
+/**
+ * Common validation utilities
+ */
+export class ValidationUtils {
+    /**
+     * Check if a string is a valid semantic version
+     */
+    static isValidSemver(version) {
+        const semverRegex = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/;
+        return semverRegex.test(version);
+    }
+    /**
+     * Check if a string is a valid DID
+     */
+    static isValidDID(did) {
+        // DID format: did:method:identifier (identifier can contain : for path segments)
+        // Examples: did:peer:123, did:webvh:example.com:user, did:btco:12345
+        const didRegex = /^did:[a-z0-9]+:[a-zA-Z0-9._:%-]+$/;
+        return didRegex.test(did);
+    }
+    /**
+     * Check if a string is a valid SPDX license identifier
+     */
+    static isValidSPDXLicense(license) {
+        // Common SPDX identifiers (not exhaustive)
+        const commonLicenses = [
+            'MIT', 'Apache-2.0', 'GPL-3.0', 'GPL-2.0', 'BSD-2-Clause', 'BSD-3-Clause',
+            'ISC', 'MPL-2.0', 'LGPL-3.0', 'AGPL-3.0', 'Unlicense', 'CC0-1.0',
+            'CC-BY-4.0', 'CC-BY-SA-4.0', 'CC-BY-NC-4.0', 'WTFPL', 'Zlib', 'BSL-1.0',
+            'MIT-0', 'Apache-1.0', 'Apache-1.1', 'EPL-2.0', 'EUPL-1.2',
+        ];
+        return commonLicenses.includes(license) || /^[A-Z0-9][A-Z0-9._-]*$/i.test(license);
+    }
+    /**
+     * Check if a string is a valid MIME type
+     */
+    static isValidMimeType(mimeType) {
+        const mimeRegex = /^[a-zA-Z0-9][a-zA-Z0-9!#$&^_.+-]{0,126}\/[a-zA-Z0-9][a-zA-Z0-9!#$&^_.+-]{0,126}$/;
+        return mimeRegex.test(mimeType);
+    }
+    /**
+     * Check if a string is a valid URL
+     */
+    static isValidURL(url) {
+        try {
+            new URL(url);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Check if a string is a valid ISO 639-1 language code
+     */
+    static isValidLanguageCode(code) {
+        // ISO 639-1 is 2 lowercase letters
+        return /^[a-z]{2}$/.test(code);
+    }
+    /**
+     * Check if a resource ID exists in the resources array
+     */
+    static resourceExists(resourceId, resources) {
+        return resources.some(r => r.id === resourceId);
+    }
+    /**
+     * Get a resource by ID
+     */
+    static getResource(resourceId, resources) {
+        return resources.find(r => r.id === resourceId);
+    }
+    /**
+     * Create a validation error
+     */
+    static error(code, message, path, value) {
+        return { code, message, path, value };
+    }
+    /**
+     * Create a validation warning
+     */
+    static warning(code, message, path, suggestion) {
+        return { code, message, path, suggestion };
+    }
+    /**
+     * Create a successful validation result
+     */
+    static success(warnings = []) {
+        return { isValid: true, errors: [], warnings };
+    }
+    /**
+     * Create a failed validation result
+     */
+    static failure(errors, warnings = []) {
+        return { isValid: false, errors, warnings };
+    }
+    /**
+     * Merge multiple validation results
+     */
+    static merge(...results) {
+        const errors = [];
+        const warnings = [];
+        for (const result of results) {
+            errors.push(...result.errors);
+            warnings.push(...result.warnings);
+        }
+        return {
+            isValid: errors.length === 0,
+            errors,
+            warnings,
+        };
+    }
+}
+/**
+ * Base validator class with common validation logic
+ */
+export class BaseKindValidator {
+    /**
+     * Validate a manifest
+     * Combines base validation with kind-specific validation
+     */
+    validate(manifest) {
+        const baseResult = this.validateBase(manifest);
+        const kindResult = this.validateKind(manifest);
+        return ValidationUtils.merge(baseResult, kindResult);
+    }
+    /**
+     * Validate base manifest fields common to all kinds
+     */
+    validateBase(manifest) {
+        const errors = [];
+        const warnings = [];
+        // Validate kind
+        if (!manifest.kind) {
+            errors.push(ValidationUtils.error('MISSING_KIND', 'Manifest must specify a kind', 'kind'));
+        }
+        // Validate name
+        if (!manifest.name || typeof manifest.name !== 'string') {
+            errors.push(ValidationUtils.error('MISSING_NAME', 'Manifest must have a name', 'name'));
+        }
+        else if (manifest.name.length < 1 || manifest.name.length > 200) {
+            errors.push(ValidationUtils.error('INVALID_NAME_LENGTH', 'Name must be between 1 and 200 characters', 'name', manifest.name));
+        }
+        // Validate version
+        if (!manifest.version || typeof manifest.version !== 'string') {
+            errors.push(ValidationUtils.error('MISSING_VERSION', 'Manifest must have a version', 'version'));
+        }
+        else if (!ValidationUtils.isValidSemver(manifest.version)) {
+            errors.push(ValidationUtils.error('INVALID_VERSION', 'Version must be a valid semantic version (e.g., 1.0.0)', 'version', manifest.version));
+        }
+        // Validate resources
+        if (!manifest.resources || !Array.isArray(manifest.resources)) {
+            errors.push(ValidationUtils.error('MISSING_RESOURCES', 'Manifest must have resources array', 'resources'));
+        }
+        else if (manifest.resources.length === 0) {
+            errors.push(ValidationUtils.error('EMPTY_RESOURCES', 'Manifest must have at least one resource', 'resources'));
+        }
+        else {
+            // Validate each resource
+            for (let i = 0; i < manifest.resources.length; i++) {
+                const resource = manifest.resources[i];
+                const resourcePath = `resources[${i}]`;
+                if (!resource.id || typeof resource.id !== 'string') {
+                    errors.push(ValidationUtils.error('INVALID_RESOURCE_ID', `Resource at index ${i} must have an id`, `${resourcePath}.id`));
+                }
+                if (!resource.type || typeof resource.type !== 'string') {
+                    errors.push(ValidationUtils.error('INVALID_RESOURCE_TYPE', `Resource at index ${i} must have a type`, `${resourcePath}.type`));
+                }
+                if (!resource.contentType || !ValidationUtils.isValidMimeType(resource.contentType)) {
+                    errors.push(ValidationUtils.error('INVALID_CONTENT_TYPE', `Resource at index ${i} must have a valid MIME contentType`, `${resourcePath}.contentType`, resource.contentType));
+                }
+                if (!resource.hash || typeof resource.hash !== 'string' || !/^[0-9a-fA-F]+$/.test(resource.hash)) {
+                    errors.push(ValidationUtils.error('INVALID_RESOURCE_HASH', `Resource at index ${i} must have a valid hex hash`, `${resourcePath}.hash`));
+                }
+            }
+            // Check for duplicate resource IDs
+            const resourceIds = manifest.resources.map(r => r.id);
+            const duplicates = resourceIds.filter((id, index) => resourceIds.indexOf(id) !== index);
+            if (duplicates.length > 0) {
+                errors.push(ValidationUtils.error('DUPLICATE_RESOURCE_IDS', `Duplicate resource IDs found: ${[...new Set(duplicates)].join(', ')}`, 'resources'));
+            }
+        }
+        // Validate dependencies if present
+        if (manifest.dependencies) {
+            if (!Array.isArray(manifest.dependencies)) {
+                errors.push(ValidationUtils.error('INVALID_DEPENDENCIES', 'Dependencies must be an array', 'dependencies'));
+            }
+            else {
+                for (let i = 0; i < manifest.dependencies.length; i++) {
+                    const dep = manifest.dependencies[i];
+                    const depPath = `dependencies[${i}]`;
+                    if (!dep.did || !ValidationUtils.isValidDID(dep.did)) {
+                        errors.push(ValidationUtils.error('INVALID_DEPENDENCY_DID', `Dependency at index ${i} must have a valid DID`, `${depPath}.did`, dep.did));
+                    }
+                }
+            }
+        }
+        // Validate optional fields
+        if (manifest.license && !ValidationUtils.isValidSPDXLicense(manifest.license)) {
+            warnings.push(ValidationUtils.warning('UNKNOWN_LICENSE', `License "${manifest.license}" is not a recognized SPDX identifier`, 'license', 'Use a valid SPDX license identifier like MIT, Apache-2.0, etc.'));
+        }
+        if (manifest.homepage && !ValidationUtils.isValidURL(manifest.homepage)) {
+            errors.push(ValidationUtils.error('INVALID_HOMEPAGE', 'Homepage must be a valid URL', 'homepage', manifest.homepage));
+        }
+        if (manifest.repository && !ValidationUtils.isValidURL(manifest.repository)) {
+            errors.push(ValidationUtils.error('INVALID_REPOSITORY', 'Repository must be a valid URL', 'repository', manifest.repository));
+        }
+        // Suggest adding description if missing
+        if (!manifest.description) {
+            warnings.push(ValidationUtils.warning('MISSING_DESCRIPTION', 'Consider adding a description for better discoverability', 'description', 'Add a brief description of this Original'));
+        }
+        return errors.length > 0
+            ? ValidationUtils.failure(errors, warnings)
+            : ValidationUtils.success(warnings);
+    }
+}

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

@@ -0,0 +1,10 @@
+/**
+ * Kind validators exports
+ */
+export { BaseKindValidator, ValidationUtils, type KindValidator } from './base';
+export { AppValidator } from './AppValidator';
+export { AgentValidator } from './AgentValidator';
+export { ModuleValidator } from './ModuleValidator';
+export { DatasetValidator } from './DatasetValidator';
+export { MediaValidator } from './MediaValidator';
+export { DocumentValidator } from './DocumentValidator';