@umituz/react-native-ai-generation-content 1.12.3 → 1.12.4

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@umituz/react-native-ai-generation-content",
-  "version": "1.12.3",
+  "version": "1.12.4",
   "description": "Provider-agnostic AI generation orchestration for React Native",
   "main": "src/index.ts",
   "types": "src/index.ts",
   "exports": {
     ".": "./src/index.ts",
-    "./prompts": "./src/domains/prompts/index.ts"
+    "./prompts": "./src/domains/prompts/index.ts",
+    "./content-moderation": "./src/domains/content-moderation/index.ts"
   },
   "files": [
     "src"

package/src/domains/content-moderation/domain/entities/moderation.types.ts

@@ -0,0 +1,84 @@
+/**
+ * Content Moderation Types
+ * Core type definitions for content moderation system
+ */
+
+export type ContentType = "text" | "image" | "video" | "voice";
+
+export type ModerationSeverity = "low" | "medium" | "high" | "critical";
+
+export type AgeRating = "G" | "PG" | "PG-13" | "R" | "NC-17" | "18+";
+
+export type ViolationType =
+  | "explicit_content"
+  | "violence"
+  | "hate_speech"
+  | "harassment"
+  | "illegal_activity"
+  | "spam"
+  | "copyright"
+  | "personal_info"
+  | "dangerous_content";
+
+export interface ModerationRule {
+  id: string;
+  name: string;
+  description: string;
+  contentTypes: ContentType[];
+  severity: ModerationSeverity;
+  violationType: ViolationType;
+  patterns: string[];
+  enabled: boolean;
+}
+
+export interface ModerationResult {
+  isAllowed: boolean;
+  violations: Violation[];
+  confidence: number;
+  suggestedAction: "allow" | "warn" | "block";
+}
+
+export interface Violation {
+  ruleId: string;
+  ruleName: string;
+  violationType: ViolationType;
+  severity: ModerationSeverity;
+  matchedPattern: string;
+  context: string;
+  suggestion: string;
+}
+
+export interface ModerationContext {
+  userId?: string;
+  contentType: ContentType;
+  content: string;
+  metadata?: Record<string, unknown>;
+}
+
+export interface ModerationConfig {
+  strictMode: boolean;
+  autoBlock: boolean;
+  logViolations: boolean;
+  notifyUser: boolean;
+  customRules?: ModerationRule[];
+  suggestionMessages?: SuggestionMessages;
+}
+
+export interface SuggestionMessages {
+  explicit_content?: string;
+  violence?: string;
+  hate_speech?: string;
+  harassment?: string;
+  illegal_activity?: string;
+  spam?: string;
+  copyright?: string;
+  personal_info?: string;
+  dangerous_content?: string;
+  default?: string;
+}
+
+export interface ValidationLimits {
+  maxTextLength?: number;
+  maxVoiceTextLength?: number;
+  maxUriLength?: number;
+}

package/src/domains/content-moderation/domain/interfaces/content-filter.interface.ts

@@ -0,0 +1,24 @@
+/**
+ * Content Filter Interface
+ * Contract for content filtering implementations
+ */
+
+import type { Violation } from "../entities/moderation.types";
+
+export interface ContentFilterResult {
+  isAllowed: boolean;
+  violations: Violation[];
+}
+
+export interface IContentFilter {
+  filter(content: string): ContentFilterResult;
+  addBlockedWord(word: string): void;
+  addBlockedPattern(pattern: string): void;
+  removeBlockedWord(word: string): void;
+  removeBlockedPattern(pattern: string): void;
+  clearFilters(): void;
+}
+
+export interface IModerator {
+  moderate(content: string): ContentFilterResult;
+}

package/src/domains/content-moderation/index.ts

@@ -0,0 +1,67 @@
+/**
+ * @umituz/react-native-ai-content-moderation
+ * Content moderation service for AI applications
+ *
+ * Usage:
+ *   import {
+ *     contentModerationService,
+ *     ContentPolicyViolationError,
+ *     rulesRegistry
+ *   } from '@umituz/react-native-ai-content-moderation';
+ */
+
+// =============================================================================
+// DOMAIN LAYER - Types
+// =============================================================================
+
+export type {
+  ContentType,
+  ModerationSeverity,
+  AgeRating,
+  ViolationType,
+  ModerationRule,
+  ModerationResult,
+  Violation,
+  ModerationContext,
+  ModerationConfig,
+  SuggestionMessages,
+  ValidationLimits,
+} from "./domain/entities/moderation.types";
+
+export type {
+  ContentFilterResult,
+  IContentFilter,
+  IModerator,
+} from "./domain/interfaces/content-filter.interface";
+
+// =============================================================================
+// INFRASTRUCTURE LAYER - Services
+// =============================================================================
+
+export {
+  contentModerationService,
+  patternMatcherService,
+  textModerator,
+  imageModerator,
+  videoModerator,
+  voiceModerator,
+  BaseModerator,
+} from "./infrastructure/services";
+
+export type {
+  PatternMatch,
+  ModerationResult as ModeratorResult,
+} from "./infrastructure/services";
+
+// =============================================================================
+// INFRASTRUCTURE LAYER - Rules
+// =============================================================================
+
+export { rulesRegistry } from "./infrastructure/rules/rules-registry";
+export { defaultModerationRules } from "./infrastructure/rules/default-rules.data";
+
+// =============================================================================
+// PRESENTATION LAYER - Exceptions
+// =============================================================================
+
+export { ContentPolicyViolationError } from "./presentation/exceptions/content-policy-violation.exception";

package/src/domains/content-moderation/infrastructure/rules/default-rules.data.ts

@@ -0,0 +1,144 @@
+/**
+ * Default Moderation Rules
+ * Built-in rules for content filtering - can be extended via config
+ */
+
+import type { ModerationRule } from "../../domain/entities/moderation.types";
+
+const explicitContentRules: ModerationRule[] = [
+  {
+    id: "explicit-001",
+    name: "Sexual Content",
+    description: "Detects explicit sexual content and nudity",
+    contentTypes: ["text", "image"],
+    severity: "critical",
+    violationType: "explicit_content",
+    patterns: [
+      "\\bnude\\b",
+      "\\bnaked\\b",
+      "\\bnsfw\\b",
+      "\\bsexual\\b",
+      "\\berotic\\b",
+      "\\bporn\\b",
+      "\\bxxx\\b",
+      "\\badult content\\b",
+      "\\bexplicit\\b",
+    ],
+    enabled: true,
+  },
+  {
+    id: "explicit-002",
+    name: "Body Parts Focus",
+    description: "Detects inappropriate body part references",
+    contentTypes: ["text", "image"],
+    severity: "high",
+    violationType: "explicit_content",
+    patterns: [
+      "\\bbreasts?\\b",
+      "\\bbutt\\b",
+      "\\bass\\b",
+      "\\bchest\\b.*\\b(exposed|revealing|bare)\\b",
+      "\\bcleavage\\b",
+    ],
+    enabled: true,
+  },
+];
+
+const violenceRules: ModerationRule[] = [
+  {
+    id: "violence-001",
+    name: "Graphic Violence",
+    description: "Detects graphic violence and gore",
+    contentTypes: ["text", "image", "video"],
+    severity: "critical",
+    violationType: "violence",
+    patterns: [
+      "\\bgore\\b",
+      "\\bblood\\b.*\\b(splatter|dripping|pool)\\b",
+      "\\bmurder\\b",
+      "\\bkilling\\b",
+      "\\btorture\\b",
+      "\\bdismember\\b",
+      "\\bbeheading\\b",
+    ],
+    enabled: true,
+  },
+  {
+    id: "violence-002",
+    name: "Weapons Focus",
+    description: "Detects inappropriate weapon usage context",
+    contentTypes: ["text", "image", "video"],
+    severity: "medium",
+    violationType: "violence",
+    patterns: [
+      "\\bgun\\b.*\\b(pointing|aimed|shooting)\\b",
+      "\\bweapon\\b.*\\b(attack|assault|harm)\\b",
+      "\\bknife\\b.*\\b(stabbing|cutting|slashing)\\b",
+    ],
+    enabled: true,
+  },
+];
+
+const hateSpeechRules: ModerationRule[] = [
+  {
+    id: "hate-001",
+    name: "Discriminatory Language",
+    description: "Detects hate speech and discriminatory content",
+    contentTypes: ["text", "voice"],
+    severity: "critical",
+    violationType: "hate_speech",
+    patterns: [
+      "\\bhate\\b.*\\b(speech|crime|group)\\b",
+      "\\bracist\\b",
+      "\\bsexist\\b",
+      "\\bbigot\\b",
+      "\\bxenophobia\\b",
+    ],
+    enabled: true,
+  },
+];
+
+const illegalActivityRules: ModerationRule[] = [
+  {
+    id: "illegal-001",
+    name: "Drug Content",
+    description: "Detects drug-related content",
+    contentTypes: ["text", "image", "video"],
+    severity: "high",
+    violationType: "illegal_activity",
+    patterns: [
+      "\\bdrug\\b.*\\b(dealing|trafficking|manufacturing)\\b",
+      "\\bcocaine\\b",
+      "\\bheroin\\b",
+      "\\bmethamphetamine\\b",
+      "\\billegal\\b.*\\b(substance|drug)\\b",
+    ],
+    enabled: true,
+  },
+];
+
+const personalInfoRules: ModerationRule[] = [
+  {
+    id: "pii-001",
+    name: "Personal Information",
+    description: "Detects personal identifiable information",
+    contentTypes: ["text", "image"],
+    severity: "medium",
+    violationType: "personal_info",
+    patterns: [
+      "\\b\\d{3}-\\d{2}-\\d{4}\\b",
+      "\\b\\d{16}\\b",
+      "\\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,}\\b",
+      "\\b\\d{3}[-.]?\\d{3}[-.]?\\d{4}\\b",
+    ],
+    enabled: true,
+  },
+];
+
+export const defaultModerationRules: ModerationRule[] = [
+  ...explicitContentRules,
+  ...violenceRules,
+  ...hateSpeechRules,
+  ...illegalActivityRules,
+  ...personalInfoRules,
+];

package/src/domains/content-moderation/infrastructure/rules/rules-registry.ts

@@ -0,0 +1,75 @@
+/**
+ * Rules Registry
+ * Manages moderation rules - allows adding/removing custom rules
+ */
+
+import type {
+  ContentType,
+  ModerationRule,
+} from "../../domain/entities/moderation.types";
+import { defaultModerationRules } from "./default-rules.data";
+
+class RulesRegistry {
+  private rules: ModerationRule[] = [...defaultModerationRules];
+
+  getRules(): ModerationRule[] {
+    return this.rules;
+  }
+
+  getRulesByContentType(contentType: ContentType): ModerationRule[] {
+    return this.rules.filter(
+      (rule) => rule.enabled && rule.contentTypes.includes(contentType)
+    );
+  }
+
+  getRuleById(id: string): ModerationRule | undefined {
+    return this.rules.find((rule) => rule.id === id);
+  }
+
+  addRule(rule: ModerationRule): void {
+    const existing = this.getRuleById(rule.id);
+    if (existing) {
+      this.updateRule(rule.id, rule);
+      return;
+    }
+    this.rules.push(rule);
+  }
+
+  addRules(rules: ModerationRule[]): void {
+    rules.forEach((rule) => this.addRule(rule));
+  }
+
+  updateRule(id: string, updates: Partial<ModerationRule>): boolean {
+    const index = this.rules.findIndex((rule) => rule.id === id);
+    if (index === -1) return false;
+
+    this.rules[index] = { ...this.rules[index], ...updates };
+    return true;
+  }
+
+  removeRule(id: string): boolean {
+    const index = this.rules.findIndex((rule) => rule.id === id);
+    if (index === -1) return false;
+
+    this.rules.splice(index, 1);
+    return true;
+  }
+
+  enableRule(id: string): boolean {
+    return this.updateRule(id, { enabled: true });
+  }
+
+  disableRule(id: string): boolean {
+    return this.updateRule(id, { enabled: false });
+  }
+
+  resetToDefaults(): void {
+    this.rules = [...defaultModerationRules];
+  }
+
+  clearAllRules(): void {
+    this.rules = [];
+  }
+}
+
+export const rulesRegistry = new RulesRegistry();

package/src/domains/content-moderation/infrastructure/services/content-moderation.service.ts

@@ -0,0 +1,150 @@
+/**
+ * Content Moderation Service
+ * Orchestrates content moderation by type
+ */
+
+import type {
+  ContentType,
+  ModerationResult,
+  ModerationContext,
+  Violation,
+  SuggestionMessages,
+  ValidationLimits,
+  ModerationRule,
+} from "../../domain/entities/moderation.types";
+import { textModerator } from "./moderators/text.moderator";
+import { imageModerator } from "./moderators/image.moderator";
+import { videoModerator } from "./moderators/video.moderator";
+import { voiceModerator } from "./moderators/voice.moderator";
+import { rulesRegistry } from "../rules/rules-registry";
+
+declare const __DEV__: boolean;
+
+interface ServiceConfig {
+  suggestionMessages?: SuggestionMessages;
+  validationLimits?: ValidationLimits;
+  customRules?: ModerationRule[];
+}
+
+class ContentModerationService {
+  configure(config: ServiceConfig): void {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[ContentModeration] Configure:", {
+        hasSuggestionMessages: !!config.suggestionMessages,
+        hasValidationLimits: !!config.validationLimits,
+        customRulesCount: config.customRules?.length ?? 0,
+      });
+    }
+
+    if (config.suggestionMessages) {
+      textModerator.setSuggestionMessages(config.suggestionMessages);
+      voiceModerator.setSuggestionMessages(config.suggestionMessages);
+    }
+
+    if (config.validationLimits) {
+      const { maxTextLength, maxVoiceTextLength, maxUriLength } =
+        config.validationLimits;
+
+      if (maxTextLength) textModerator.setMaxLength(maxTextLength);
+      if (maxVoiceTextLength) voiceModerator.setMaxLength(maxVoiceTextLength);
+      if (maxUriLength) {
+        imageModerator.setMaxUriLength(maxUriLength);
+        videoModerator.setMaxUriLength(maxUriLength);
+      }
+    }
+
+    if (config.customRules) {
+      rulesRegistry.addRules(config.customRules);
+    }
+  }
+
+  async moderate(context: ModerationContext): Promise<ModerationResult> {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[ContentModeration] Moderate started:", {
+        contentType: context.contentType,
+        contentLength: context.content?.length ?? 0,
+      });
+    }
+
+    const result = this.moderateByType(context.contentType, context.content);
+    const moderationResult: ModerationResult = {
+      isAllowed: result.isAllowed,
+      violations: result.violations,
+      confidence: this.calculateConfidence(result.violations),
+      suggestedAction: this.determineAction(result.violations),
+    };
+
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[ContentModeration] Moderate completed:", {
+        contentType: context.contentType,
+        isAllowed: moderationResult.isAllowed,
+        violationsCount: moderationResult.violations?.length ?? 0,
+        suggestedAction: moderationResult.suggestedAction,
+      });
+    }
+
+    return moderationResult;
+  }
+
+  async isContentAllowed(
+    content: string,
+    contentType: ContentType
+  ): Promise<boolean> {
+    const result = this.moderateByType(contentType, content);
+    return result.isAllowed;
+  }
+
+  moderateSync(
+    content: string,
+    contentType: ContentType
+  ): { isAllowed: boolean; violations: Violation[] } {
+    return this.moderateByType(contentType, content);
+  }
+
+  private moderateByType(
+    contentType: ContentType,
+    content: string
+  ): { isAllowed: boolean; violations: Violation[] } {
+    switch (contentType) {
+      case "text":
+        return textModerator.moderate(content);
+      case "image":
+        return imageModerator.moderate(content);
+      case "video":
+        return videoModerator.moderate(content);
+      case "voice":
+        return voiceModerator.moderate(content);
+      default:
+        return { isAllowed: true, violations: [] };
+    }
+  }
+
+  private calculateConfidence(violations: Violation[]): number {
+    if (violations.length === 0) return 1.0;
+
+    const weights = { critical: 1.0, high: 0.75, medium: 0.5, low: 0.25 };
+    const score = violations.reduce(
+      (sum, v) => sum + (weights[v.severity] || 0.25),
+      0
+    );
+
+    return Math.min(1.0, score / 2);
+  }
+
+  private determineAction(
+    violations: Violation[]
+  ): "allow" | "warn" | "block" {
+    if (violations.length === 0) return "allow";
+
+    const hasCritical = violations.some((v) => v.severity === "critical");
+    const hasHigh = violations.some((v) => v.severity === "high");
+
+    if (hasCritical || hasHigh) return "block";
+    return "warn";
+  }
+}
+
+export const contentModerationService = new ContentModerationService();

