ad2app-lib 1.10.0 → 1.14.0

package/src/publish-limits/index.test.ts

@@ -0,0 +1,116 @@
+/**
+ * Contract tests for the canonical publish-limits table (AD2-1140 Wave 1).
+ *
+ * These lock the shape every consumer (frontend compose, backend media
+ * upload validation) will depend on in Wave 2: all 10 platforms present,
+ * every field positive and correctly typed, and the universal upload cap
+ * pinned to the value ad2app-backend actually enforces.
+ */
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+
+import { ALL_PUBLISH_PLATFORMS, MAX_UPLOAD_BYTES, PUBLISH_LIMITS } from './index';
+import type { PublishPlatform } from './types';
+
+const EXPECTED_PLATFORMS: PublishPlatform[] = [
+  'twitter',
+  'instagram',
+  'tiktok',
+  'linkedin',
+  'facebook',
+  'youtube',
+  'threads',
+  'reddit',
+  'pinterest',
+  'bluesky',
+];
+
+test('PUBLISH_LIMITS has exactly the 10 expected platform keys', () => {
+  const keys = Object.keys(PUBLISH_LIMITS).sort();
+  assert.deepEqual(keys, [...EXPECTED_PLATFORMS].sort());
+  assert.equal(keys.length, 10);
+});
+
+test('ALL_PUBLISH_PLATFORMS matches the PUBLISH_LIMITS keys', () => {
+  assert.deepEqual([...ALL_PUBLISH_PLATFORMS].sort(), Object.keys(PUBLISH_LIMITS).sort());
+});
+
+test('every platform has a complete, correctly typed, positive limits object', () => {
+  for (const platform of EXPECTED_PLATFORMS) {
+    const limits = PUBLISH_LIMITS[platform];
+    assert.ok(limits, `missing PUBLISH_LIMITS entry for ${platform}`);
+
+    assert.equal(typeof limits.charLimit, 'number', `${platform}.charLimit not a number`);
+    assert.ok(limits.charLimit > 0, `${platform}.charLimit must be positive`);
+
+    assert.equal(typeof limits.maxImages, 'number', `${platform}.maxImages not a number`);
+    assert.ok(limits.maxImages >= 0, `${platform}.maxImages must be >= 0`);
+
+    assert.equal(typeof limits.maxVideos, 'number', `${platform}.maxVideos not a number`);
+    assert.ok(limits.maxVideos >= 0, `${platform}.maxVideos must be >= 0`);
+
+    assert.equal(
+      typeof limits.maxVideoDurationSec,
+      'number',
+      `${platform}.maxVideoDurationSec not a number`,
+    );
+    assert.ok(limits.maxVideoDurationSec > 0, `${platform}.maxVideoDurationSec must be positive`);
+
+    assert.equal(typeof limits.acceptsVideo, 'boolean', `${platform}.acceptsVideo not a boolean`);
+    assert.equal(
+      typeof limits.acceptsImages,
+      'boolean',
+      `${platform}.acceptsImages not a boolean`,
+    );
+
+    // A platform that doesn't accept a media type should have a 0 count for it,
+    // and vice versa — catches copy-paste drift between the flag and the count.
+    assert.equal(
+      limits.acceptsImages,
+      limits.maxImages > 0,
+      `${platform}: acceptsImages must agree with maxImages > 0`,
+    );
+    assert.equal(
+      limits.acceptsVideo,
+      limits.maxVideos > 0,
+      `${platform}: acceptsVideo must agree with maxVideos > 0`,
+    );
+  }
+});
+
+test('youtube is the sole image-less platform (acceptsImages=false, maxImages=0)', () => {
+  assert.equal(PUBLISH_LIMITS.youtube.acceptsImages, false);
+  assert.equal(PUBLISH_LIMITS.youtube.maxImages, 0);
+  for (const platform of EXPECTED_PLATFORMS.filter((p) => p !== 'youtube')) {
+    assert.equal(PUBLISH_LIMITS[platform].acceptsImages, true, `${platform} should accept images`);
+  }
+});
+
+test('MAX_UPLOAD_BYTES is pinned to 500MB — the ad2app-backend enforced universal cap', () => {
+  assert.equal(MAX_UPLOAD_BYTES, 500 * 1024 * 1024);
+});
+
+/**
+ * Drift guard: MAX_UPLOAD_BYTES is a single universal cap, not a per-platform
+ * value — this table intentionally does NOT carry per-platform max
+ * image/video byte sizes (the old platformConstants.ts
+ * metadata.mediaConstraints.maxImageSize/maxVideoSize were dead/unenforced
+ * values this feature retires). Wave 2 adds a consumer-side test in
+ * ad2app-frontend and ad2app-backend asserting their enforced upload cap
+ * equals ad2app-lib/publish-limits MAX_UPLOAD_BYTES, so this table stays the
+ * single source of truth rather than three independently-drifting copies.
+ */
+test('PlatformPublishLimits contract does not carry per-platform byte-size fields', () => {
+  const keys = Object.keys(PUBLISH_LIMITS.instagram);
+  assert.deepEqual(
+    keys.sort(),
+    [
+      'acceptsImages',
+      'acceptsVideo',
+      'charLimit',
+      'maxImages',
+      'maxVideoDurationSec',
+      'maxVideos',
+    ].sort(),
+  );
+});

