@x12i/youtube-video-uploader-cli 1.2.0 → 1.4.0

package/src/index.d.ts

@@ -8,11 +8,29 @@ export interface VideoMetadata {
   tags: string[];
   categoryId?: string;
   privacyStatus?: 'private' | 'unlisted' | 'public';
+  defaultLanguage?: string;
+  defaultAudioLanguage?: string;
+  license?: string;
+  embeddable?: boolean;
+  publicStatsViewable?: boolean;
+  selfDeclaredMadeForKids?: boolean;
+  notifySubscribers?: boolean;
+  trackNumber?: number;
+  playlistPosition?: number;
   filePath: string;
 }
 
+export interface PlaylistConfig {
+  key?: string;
+  snippet?: Record<string, any>;
+  status?: Record<string, any>;
+  publishStatusAfterQc?: string;
+}
+
 export interface MetadataConfig {
   playlistId: string | null;
+  playlist?: PlaylistConfig | null;
+  templateVariables: Record<string, string | null>;
   privacyStatus: 'private' | 'unlisted' | 'public';
   categoryId: string;
   videos: VideoMetadata[];
@@ -22,6 +40,9 @@ export interface BatchUploadOptions {
   metadataFile?: string;
   force?: boolean;
   dryRun?: boolean;
+  limit?: number;
+  safeQuota?: boolean;
+  maxQuota?: number;
   tokenFile?: string;
   clientSecretsFile?: string;
   clientId?: string;
@@ -34,19 +55,26 @@ export interface BatchUploadResult {
   total: number;
   uploaded: Array<{ filename: string; videoId: string; url: string; addedToPlaylist: boolean }>;
   skipped: Array<{ filename: string; videoId?: string; reason: string }>;
+  deferred: Array<{ filename: string; reason: string }>;
   failed: Array<{ filename: string; error: Error }>;
   estimatedQuota: number;
+  playlistId?: string | null;
 }
 
 export declare class UploadState {
   constructor(targetFolder?: string, stateFilename?: string);
+  listUploads(): Array<{ filename: string; videoId: string; uploadedAt: string; playlistId?: string }>;
   getUpload(filename: string): { videoId: string; uploadedAt: string; playlistId?: string } | null;
   recordUpload(filename: string, videoId: string, playlistId?: string | null): void;
   recordPlaylist(filename: string, playlistId: string): void;
+  getPlaylist(key?: string): { playlistId: string; url: string; createdAt: string | null } | null;
+  recordPlaylistInfo(key: string, playlistId: string, url?: string): void;
   save(): void;
 }
 
 export function loadMetadata(targetFolder?: string, customMetadataPath?: string): MetadataConfig;
+export function interpolateTemplates(text: string, variables?: Record<string, string | null | undefined>): string;
+
 export function authenticate(options?: {
   clientId?: string;
   clientSecret?: string;
@@ -67,9 +95,16 @@ export function uploadVideo(
 export function addToPlaylist(
   youtube: youtube_v3.Youtube,
   playlistId: string,
-  videoId: string
+  videoId: string,
+  position?: number
 ): Promise<any>;
 
+export function createPlaylist(
+  youtube: youtube_v3.Youtube,
+  snippet: Record<string, any>,
+  status?: Record<string, any>
+): Promise<{ playlistId: string; url: string; data: any }>;
+
 export function batchUpload(
   targetFolder?: string,
   options?: BatchUploadOptions
@@ -77,10 +112,13 @@ export function batchUpload(
 
 export const QUOTA_PER_VIDEO_UPLOAD: number;
 export const QUOTA_PER_PLAYLIST_ITEM: number;
+export const QUOTA_PER_PLAYLIST_CREATE: number;
 export const DAILY_DEFAULT_QUOTA: number;
 export const DEFAULT_CATEGORY_ID: string;
 export const DEFAULT_PRIVACY_STATUS: string;
 export const VALID_PRIVACY_STATUSES: Set<string>;
+export const DEFAULT_STATE_FILENAME: string;
+export const YOUTUBE_SCOPES: string[];
 
 // ─── Playlist video swap ───────────────────────────────────────────────────
 
@@ -118,7 +156,7 @@ export class SwapStore {
 export function uploadNewVideo(
   youtube: youtube_v3.Youtube,
   newVideoPath: string,
-  opts?: { oldVideoId?: string; meta?: VideoMetadata; retries?: number }
+  opts?: { oldVideoId?: string; meta?: Partial<VideoMetadata>; retries?: number }
 ): Promise<{ videoId: string; url: string }>;
 
 export function findPlaylistItem(
@@ -144,7 +182,7 @@ export function swapSong(params: {
   newVideoPath: string;
   playlistId: string;
   oldVideoId: string;
-  meta?: VideoMetadata;
+  meta?: Partial<VideoMetadata>;
   stateDir?: string;
   stateFile?: string;
   fresh?: boolean;
@@ -154,3 +192,494 @@ export function swapSong(params: {
 export const QUOTA_PER_SWAP: number;
 export const DEFAULT_SWAP_STATE_FILENAME: string;
 export const SWAP_STATUSES: string[];
+
+// ─── Metadata & Title Updates ──────────────────────────────────────────────
+
+export interface BatchUpdateMetadataOptions {
+  titlePostfix?: string;
+  titlePrefix?: string;
+  playlistPostfix?: string;
+  playlistTitle?: string;
+  metadataFile?: string;
+  updateLocalMetadata?: boolean;
+  syncMetadata?: boolean;
+  singleVideoId?: string;
+  singleVideoTitle?: string;
+  singlePlaylistId?: string;
+  dryRun?: boolean;
+  tokenFile?: string;
+  clientSecretsFile?: string;
+  clientId?: string;
+  clientSecret?: string;
+  onEvent?: (event: { type: string; [key: string]: any }) => void;
+}
+
+export interface VideoPlanItem {
+  filename: string;
+  videoId: string;
+  oldTitle: string;
+  newTitle: string;
+  changed: boolean;
+}
+
+export interface PlaylistPlanItem {
+  playlistId: string;
+  oldTitle: string;
+  newTitle: string;
+  changed: boolean;
+}
+
+export interface BatchUpdateMetadataResult {
+  playlist?: PlaylistPlanItem | null;
+  videos: VideoPlanItem[];
+  estimatedQuota: number;
+  dryRun: boolean;
+}
+
+export function updateVideoSnippet(
+  youtube: youtube_v3.Youtube,
+  videoId: string,
+  snippetUpdates: Record<string, any>
+): Promise<{ videoId: string; title: string; data: any }>;
+
+export function updateVideoTitle(
+  youtube: youtube_v3.Youtube,
+  videoId: string,
+  newTitle: string
+): Promise<{ videoId: string; title: string; data: any }>;
+
+export function updatePlaylistSnippet(
+  youtube: youtube_v3.Youtube,
+  playlistId: string,
+  snippetUpdates: Record<string, any>
+): Promise<{ playlistId: string; title: string; data: any }>;
+
+export function updatePlaylistTitle(
+  youtube: youtube_v3.Youtube,
+  playlistId: string,
+  newTitle: string
+): Promise<{ playlistId: string; title: string; data: any }>;
+
+export function batchUpdateMetadata(
+  targetFolder?: string,
+  options?: BatchUpdateMetadataOptions
+): Promise<BatchUpdateMetadataResult>;
+
+export const QUOTA_PER_VIDEO_UPDATE: number;
+export const QUOTA_PER_PLAYLIST_UPDATE: number;
+export const QUOTA_PER_LIST: number;
+
+// ─── Automated Stock Media Sourcing (Pexels + Pixabay) ──────────────────────
+
+export interface UnifiedResult {
+  provider: 'pexels' | 'pixabay';
+  id: string;
+  type: 'video' | 'photo';
+  rank: number;
+  pageUrl: string;
+  previewUrl: string;
+  downloadUrl: string;
+  width: number;
+  height: number;
+  duration?: number;
+  orientation: 'landscape' | 'portrait' | 'square';
+  tags: string[];
+  creator: { name: string; profileUrl?: string };
+  license: 'Pexels License' | 'Pixabay Content License';
+  raw: unknown;
+}
+
+export interface MediaSearchOptions {
+  query: string;
+  type?: 'video' | 'photo';
+  provider?: 'auto' | 'pexels' | 'pixabay';
+  mergeStrategy?: 'fallback' | 'merge';
+  providerOrder?: Array<'pexels' | 'pixabay'>;
+  orientation?: 'landscape' | 'portrait' | 'square';
+  page?: number;
+  perPage?: number;
+  safeSearch?: boolean;
+  pexelsKey?: string;
+  pixabayKey?: string;
+  useCache?: boolean;
+  cacheDir?: string;
+  fetchFn?: typeof fetch;
+}
+
+export interface CandidateCriteria {
+  preferredWidth?: number;
+  preferredHeight?: number;
+  minWidth?: number;
+  minHeight?: number;
+  orientation?: 'landscape' | 'portrait' | 'square';
+  targetDuration?: number;
+  minDuration?: number;
+  maxDuration?: number;
+  avoidReuse?: boolean;
+  cacheDir?: string;
+  usedAssetSet?: Set<string>;
+  providerOrder?: Array<'pexels' | 'pixabay'>;
+}
+
+export interface CandidateScore {
+  score: number;
+  breakdown: {
+    rank: number;
+    resolution: number;
+    orientation: number;
+    duration: number;
+    novelty: number;
+  };
+}
+
+export interface RankedCandidate {
+  candidate: UnifiedResult;
+  score: number;
+  breakdown: CandidateScore['breakdown'];
+}
+
+export interface ComposeVideoOptions {
+  backgroundPath: string;
+  audioPath: string;
+  outputPath: string;
+  mode?: 'video-loop' | 'video-trim' | 'ken-burns';
+  targetWidth?: number;
+  targetHeight?: number;
+  fps?: number;
+  dryRun?: boolean;
+  onProgress?: (progress: { percent?: number; timemark?: string }) => void;
+}
+
+export interface ResolveMediaOptions {
+  compose?: boolean;
+  force?: boolean;
+  dryRun?: boolean;
+  allowRepeatMedia?: boolean;
+  provider?: 'auto' | 'pexels' | 'pixabay';
+  type?: 'video' | 'photo';
+  orientation?: 'landscape' | 'portrait' | 'square';
+  cacheDir?: string;
+  pexelsKey?: string;
+  pixabayKey?: string;
+  autoMedia?: boolean;
+  onEvent?: (event: { type: string; [key: string]: any }) => void;
+}
+
+export interface ResolvedMediaItem {
+  songKey: string;
+  resolvedMedia: {
+    provider: 'pexels' | 'pixabay';
+    assetId: string;
+    type: 'video' | 'photo';
+    pageUrl: string;
+    localPath: string;
+    width: number;
+    height: number;
+    duration?: number;
+    license: string;
+    credit: string;
+    resolvedAt: string;
+  };
+  generatedVideoPath?: string;
+}
+
+export interface ResolveMediaResult {
+  resolved: ResolvedMediaItem[];
+  skipped: Array<{ songKey: string; reason: string }>;
+  errors: Array<{ songKey: string; error: string }>;
+}
+
+export function searchPexels(options: {
+  query: string;
+  type?: 'video' | 'photo';
+  orientation?: 'landscape' | 'portrait' | 'square';
+  page?: number;
+  perPage?: number;
+  apiKey: string;
+  fetchFn?: typeof fetch;
+}): Promise<UnifiedResult[]>;
+
+export function searchPixabay(options: {
+  query: string;
+  type?: 'video' | 'photo';
+  orientation?: 'landscape' | 'portrait' | 'square';
+  page?: number;
+  perPage?: number;
+  safeSearch?: boolean;
+  apiKey: string;
+  fetchFn?: typeof fetch;
+}): Promise<UnifiedResult[]>;
+
+export function searchMedia(options: MediaSearchOptions): Promise<UnifiedResult[]>;
+
+export function resolveProviderCredentials(options?: {
+  pexelsKey?: string;
+  pixabayKey?: string;
+  providerOrder?: Array<'pexels' | 'pixabay'>;
+}): {
+  pexelsKey?: string;
+  pixabayKey?: string;
+  providerOrder: Array<'pexels' | 'pixabay'>;
+};
+
+export const DEFAULT_MEDIA_CACHE_DIR: string;
+export const CACHE_TTL_MS: number;
+
+export function createSearchCacheKey(params: {
+  provider: string;
+  type: string;
+  query: string;
+  orientation?: string;
+}): string;
+
+export function getCachedSearch(cacheDir: string, cacheKey: string, ttlMs?: number): any[] | null;
+export function setCachedSearch(cacheDir: string, cacheKey: string, results: any[]): void;
+export function readUsedAssetsLedger(cacheDir?: string): Record<string, { provider: string; assetId: string; usedAt: string; songKey?: string }>;
+export function isAssetUsed(cacheDir: string, provider: string, assetId: string): boolean;
+export function recordUsedAsset(cacheDir: string, assetInfo: { provider: string; assetId: string; songKey?: string }): void;
+
+export function scoreCandidate(candidate: UnifiedResult, criteria?: CandidateCriteria): CandidateScore;
+export function rankCandidates(results?: UnifiedResult[], criteria?: CandidateCriteria): RankedCandidate[];
+export function selectBest(results?: UnifiedResult[], criteria?: CandidateCriteria): UnifiedResult | null;
+
+export function inferExtension(contentType?: string, url?: string, type?: 'video' | 'photo'): string;
+export function downloadAsset(
+  asset: UnifiedResult,
+  options?: {
+    cacheDir?: string;
+    targetPath?: string;
+    force?: boolean;
+    maxRetries?: number;
+    fetchFn?: typeof fetch;
+  }
+): Promise<{ localPath: string; size: number; ext: string; fromCache: boolean }>;
+
+export function getMediaDuration(filePath: string): Promise<number>;
+export function composeVideo(options: ComposeVideoOptions): Promise<{ outputPath: string; duration: number; dryRun?: boolean; command?: string }>;
+
+export function deriveSearchQuery(item?: {
+  title?: string;
+  tags?: string[];
+  artist?: string;
+  album?: { title?: string };
+  filename?: string;
+}): string;
+
+export function formatMediaCredit(asset: UnifiedResult): string;
+export function writeAttributionsFile(targetDir: string, resolvedItems: Array<{ songKey: string; resolvedMedia: object }>): void;
+export function resolveMediaForMetadata(metadataFilePathOrDir: string, options?: ResolveMediaOptions): Promise<ResolveMediaResult>;
+
+// ─── Batch Video Actions Pipeline ──────────────────────────────────────────
+
+export interface ShortenAction {
+  type: 'shorten';
+  cutPoint: string | number;
+  fadeDuration?: number;
+  paddingDuration?: number;
+  paddingFill?: 'black' | 'freeze-frame';
+  fadeTargets?: Array<'audio' | 'video'>;
+}
+
+export interface ReplaceBackgroundAction {
+  type: 'replace-background';
+  query?: string;
+  provider?: 'pexels' | 'pixabay' | 'auto';
+  orientation?: 'landscape' | 'portrait' | 'square';
+  mode?: 'video-loop' | 'video-trim' | 'ken-burns';
+  mediaType?: 'video' | 'photo';
+  avoidReuse?: boolean;
+}
+
+export interface JourneyOverlayAction {
+  type: 'journey-overlay';
+  centerText?: string;
+  centerConcepts?: string[];
+  conceptsDisplayMode?: 'intro' | 'full';
+  conceptDisplaySeconds?: number;
+  conceptFadeSeconds?: number;
+  showSidebar?: boolean;
+}
+
+export type VideoAction = ShortenAction | ReplaceBackgroundAction | JourneyOverlayAction | { type: string; [key: string]: any };
+
+export interface JourneyConfig {
+  enabled?: boolean;
+  mode?: 'before-current' | 'all';
+  position?: 'left' | 'right';
+  style?: 'badge' | 'panel';
+  badgeText?: string;
+  displayDuration?: number | 'full';
+  sidebarDisplayDuration?: number | 'full';
+  sidebarLabel?: 'title' | 'stage' | 'both';
+  theme?: 'dark' | 'light';
+  maxCenterChars?: number;
+  maxVisibleRows?: number;
+}
+
+export interface PlannedEntry {
+  index: number;
+  songKey: string;
+  filename: string;
+  title: string;
+  sourcePath: string;
+  targetPath: string;
+  actions: VideoAction[];
+  rawEntry?: any;
+}
+
+export interface BatchActionsPlan {
+  sourceDir: string;
+  outputDir: string;
+  hasShorten: boolean;
+  rawMetadata: any;
+  journeyConfig: JourneyConfig;
+  entries: PlannedEntry[];
+  dryRun: boolean;
+  force: boolean;
+}
+
+export interface BatchApplyActionsOptions {
+  metadataFile?: string;
+  actionsFile?: string;
+  outputDir?: string;
+  outputSuffix?: string;
+  only?: string;
+  force?: boolean;
+  dryRun?: boolean;
+  pexelsKey?: string;
+  pixabayKey?: string;
+  cacheDir?: string;
+  fetchFn?: typeof fetch;
+  onEvent?: (event: { type: string; [key: string]: any }) => void;
+}
+
+export interface BatchApplyActionsResult {
+  sourceDir: string;
+  outputDir: string;
+  total: number;
+  processed: Array<{
+    songKey: string;
+    filename: string;
+    outputPath: string;
+    actionsApplied: string[];
+    steps?: string[];
+  }>;
+  skipped: Array<{
+    songKey: string;
+    filename: string;
+    reason?: string;
+  }>;
+  failed: Array<{
+    songKey: string;
+    filename: string;
+    error: Error;
+  }>;
+  dryRun: boolean;
+}
+
+export function parseTimeSeconds(time: string | number): number;
+export function getVideoMetadata(filePath: string): Promise<{ duration: number; width: number; height: number; fps: number; sampleRate: number }>;
+export function shortenVideo(params: {
+  inputPath: string;
+  outputPath: string;
+  cutPoint: string | number;
+  fadeDuration?: number;
+  paddingDuration?: number;
+  paddingFill?: 'black' | 'freeze-frame';
+  fadeTargets?: Array<'audio' | 'video'>;
+  dryRun?: boolean;
+  onWarn?: (msg: string) => void;
+}): Promise<{ outputPath: string; duration: number; dryRun?: boolean; command?: string }>;
+
+export function extractAudio(inputVideoPath: string, outputAudioPath: string): Promise<string>;
+export function replaceBackground(params: {
+  inputPath: string;
+  outputPath: string;
+  action?: Partial<ReplaceBackgroundAction>;
+  entry?: any;
+  context?: any;
+  dryRun?: boolean;
+}): Promise<{ outputPath: string; duration?: number; dryRun?: boolean; command?: string; asset?: any }>;
+
+export function resolveJourneyTracks(params: {
+  currentSongKey: string;
+  rawMetadata?: any;
+  mode?: 'before-current' | 'all';
+  maxVisibleRows?: number;
+  sidebarLabel?: 'title' | 'stage' | 'both';
+}): Array<{ index: number; title: string; isCurrent: boolean; isUpcoming: boolean; isOverflow?: boolean }>;
+
+export function generateJourneySvg(params: {
+  width?: number;
+  height?: number;
+  tracks?: Array<{ index: number; title: string; isCurrent: boolean; isUpcoming: boolean; isOverflow?: boolean }>;
+  centerText?: string;
+  showSidebar?: boolean;
+  theme?: 'dark' | 'light';
+  position?: 'left' | 'right';
+  style?: 'badge' | 'panel';
+  stage?: string;
+  step?: number;
+  totalSteps?: number;
+  badgeText?: string;
+}): string;
+
+export function renderSvgToPng(svgContent: string, width?: number, height?: number): Buffer;
+
+export function applyJourneyOverlay(params: {
+  inputPath: string;
+  outputPath: string;
+  action?: Partial<JourneyOverlayAction>;
+  entry?: any;
+  rawMetadata?: any;
+  journeyConfig?: JourneyConfig;
+  dryRun?: boolean;
+  onWarn?: (msg: string) => void;
+}): Promise<{ outputPath: string; duration?: number; dryRun?: boolean; command?: string }>;
+
+export function runActionsPipeline(
+  entry: PlannedEntry | { songKey?: string; filename: string; sourcePath: string; targetPath?: string },
+  actions?: VideoAction[],
+  context?: {
+    outputDir?: string;
+    rawMetadata?: any;
+    journeyConfig?: JourneyConfig;
+    dryRun?: boolean;
+    force?: boolean;
+    pexelsKey?: string;
+    pixabayKey?: string;
+    cacheDir?: string;
+    fetchFn?: typeof fetch;
+    onEvent?: (event: any) => void;
+    onWarn?: (msg: string) => void;
+  }
+): Promise<{
+  songKey: string;
+  filename: string;
+  outputPath: string;
+  actionsApplied: string[];
+  skipped?: boolean;
+  reason?: string;
+  dryRun?: boolean;
+  steps?: string[];
+}>;
+
+export function resolveOutputDirectory(sourceDir: string, options?: { outputDir?: string; outputSuffix?: string; hasShorten?: boolean }): string;
+export function resolveEntryActions(params: { songKey: string; filename: string; rawEntry?: any; rawMetadata?: any; actionsFileConfig?: any }): VideoAction[];
+export function planBatchActions(sourceDir: string, options?: BatchApplyActionsOptions): BatchActionsPlan;
+export function cloneMetadataForOutput(rawMetadata: any, outputDir: string, results?: Array<any>): any;
+export function batchApplyActions(targetDir?: string, options?: BatchApplyActionsOptions): Promise<BatchApplyActionsResult>;
+
+export function previewJourney(
+  songKey: string,
+  options?: {
+    dir?: string;
+    metadata?: string;
+    centerText?: string;
+    output?: string;
+    width?: number;
+    height?: number;
+  }
+): Promise<{ outputPath: string; width: number; height: number; tracksCount: number }>;
+
+

package/src/index.js

@@ -1,12 +1,20 @@
 export { authenticate, resolveOAuthCredentials, YOUTUBE_SCOPES } from './auth.js';
-export { loadMetadata, DEFAULT_CATEGORY_ID, DEFAULT_PRIVACY_STATUS, VALID_PRIVACY_STATUSES } from './metadata.js';
+export {
+  loadMetadata,
+  interpolateTemplates,
+  DEFAULT_CATEGORY_ID,
+  DEFAULT_PRIVACY_STATUS,
+  VALID_PRIVACY_STATUSES,
+} from './metadata.js';
 export { UploadState, DEFAULT_STATE_FILENAME } from './state.js';
 export {
   uploadVideo,
   addToPlaylist,
+  createPlaylist,
   batchUpload,
   QUOTA_PER_VIDEO_UPLOAD,
   QUOTA_PER_PLAYLIST_ITEM,
+  QUOTA_PER_PLAYLIST_CREATE,
   DAILY_DEFAULT_QUOTA,
 } from './uploader.js';
 export { SwapStore, DEFAULT_SWAP_STATE_FILENAME, SWAP_STATUSES } from './swap/store.js';
@@ -18,3 +26,76 @@ export {
   finalizeSwap,
 } from './swap/steps.js';
 export { swapSong, QUOTA_PER_SWAP } from './swap/swapSong.js';
+export {
+  updateVideoSnippet,
+  updateVideoTitle,
+  updatePlaylistSnippet,
+  updatePlaylistTitle,
+  batchUpdateMetadata,
+  QUOTA_PER_VIDEO_UPDATE,
+  QUOTA_PER_PLAYLIST_UPDATE,
+  QUOTA_PER_LIST,
+} from './update.js';
+export {
+  searchPexels,
+  searchPixabay,
+  searchMedia,
+  resolveProviderCredentials,
+} from './providers/index.js';
+export {
+  DEFAULT_MEDIA_CACHE_DIR,
+  CACHE_TTL_MS,
+  createSearchCacheKey,
+  getCachedSearch,
+  setCachedSearch,
+  readUsedAssetsLedger,
+  isAssetUsed,
+  recordUsedAsset,
+} from './media/cache.js';
+export {
+  scoreCandidate,
+  rankCandidates,
+  selectBest,
+} from './media/select.js';
+export {
+  downloadAsset,
+  inferExtension,
+} from './media/download.js';
+export {
+  composeVideo,
+  getMediaDuration,
+} from './media/compose.js';
+export {
+  deriveSearchQuery,
+  formatMediaCredit,
+  writeAttributionsFile,
+  resolveMediaForMetadata,
+} from './media/resolve.js';
+export {
+  shortenVideo,
+  parseTimeSeconds,
+  getVideoMetadata,
+  replaceBackground,
+  extractAudio,
+  applyJourneyOverlay,
+  generateJourneySvg,
+  renderSvgToPng,
+  resolveJourneyTracks,
+  runActionsPipeline,
+} from './actions/index.js';
+export {
+  resolveOutputDirectory,
+  resolveEntryActions,
+  planBatchActions,
+} from './batch/plan.js';
+export {
+  cloneMetadataForOutput,
+} from './batch/clone-metadata.js';
+export {
+  batchApplyActions,
+} from './cli/apply-actions.js';
+export {
+  previewJourney,
+} from './cli/preview-journey.js';
+
+