package/src/domains/content-moderation/infrastructure/services/index.ts

@@ -0,0 +1,8 @@
+/**
+ * Services Index
+ * Exports all infrastructure services
+ */
+
+export { contentModerationService } from "./content-moderation.service";
+export { patternMatcherService, type PatternMatch } from "./pattern-matcher.service";
+export * from "./moderators";

package/src/domains/content-moderation/infrastructure/services/moderators/base.moderator.ts

@@ -0,0 +1,62 @@
+/**
+ * Base Moderator
+ * Shared functionality for all content moderators
+ */
+
+import type {
+  Violation,
+  ViolationType,
+  SuggestionMessages,
+} from "../../../domain/entities/moderation.types";
+
+export interface ModerationResult {
+  isAllowed: boolean;
+  violations: Violation[];
+}
+
+const DEFAULT_SUGGESTIONS: Record<string, string> = {
+  explicit_content: "Remove explicit content",
+  violence: "Remove violent content",
+  hate_speech: "Remove discriminatory language",
+  harassment: "Remove harassing content",
+  illegal_activity: "Remove illegal content references",
+  spam: "Remove spam content",
+  copyright: "Remove copyrighted content",
+  personal_info: "Remove personal information",
+  dangerous_content: "Remove dangerous content",
+  default: "Modify content to comply with guidelines",
+};
+
+export abstract class BaseModerator {
+  protected customSuggestions?: SuggestionMessages;
+
+  setSuggestionMessages(messages: SuggestionMessages): void {
+    this.customSuggestions = messages;
+  }
+
+  protected getSuggestion(type: ViolationType): string {
+    if (this.customSuggestions?.[type]) {
+      return this.customSuggestions[type] as string;
+    }
+    return DEFAULT_SUGGESTIONS[type] || DEFAULT_SUGGESTIONS.default;
+  }
+
+  protected createViolation(
+    id: string,
+    ruleName: string,
+    message: string,
+    violationType: ViolationType = "illegal_activity"
+  ): Violation {
+    return {
+      ruleId: id,
+      ruleName,
+      violationType,
+      severity: "high",
+      matchedPattern: "validation",
+      context: "",
+      suggestion: message,
+    };
+  }
+
+  abstract moderate(content: string): ModerationResult;
+}