package/src/publish-limits/index.ts

@@ -0,0 +1,122 @@
+/**
+ * Canonical publish-limits source of truth for ad2app (AD2-1140 Wave 1).
+ *
+ * Single source of truth for (a) the per-platform compose/publish limits
+ * (character count, image/video counts, max video duration) and (b) the
+ * universal media-upload byte cap ad2app itself enforces.
+ *
+ * Provenance:
+ *  - Per-platform values are the CORRECTED figures from
+ *    ad2app-frontend/src/components/social/compose/platformConstants.ts
+ *    (PLATFORM_CONFIGS[*].charLimit / maxImages / maxVideos / acceptsVideo /
+ *    acceptsImages / metadata.mediaConstraints.maxVideoDuration).
+ *  - MAX_UPLOAD_BYTES matches ad2app-backend
+ *    src/modules/late/late-media-upload.service.ts MAX_FILE_SIZE_BYTES + FR-105.
+ *
+ * Wave 2 (separate PRs) makes ad2app-frontend and ad2app-backend import from
+ * here instead of carrying their own copies, and deletes the stale
+ * per-platform maxImageSize/maxVideoSize byte values that this table
+ * deliberately does NOT carry forward (they were never the real enforced
+ * cap — MAX_UPLOAD_BYTES is).
+ */
+
+import type { PlatformPublishLimits, PublishPlatform } from './types';
+
+export type { PlatformPublishLimits, PublishPlatform } from './types';
+
+/**
+ * The universal media-upload byte cap ad2app enforces on every publish,
+ * regardless of destination platform. This is ad2app's own operational
+ * choice (all media flows through the /late/uploadMedia path), NOT a
+ * per-platform maximum — do not read this as "what X/Instagram/etc. allow."
+ */
+export const MAX_UPLOAD_BYTES = 500 * 1024 * 1024;
+
+/** Per-platform compose/publish limits for all 10 connectable platforms. */
+export const PUBLISH_LIMITS: Record<PublishPlatform, PlatformPublishLimits> = {
+  twitter: {
+    charLimit: 280,
+    maxImages: 4,
+    maxVideos: 1,
+    maxVideoDurationSec: 3600,
+    acceptsVideo: true,
+    acceptsImages: true,
+  },
+  instagram: {
+    charLimit: 2200,
+    maxImages: 10,
+    maxVideos: 1,
+    maxVideoDurationSec: 3600,
+    acceptsVideo: true,
+    acceptsImages: true,
+  },
+  tiktok: {
+    charLimit: 2200,
+    maxImages: 35,
+    maxVideos: 1,
+    maxVideoDurationSec: 600,
+    acceptsVideo: true,
+    acceptsImages: true,
+  },
+  linkedin: {
+    charLimit: 3000,
+    maxImages: 9,
+    maxVideos: 1,
+    maxVideoDurationSec: 3600,
+    acceptsVideo: true,
+    acceptsImages: true,
+  },
+  facebook: {
+    charLimit: 63206,
+    maxImages: 10,
+    maxVideos: 1,
+    maxVideoDurationSec: 3600,
+    acceptsVideo: true,
+    acceptsImages: true,
+  },
+  youtube: {
+    charLimit: 5000,
+    maxImages: 0,
+    maxVideos: 1,
+    maxVideoDurationSec: 43200,
+    acceptsVideo: true,
+    acceptsImages: false,
+  },
+  threads: {
+    charLimit: 500,
+    maxImages: 10,
+    maxVideos: 1,
+    maxVideoDurationSec: 300,
+    acceptsVideo: true,
+    acceptsImages: true,
+  },
+  reddit: {
+    charLimit: 40000,
+    maxImages: 20,
+    maxVideos: 1,
+    maxVideoDurationSec: 3600,
+    acceptsVideo: true,
+    acceptsImages: true,
+  },
+  pinterest: {
+    charLimit: 500,
+    maxImages: 1,
+    maxVideos: 1,
+    maxVideoDurationSec: 900,
+    acceptsVideo: true,
+    acceptsImages: true,
+  },
+  bluesky: {
+    charLimit: 300,
+    maxImages: 4,
+    maxVideos: 1,
+    maxVideoDurationSec: 60,
+    acceptsVideo: true,
+    acceptsImages: true,
+  },
+};
+
+/** All publish platforms, canonical order (mirrors PUBLISH_LIMITS key order). */
+export const ALL_PUBLISH_PLATFORMS: PublishPlatform[] = Object.keys(
+  PUBLISH_LIMITS,
+) as PublishPlatform[];

package/src/publish-limits/types.ts

@@ -0,0 +1,38 @@
+/**
+ * Publish-limits domain — types.
+ *
+ * AD2-1140 Wave 1: canonicalizes the per-platform compose/publish limits that
+ * previously lived only as a hand-copied constant in ad2app-frontend
+ * (platformConstants.ts) plus the universal media-size cap enforced in
+ * ad2app-backend (late-media-upload.service.ts). Wave 2 makes both consumers
+ * import from here instead of carrying their own copies.
+ */
+
+/** The 10 platforms ad2app can publish to. Matches the frontend's SocialPlatform union. */
+export type PublishPlatform =
+  | 'twitter'
+  | 'instagram'
+  | 'tiktok'
+  | 'linkedin'
+  | 'facebook'
+  | 'youtube'
+  | 'threads'
+  | 'reddit'
+  | 'pinterest'
+  | 'bluesky';
+
+/** Per-platform compose/publish limits (content, not file-size — see MAX_UPLOAD_BYTES for that). */
+export interface PlatformPublishLimits {
+  /** Max caption/body length in characters. */
+  charLimit: number;
+  /** Max still images per post (0 = platform does not accept images). */
+  maxImages: number;
+  /** Max videos per post (0 = platform does not accept video). */
+  maxVideos: number;
+  /** Max video duration in seconds. */
+  maxVideoDurationSec: number;
+  /** Whether the platform accepts video media at all. */
+  acceptsVideo: boolean;
+  /** Whether the platform accepts image media at all. */
+  acceptsImages: boolean;
+}

package/src/types/scheduling/I_SchedulingAnalytics.test.ts