package/src/domains/content-moderation/infrastructure/services/moderators/image.moderator.ts

@@ -0,0 +1,64 @@
+/**
+ * Image Content Moderator
+ * Validates and moderates image URIs
+ */
+
+import type { Violation } from "../../../domain/entities/moderation.types";
+import { BaseModerator, type ModerationResult } from "./base.moderator";
+
+const DEFAULT_PROTOCOLS = ["http:", "https:", "file:", "data:"];
+const DEFAULT_MAX_URI_LENGTH = 2048;
+
+class ImageModerator extends BaseModerator {
+  private allowedProtocols = DEFAULT_PROTOCOLS;
+  private maxUriLength = DEFAULT_MAX_URI_LENGTH;
+
+  setAllowedProtocols(protocols: string[]): void {
+    this.allowedProtocols = protocols;
+  }
+
+  setMaxUriLength(length: number): void {
+    this.maxUriLength = length;
+  }
+
+  moderate(imageUri: string): ModerationResult {
+    const validationError = this.validate(imageUri);
+    if (validationError) {
+      return { isAllowed: false, violations: [validationError] };
+    }
+
+    return { isAllowed: true, violations: [] };
+  }
+
+  private validate(uri: string): Violation | null {
+    if (!uri || typeof uri !== "string") {
+      return this.createViolation("empty-uri", "Image Validation", "empty URI");
+    }
+
+    if (uri.length > this.maxUriLength) {
+      return this.createViolation(
+        "uri-too-long",
+        "Image Validation",
+        "URI too long"
+      );
+    }
+
+    if (!this.hasValidProtocol(uri)) {
+      return this.createViolation(
+        "invalid-protocol",
+        "Image Validation",
+        "invalid protocol"
+      );
+    }
+
+    return null;
+  }
+
+  private hasValidProtocol(uri: string): boolean {
+    return this.allowedProtocols.some((protocol) =>
+      uri.toLowerCase().startsWith(protocol)
+    );
+  }
+}
+
+export const imageModerator = new ImageModerator();