@@ -0,0 +1,91 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  ANALYTICS_SOURCES,
+  SchedulingAnalyticsKpiDTO,
+} from './I_SchedulingAnalytics';
+
+// AD2-1045 — the analytics partial-failure signal: a KPI response can name
+// which sources were unavailable so a swallowed Zernio failure is never
+// presented as real zeros.
+
+test('ANALYTICS_SOURCES names the four analytics sources', () => {
+  assert.deepEqual(
+    [...ANALYTICS_SOURCES],
+    ['daily-metrics', 'follower-stats', 'content-decay', 'top-posts'],
+  );
+});
+
+test('SchedulingAnalyticsKpiDTO carries engagements and views (AD2-1078 headline metrics)', () => {
+  const kpi = new SchedulingAnalyticsKpiDTO({
+    impressions: 10,
+    reach: 5,
+    engagements: 42,
+    views: 100,
+    engagementRate: 1.2,
+    followerGrowth: 3,
+  });
+  assert.equal(kpi.engagements, 42);
+  assert.equal(kpi.views, 100);
+});
+
+test('SchedulingAnalyticsKpiDTO carries failedSources when provided', () => {
+  const kpi = new SchedulingAnalyticsKpiDTO({
+    impressions: 10,
+    reach: 5,
+    engagements: 4,
+    views: 20,
+    engagementRate: 1.2,
+    followerGrowth: 3,
+    failedSources: ['follower-stats'],
+  });
+  assert.deepEqual(kpi.failedSources, ['follower-stats']);
+});
+
+test('failedSources is optional and absent by default (backward compatible)', () => {
+  const kpi = new SchedulingAnalyticsKpiDTO({
+    impressions: 10,
+    reach: 5,
+    engagements: 4,
+    views: 20,
+    engagementRate: 1.2,
+    followerGrowth: 3,
+  });
+  assert.equal(kpi.failedSources, undefined);
+  assert.equal('failedSources' in JSON.parse(JSON.stringify(kpi)), false);
+});
+
+// AD2-1078 — structural (permanent, platform-level) metric unavailability,
+// distinct from AD2-1045's transient failedSources: Instagram Graph API v22+
+// dropped impressions, TikTok never exposed reach at all.
+
+test('SchedulingAnalyticsKpiDTO carries impressionsAvailable/reachAvailable when provided', () => {
+  const kpi = new SchedulingAnalyticsKpiDTO({
+    impressions: 0,
+    reach: 5,
+    engagements: 4,
+    views: 20,
+    engagementRate: 1.2,
+    followerGrowth: 3,
+    impressionsAvailable: false,
+    reachAvailable: true,
+  });
+  assert.equal(kpi.impressionsAvailable, false);
+  assert.equal(kpi.reachAvailable, true);
+});
+
+test('impressionsAvailable/reachAvailable are optional and absent by default (backward compatible)', () => {
+  const kpi = new SchedulingAnalyticsKpiDTO({
+    impressions: 10,
+    reach: 5,
+    engagements: 4,
+    views: 20,
+    engagementRate: 1.2,
+    followerGrowth: 3,
+  });
+  assert.equal(kpi.impressionsAvailable, undefined);
+  assert.equal(kpi.reachAvailable, undefined);
+  const serialized = JSON.parse(JSON.stringify(kpi));
+  assert.equal('impressionsAvailable' in serialized, false);
+  assert.equal('reachAvailable' in serialized, false);
+});

package/src/types/scheduling/I_SchedulingAnalytics.ts

@@ -5,6 +5,21 @@
  * per-post timeline snapshots, content decay windows, and follower stats.
  */
 
+// ── Analytics sources (AD2-1045) ──────────────────────────────────────────────
+
+/**
+ * The upstream sources an analytics response aggregates. Used by
+ * `failedSources` to name which of them were unavailable.
+ */
+export const ANALYTICS_SOURCES = [
+  'daily-metrics',
+  'follower-stats',
+  'content-decay',
+  'top-posts',
+] as const;
+
+export type AnalyticsSource = (typeof ANALYTICS_SOURCES)[number];
+
 // ── SchedulingAnalyticsKpiDTO ─────────────────────────────────────────────────
 
 /**
@@ -14,14 +29,50 @@
 export class SchedulingAnalyticsKpiDTO {
   impressions: number;
   reach: number;
+  /** Total engagements (likes, comments, shares, saves) across all selected platforms. */
+  engagements: number;
+  /** Total video/media views across all selected platforms. */
+  views: number;
   engagementRate: number;
   followerGrowth: number;
+  /**
+   * Sources that were unavailable when this response was assembled
+   * (AD2-1045). Absent/empty = all sources healthy. When present, the
+   * numeric fields contain only data from the healthy sources — a partial
+   * outage must never read as real zeros.
+   */
+  failedSources?: AnalyticsSource[];
+  /**
+   * Structural availability of the impressions metric (AD2-1078) — distinct
+   * from `failedSources`, which is a transient per-fetch outage. False when
+   * the connected platform mix fundamentally does not expose impressions
+   * (e.g. Instagram Graph API v22+ dropped it): an honest "—" beats a fake
+   * 0, which reads as "zero people saw this". Absent/true = available.
+   */
+  impressionsAvailable?: boolean;
+  /**
+   * Structural availability of the reach metric (AD2-1078). False when the
+   * connected platform mix fundamentally never exposes reach (e.g. TikTok).
+   * Absent/true = available.
+   */
+  reachAvailable?: boolean;
 
   constructor(data: SchedulingAnalyticsKpiDTO) {
     this.impressions = data.impressions;
     this.reach = data.reach;
+    this.engagements = data.engagements;
+    this.views = data.views;
     this.engagementRate = data.engagementRate;
     this.followerGrowth = data.followerGrowth;
+    if (data.failedSources !== undefined) {
+      this.failedSources = data.failedSources;
+    }
+    if (data.impressionsAvailable !== undefined) {
+      this.impressionsAvailable = data.impressionsAvailable;
+    }
+    if (data.reachAvailable !== undefined) {
+      this.reachAvailable = data.reachAvailable;
+    }
   }
 }
 
@@ -131,7 +182,11 @@ export class SchedulingPostTimelineEntryDTO {
  * Returned by GET /social/analytics/content-decay.
  */
 export class SchedulingContentDecayDTO {
-  window: '1h' | '6h' | '24h' | '7d';
+  /**
+   * Zernio now returns aggregate bucket labels (e.g. "0-6h", "6-12h"), not
+   * the old fixed windows — widened accordingly (AD2-1061, 2026-07-03).
+   */
+  window: string;
   platform: string;
   /** Percentage of peak engagement remaining at this window */
   pct: number;

package/src/types/scheduling/I_SchedulingInbox.test.ts

@@ -0,0 +1,55 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { SchedulingInboxCommentDTO } from './I_SchedulingInbox';
+
+// AD2-1088 — engagement + ownership pass-through on inbox comments, verbatim
+// from Zernio GET /v1/inbox/comments/{postId} (OpenAPI v1.0.4:20799). Set
+// only when Zernio provides a value; never zero-backfilled.
+
+test('SchedulingInboxCommentDTO engagement/ownership fields are absent by default', () => {
+  const comment = new SchedulingInboxCommentDTO({
+    id: 'c1',
+    authorName: 'Jane',
+    text: 'hello',
+    createdAt: '2026-07-06T00:00:00.000Z',
+  });
+  assert.equal(comment.likeCount, undefined);
+  assert.equal(comment.replyCount, undefined);
+  assert.equal(comment.isOwner, undefined);
+  assert.equal(comment.parentId, undefined);
+});
+
+test('SchedulingInboxCommentDTO carries likeCount/replyCount/isOwner/parentId when provided', () => {
+  const comment = new SchedulingInboxCommentDTO({
+    id: 'c2',
+    authorName: 'Jane',
+    text: 'hello',
+    createdAt: '2026-07-06T00:00:00.000Z',
+    likeCount: 3,
+    replyCount: 1,
+    isOwner: true,
+    parentId: 'c1',
+  });
+  assert.equal(comment.likeCount, 3);
+  assert.equal(comment.replyCount, 1);
+  assert.equal(comment.isOwner, true);
+  assert.equal(comment.parentId, 'c1');
+});
+
+test('SchedulingInboxCommentDTO nests replies with the same optional fields', () => {
+  const reply = new SchedulingInboxCommentDTO({
+    id: 'c2',
+    authorName: 'Jane',
+    text: 'reply',
+    createdAt: '2026-07-06T00:00:00.000Z',
+    parentId: 'c1',
+  });
+  const comment = new SchedulingInboxCommentDTO({
+    id: 'c1',
+    authorName: 'Bob',
+    text: 'hello',
+    createdAt: '2026-07-06T00:00:00.000Z',
+    replies: [reply],
+  });
+  assert.equal(comment.replies?.[0].parentId, 'c1');
+});

package/src/types/scheduling/I_SchedulingInbox.ts

@@ -73,6 +73,14 @@ export class SchedulingInboxCommentDTO {
   authorAvatarUrl?: string;
   text: string;
   createdAt: string;
+  /** Likes on the comment, verbatim from Zernio (AD2-1088). Absent, never backfilled to 0. */
+  likeCount?: number;
+  /** Replies count on the comment, verbatim from Zernio (AD2-1088). */
+  replyCount?: number;
+  /** True when OUR connected account authored it — the answered state (AD2-1088). */
+  isOwner?: boolean;
+  /** Parent comment id on nested replies (AD2-1088). Absent on top-level comments. */
+  parentId?: string;
   replies?: SchedulingInboxCommentDTO[];
 
   constructor(data: SchedulingInboxCommentDTO) {
@@ -81,6 +89,10 @@ export class SchedulingInboxCommentDTO {
     this.authorAvatarUrl = data.authorAvatarUrl;
     this.text = data.text;
     this.createdAt = data.createdAt;
+    this.likeCount = data.likeCount;
+    this.replyCount = data.replyCount;
+    this.isOwner = data.isOwner;
+    this.parentId = data.parentId;
     this.replies = data.replies;
   }
 }

package/src/types/scheduling/I_SchedulingPost.test.ts

@@ -0,0 +1,92 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  SchedulingPostDTO,
+  SchedulingPostMediaItemDTO,
+  SchedulingPostTargetDTO,
+  SchedulingUpdatePostDTO,
+  SchedulingPlatformTargetDTO,
+  SchedulingMediaItemDTO,
+  SchedulingPostStatus,
+} from './I_SchedulingPost';
+
+// AD2-1083 / AD2-1026 / T022b — the compose edit-load fields the backend
+// already types locally (SchedulingPostWithMediaDTO) as a clean intersection
+// pending this lib bump. Pinning them here so ship-time is mechanical.
+
+function basePost(overrides?: Partial<SchedulingPostDTO>): SchedulingPostDTO {
+  return new SchedulingPostDTO({
+    id: 'post-1',
+    platforms: ['instagram'],
+    platformStatuses: { instagram: 'scheduled' },
+    status: SchedulingPostStatus.SCHEDULED,
+    createdAt: '2026-07-06T00:00:00.000Z',
+    updatedAt: '2026-07-06T00:00:00.000Z',
+    ...overrides,
+  });
+}
+
+test('SchedulingPostDTO edit-load fields are absent by default (backward compatible)', () => {
+  const post = basePost();
+  assert.equal(post.thumbnailUrl, undefined);
+  assert.equal(post.mediaUrl, undefined);
+  assert.equal(post.content, undefined);
+  assert.equal(post.mediaItems, undefined);
+  assert.equal(post.platformTargets, undefined);
+});
+
+test('SchedulingPostDTO carries the media-miniature + edit-load fields when provided', () => {
+  const mediaItem = new SchedulingPostMediaItemDTO({
+    type: 'gif',
+    url: 'https://cdn.example.com/a.gif',
+    title: 'a',
+  });
+  const target = new SchedulingPostTargetDTO({
+    platform: 'instagram',
+    accountId: 'acc-1',
+    platformSpecificData: { shareToFeed: true },
+  });
+  const post = basePost({
+    thumbnailUrl: 'https://cdn.example.com/thumb.jpg',
+    mediaUrl: 'https://cdn.example.com/media.jpg',
+    content: 'the complete caption',
+    mediaItems: [mediaItem],
+    platformTargets: [target],
+  });
+  assert.equal(post.thumbnailUrl, 'https://cdn.example.com/thumb.jpg');
+  assert.equal(post.mediaUrl, 'https://cdn.example.com/media.jpg');
+  assert.equal(post.content, 'the complete caption');
+  assert.deepEqual(post.mediaItems, [mediaItem]);
+  assert.deepEqual(post.platformTargets, [target]);
+});
+
+test('SchedulingPostMediaItemDTO allows gif/document (response-only, wider than the create-input type)', () => {
+  const gif = new SchedulingPostMediaItemDTO({ type: 'gif' });
+  const doc = new SchedulingPostMediaItemDTO({ type: 'document' });
+  assert.equal(gif.type, 'gif');
+  assert.equal(doc.type, 'document');
+});
+
+test('SchedulingPostTargetDTO requires only platform, everything else optional', () => {
+  const target = new SchedulingPostTargetDTO({ platform: 'tiktok' });
+  assert.equal(target.platform, 'tiktok');
+  assert.equal(target.accountId, undefined);
+  assert.equal(target.platformSpecificData, undefined);
+});
+
+test('SchedulingUpdatePostDTO gains platforms/mediaItems for the edit-patch flow (AD2-1026)', () => {
+  const patch = new SchedulingUpdatePostDTO({
+    content: 'edited caption',
+    platforms: [new SchedulingPlatformTargetDTO({ platform: 'instagram', accountId: 'acc-1' })],
+    mediaItems: [new SchedulingMediaItemDTO({ type: 'image', url: 'https://cdn.example.com/x.jpg' })],
+  });
+  assert.equal(patch.content, 'edited caption');
+  assert.equal(patch.platforms?.[0].platform, 'instagram');
+  assert.equal(patch.mediaItems?.[0].type, 'image');
+});
+
+test('SchedulingUpdatePostDTO platforms/mediaItems are absent by default (backward compatible)', () => {
+  const patch = new SchedulingUpdatePostDTO({ content: 'x' });
+  assert.equal(patch.platforms, undefined);
+  assert.equal(patch.mediaItems, undefined);
+});