package/src/domains/content-moderation/infrastructure/services/moderators/index.ts

@@ -0,0 +1,10 @@
+/**
+ * Moderators Index
+ * Exports all content moderators
+ */
+
+export { textModerator } from "./text.moderator";
+export { imageModerator } from "./image.moderator";
+export { videoModerator } from "./video.moderator";
+export { voiceModerator } from "./voice.moderator";
+export { BaseModerator, type ModerationResult } from "./base.moderator";

package/src/domains/content-moderation/infrastructure/services/moderators/text.moderator.ts

@@ -0,0 +1,144 @@
+/**
+ * Text Content Moderator
+ * Validates and moderates text content
+ */
+
+import type { Violation } from "../../../domain/entities/moderation.types";
+import { patternMatcherService } from "../pattern-matcher.service";
+import { rulesRegistry } from "../../rules/rules-registry";
+import { BaseModerator, type ModerationResult } from "./base.moderator";
+
+declare const __DEV__: boolean;
+
+const DEFAULT_MAX_LENGTH = 10000;
+
+const MALICIOUS_CODE_PATTERNS = [
+  /<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi,
+  /javascript:/gi,
+  /on\w+\s*=/gi,
+];
+
+const PROMPT_INJECTION_PATTERNS = [
+  /ignore\s+(all\s+)?(previous|prior|above)\s+(instructions?|prompts?|rules?)/gi,
+  /disregard\s+(all\s+)?(previous|prior|above)\s+(instructions?|prompts?)/gi,
+  /forget\s+(all\s+)?(previous|prior|your)\s+(instructions?|prompts?|rules?)/gi,
+  /you\s+are\s+now\s+(a|an)\s+/gi,
+  /act\s+as\s+(if|though)\s+you/gi,
+  /pretend\s+(you\s+are|to\s+be)/gi,
+  /bypass\s+(your\s+)?(safety|content|moderation)/gi,
+  /override\s+(your\s+)?(restrictions?|limitations?|rules?)/gi,
+  /jailbreak/gi,
+  /DAN\s*mode/gi,
+  /developer\s+mode\s+(enabled|on|activated)/gi,
+  /system\s*:\s*/gi,
+  /\[system\]/gi,
+  /<<\s*sys\s*>>/gi,
+];
+
+class TextModerator extends BaseModerator {
+  private maxLength = DEFAULT_MAX_LENGTH;
+
+  setMaxLength(length: number): void {
+    this.maxLength = length;
+  }
+
+  moderate(content: string): ModerationResult {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[TextModerator] moderate() called", {
+        contentLength: content?.length ?? 0,
+      });
+    }
+
+    const validationError = this.validate(content);
+    if (validationError) {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        // eslint-disable-next-line no-console
+        console.log("[TextModerator] validation failed", {
+          ruleId: validationError.ruleId,
+          violationType: validationError.violationType,
+        });
+      }
+      return { isAllowed: false, violations: [validationError] };
+    }
+
+    const violations = this.evaluateRules(content);
+
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[TextModerator] moderate() completed", {
+        isAllowed: violations.length === 0,
+        violationsCount: violations.length,
+      });
+    }
+
+    return { isAllowed: violations.length === 0, violations };
+  }
+
+  private validate(content: string): Violation | null {
+    if (!content || typeof content !== "string") {
+      return this.createViolation("empty-content", "Validation", "empty");
+    }
+
+    if (content.length > this.maxLength) {
+      return this.createViolation("too-long", "Validation", "length exceeded");
+    }
+
+    if (this.containsMaliciousCode(content)) {
+      return this.createViolation(
+        "malicious",
+        "Security",
+        "malicious code",
+        "dangerous_content"
+      );
+    }
+
+    if (this.containsPromptInjection(content)) {
+      return this.createViolation(
+        "prompt-injection",
+        "Security",
+        "prompt injection",
+        "dangerous_content"
+      );
+    }
+
+    return null;
+  }
+
+  private containsMaliciousCode(content: string): boolean {
+    return MALICIOUS_CODE_PATTERNS.some((pattern) => pattern.test(content));
+  }
+
+  private containsPromptInjection(content: string): boolean {
+    return PROMPT_INJECTION_PATTERNS.some((pattern) => pattern.test(content));
+  }
+
+  private evaluateRules(content: string): Violation[] {
+    const rules = rulesRegistry.getRulesByContentType("text");
+    const violations: Violation[] = [];
+
+    for (const rule of rules) {
+      const matches = patternMatcherService.matchAnyPattern(
+        content,
+        rule.patterns
+      );
+      const matched = matches.find((m) => m.matched);
+
+      if (matched) {
+        violations.push({
+          ruleId: rule.id,
+          ruleName: rule.name,
+          violationType: rule.violationType,
+          severity: rule.severity,
+          matchedPattern: matched.matchedText || "",
+          context: content.slice(0, 100),
+          suggestion: this.getSuggestion(rule.violationType),
+        });
+      }
+    }
+
+    return violations;
+  }
+}
+
+export const textModerator = new TextModerator();

package/src/domains/content-moderation/infrastructure/services/moderators/video.moderator.ts

@@ -0,0 +1,64 @@
+/**
+ * Video Content Moderator
+ * Validates and moderates video URIs
+ */
+
+import type { Violation } from "../../../domain/entities/moderation.types";
+import { BaseModerator, type ModerationResult } from "./base.moderator";
+
+const DEFAULT_PROTOCOLS = ["http:", "https:", "file:"];
+const DEFAULT_MAX_URI_LENGTH = 2048;
+
+class VideoModerator extends BaseModerator {
+  private allowedProtocols = DEFAULT_PROTOCOLS;
+  private maxUriLength = DEFAULT_MAX_URI_LENGTH;
+
+  setAllowedProtocols(protocols: string[]): void {
+    this.allowedProtocols = protocols;
+  }
+
+  setMaxUriLength(length: number): void {
+    this.maxUriLength = length;
+  }
+
+  moderate(videoUri: string): ModerationResult {
+    const validationError = this.validate(videoUri);
+    if (validationError) {
+      return { isAllowed: false, violations: [validationError] };
+    }
+
+    return { isAllowed: true, violations: [] };
+  }
+
+  private validate(uri: string): Violation | null {
+    if (!uri || typeof uri !== "string") {
+      return this.createViolation("empty-uri", "Video Validation", "empty URI");
+    }
+
+    if (uri.length > this.maxUriLength) {
+      return this.createViolation(
+        "uri-too-long",
+        "Video Validation",
+        "URI too long"
+      );
+    }
+
+    if (!this.hasValidProtocol(uri)) {
+      return this.createViolation(
+        "invalid-protocol",
+        "Video Validation",
+        "invalid protocol"
+      );
+    }
+
+    return null;
+  }
+
+  private hasValidProtocol(uri: string): boolean {
+    return this.allowedProtocols.some((protocol) =>
+      uri.toLowerCase().startsWith(protocol)
+    );
+  }
+}
+
+export const videoModerator = new VideoModerator();

package/src/domains/content-moderation/infrastructure/services/moderators/voice.moderator.ts

@@ -0,0 +1,74 @@
+/**
+ * Voice Content Moderator
+ * Validates and moderates voice/TTS text content
+ */
+
+import type { Violation } from "../../../domain/entities/moderation.types";
+import { patternMatcherService } from "../pattern-matcher.service";
+import { rulesRegistry } from "../../rules/rules-registry";
+import { BaseModerator, type ModerationResult } from "./base.moderator";
+
+const DEFAULT_MAX_LENGTH = 5000;
+
+class VoiceModerator extends BaseModerator {
+  private maxLength = DEFAULT_MAX_LENGTH;
+
+  setMaxLength(length: number): void {
+    this.maxLength = length;
+  }
+
+  moderate(text: string): ModerationResult {
+    const validationError = this.validate(text);
+    if (validationError) {
+      return { isAllowed: false, violations: [validationError] };
+    }
+
+    const violations = this.evaluateRules(text);
+    return { isAllowed: violations.length === 0, violations };
+  }
+
+  private validate(text: string): Violation | null {
+    if (!text || typeof text !== "string") {
+      return this.createViolation("empty-text", "Voice Validation", "empty");
+    }
+
+    if (text.length > this.maxLength) {
+      return this.createViolation(
+        "too-long",
+        "Voice Validation",
+        "length exceeded"
+      );
+    }
+
+    return null;
+  }
+
+  private evaluateRules(text: string): Violation[] {
+    const rules = rulesRegistry.getRulesByContentType("voice");
+    const violations: Violation[] = [];
+
+    for (const rule of rules) {
+      const matches = patternMatcherService.matchAnyPattern(
+        text,
+        rule.patterns
+      );
+      const matched = matches.find((m) => m.matched);
+
+      if (matched) {
+        violations.push({
+          ruleId: rule.id,
+          ruleName: rule.name,
+          violationType: rule.violationType,
+          severity: rule.severity,
+          matchedPattern: matched.matchedText || "",
+          context: text.slice(0, 100),
+          suggestion: this.getSuggestion(rule.violationType),
+        });
+      }
+    }
+
+    return violations;
+  }
+}
+
+export const voiceModerator = new VoiceModerator();

package/src/domains/content-moderation/infrastructure/services/pattern-matcher.service.ts

@@ -0,0 +1,51 @@
+/**
+ * Pattern Matcher Service
+ * Utility service for regex pattern matching
+ */
+
+export interface PatternMatch {
+  pattern: string;
+  matched: boolean;
+  matchedText?: string;
+  position?: number;
+}
+
+class PatternMatcherService {
+  matchPattern(content: string, pattern: string): PatternMatch {
+    try {
+      const regex = new RegExp(pattern, "gi");
+      const match = regex.exec(content);
+
+      if (match) {
+        return {
+          pattern,
+          matched: true,
+          matchedText: match[0],
+          position: match.index,
+        };
+      }
+
+      return { pattern, matched: false };
+    } catch {
+      return { pattern, matched: false };
+    }
+  }
+
+  matchAnyPattern(content: string, patterns: string[]): PatternMatch[] {
+    return patterns.map((pattern) => this.matchPattern(content, pattern));
+  }
+
+  matchAllPatterns(content: string, patterns: string[]): boolean {
+    return patterns.every(
+      (pattern) => this.matchPattern(content, pattern).matched
+    );
+  }
+
+  hasAnyMatch(content: string, patterns: string[]): boolean {
+    return patterns.some(
+      (pattern) => this.matchPattern(content, pattern).matched
+    );
+  }
+}
+
+export const patternMatcherService = new PatternMatcherService();

package/src/domains/content-moderation/presentation/exceptions/content-policy-violation.exception.ts

@@ -0,0 +1,48 @@
+/**
+ * Content Policy Violation Exception
+ * Custom error class for content policy violations
+ */
+
+import type {
+  Violation,
+  ViolationType,
+} from "../../domain/entities/moderation.types";
+
+export class ContentPolicyViolationError extends Error {
+  public readonly violations: Violation[];
+
+  constructor(violations: Violation[], message?: string) {
+    const defaultMessage = `Content policy violation: ${violations
+      .map((v) => v.ruleName)
+      .join(", ")}`;
+    super(message || defaultMessage);
+    this.name = "ContentPolicyViolationError";
+    this.violations = violations;
+  }
+
+  getUserMessage(): string {
+    if (this.violations.length === 0) {
+      return "Content policy violation detected.";
+    }
+
+    const firstViolation = this.violations[0];
+    return firstViolation?.suggestion || "Please modify your content.";
+  }
+
+  getViolationTypes(): ViolationType[] {
+    return this.violations.map((v) => v.violationType);
+  }
+
+  hasViolationType(type: ViolationType): boolean {
+    return this.violations.some((v) => v.violationType === type);
+  }
+
+  getSeverityLevel(): "low" | "medium" | "high" | "critical" {
+    const severities = this.violations.map((v) => v.severity);
+
+    if (severities.includes("critical")) return "critical";
+    if (severities.includes("high")) return "high";
+    if (severities.includes("medium")) return "medium";
+    return "low";
+  }
+}

package/src/index.ts

@@ -227,3 +227,9 @@ export type {
 // =============================================================================
 
 export * from "./domains/prompts";
+
+// =============================================================================
+// DOMAINS - Content Moderation
+// =============================================================================
+
+export * from "./domains/content-moderation";