larkup 0.4.12 → 0.4.14

package/.next/standalone/apps/web/lib/media/video-intelligence-capacity.test.ts

@@ -0,0 +1,104 @@
+import { describe, expect, it, vi } from 'vitest';
+import {
+  isLocallyActiveVideoJob,
+  reconcileVideoIntelligenceCapacity,
+  type VideoIntelligenceUsageSnapshot,
+} from './video-intelligence-capacity';
+
+const fullUsage = (activeJobIds?: string[]): VideoIntelligenceUsageSnapshot => ({
+  sourceMinutesLimit: 600,
+  sourceMinutesUsed: 10,
+  activeJobs: 1,
+  concurrentJobsLimit: 1,
+  activeJobIds,
+});
+
+const freeUsage = (): VideoIntelligenceUsageSnapshot => ({
+  ...fullUsage([]),
+  activeJobs: 0,
+});
+
+describe('video intelligence capacity reconciliation', () => {
+  it('does not treat an unclaimed pending URL import as an active job', () => {
+    expect(
+      isLocallyActiveVideoJob({
+        type: 'video',
+        processingStatus: 'pending',
+        processingMessage: undefined,
+        activeVideoIntelligenceJobId: undefined,
+      }),
+    ).toBe(false);
+  });
+
+  it('releases the exact remote job for a terminal local asset', async () => {
+    const getUsage = vi
+      .fn()
+      .mockResolvedValueOnce(fullUsage(['job-orphan']))
+      .mockResolvedValueOnce(freeUsage());
+    const getJob = vi.fn().mockResolvedValue({ status: 'running' });
+    const cancelJob = vi.fn().mockResolvedValue({ status: 'cancelled' });
+
+    const usage = await reconcileVideoIntelligenceCapacity({
+      assets: [
+        {
+          type: 'video',
+          processingStatus: 'failed',
+          processingMessage: undefined,
+          activeVideoIntelligenceJobId: 'job-orphan',
+        },
+      ],
+      getUsage,
+      getJob,
+      cancelJob,
+      retryDelaysMs: [],
+    });
+
+    expect(usage.activeJobs).toBe(0);
+    expect(getJob).toHaveBeenCalledWith('job-orphan');
+    expect(cancelJob).toHaveBeenCalledWith('job-orphan');
+  });
+
+  it('never cancels a remote job that is still active locally', async () => {
+    const getUsage = vi.fn().mockResolvedValue(fullUsage(['job-live']));
+    const getJob = vi.fn();
+    const cancelJob = vi.fn();
+
+    const usage = await reconcileVideoIntelligenceCapacity({
+      assets: [
+        {
+          type: 'video',
+          processingStatus: 'processing',
+          processingMessage: 'Indexing…',
+          activeVideoIntelligenceJobId: 'job-live',
+        },
+      ],
+      getUsage,
+      getJob,
+      cancelJob,
+      retryDelaysMs: [0],
+    });
+
+    expect(usage.activeJobs).toBe(1);
+    expect(getJob).not.toHaveBeenCalled();
+    expect(cancelJob).not.toHaveBeenCalled();
+  });
+
+  it('retries reconciliation without cancelling an unknown project job', async () => {
+    const getUsage = vi
+      .fn()
+      .mockResolvedValueOnce(fullUsage(['job-other']))
+      .mockResolvedValueOnce(freeUsage());
+    const cancelJob = vi.fn();
+
+    const usage = await reconcileVideoIntelligenceCapacity({
+      assets: [],
+      getUsage,
+      getJob: vi.fn(),
+      cancelJob,
+      retryDelaysMs: [0],
+    });
+
+    expect(usage.activeJobs).toBe(0);
+    expect(cancelJob).not.toHaveBeenCalled();
+  });
+});

package/.next/standalone/apps/web/lib/media/video-runtime-scope.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, it } from 'vitest';
+import {
+  isDocumentAvailableInVideoRuntime,
+  videoRuntimeScopeFromConfig,
+} from './video-runtime-scope';
+
+describe('video runtime visibility', () => {
+  it('normalizes merged local runtime values into the local evidence scope', () => {
+    expect(
+      videoRuntimeScopeFromConfig({
+        toolConfigs: { 'video-intelligence': { runtimeMode: 'local-docker' } },
+      }),
+    ).toBe('local');
+    expect(
+      videoRuntimeScopeFromConfig({
+        toolConfigs: { 'video-intelligence': { runtimeMode: 'local-process' } },
+      }),
+    ).toBe('local');
+    expect(
+      videoRuntimeScopeFromConfig({
+        toolConfigs: { 'video-intelligence': { runtimeMode: 'managed-cloud' } },
+      }),
+    ).toBe('cloud');
+  });
+
+  it('keeps scoped video evidence out of the opposite runtime', () => {
+    const localVideo = { source: 'media' as const, metadata: { videoRuntimeScope: 'local' } };
+    expect(isDocumentAvailableInVideoRuntime(localVideo, 'local')).toBe(true);
+    expect(isDocumentAvailableInVideoRuntime(localVideo, 'cloud')).toBe(false);
+  });
+
+  it('keeps legacy media visible until it can be safely re-indexed', () => {
+    const legacyVideo = { source: 'media' as const, metadata: { mediaAssetId: 'legacy-video' } };
+    expect(isDocumentAvailableInVideoRuntime(legacyVideo, 'local')).toBe(true);
+    expect(isDocumentAvailableInVideoRuntime(legacyVideo, 'cloud')).toBe(true);
+  });
+
+  it('never hides ordinary corpus documents when video runtime changes', () => {
+    const document = { source: 'files' as const, metadata: {} };
+    expect(isDocumentAvailableInVideoRuntime(document, 'local')).toBe(true);
+    expect(isDocumentAvailableInVideoRuntime(document, 'cloud')).toBe(true);
+  });
+});

package/.next/standalone/apps/web/lib/release-metadata.test.ts

@@ -0,0 +1,118 @@
+import { execFileSync } from 'node:child_process';
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { describe, expect, it } from 'vitest';
+
+const repoRoot = path.resolve(process.cwd(), '../..');
+
+function readJson(relativePath: string) {
+  return JSON.parse(readFileSync(path.join(repoRoot, relativePath), 'utf8'));
+}
+
+describe('published npm metadata', () => {
+  it('keeps global installer dependencies compatible and current', () => {
+    const webPackage = readJson('apps/web/package.json');
+    const rootPackage = readJson('package.json');
+    const cliPackage = readJson('apps/cli/package.json');
+    const corePackage = readJson('packages/core/package.json');
+    const marketplacePackage = readJson('packages/marketplace/package.json');
+    const vectorStoresPackage = readJson('packages/vector-stores/package.json');
+    const sandboxPackage = readJson('packages/sandbox/package.json');
+    const launcher = readFileSync(path.join(repoRoot, 'apps/web/bin/larkup.js'), 'utf8');
+    const dockerfile = readFileSync(path.join(repoRoot, 'docker/Dockerfile'), 'utf8');
+    const dockerWorkflow = readFileSync(
+      path.join(repoRoot, '.github/workflows/docker-build.yml'),
+      'utf8',
+    );
+
+    expect(webPackage.dependencies['apache-arrow']).toBe('18.1.0');
+    // The standalone output and its Next runtime must be the same patch
+    // release. A range can install a newer runtime that expects build files
+    // which the packaged output does not contain.
+    expect(webPackage.dependencies.next).toMatch(/^\d+\.\d+\.\d+$/);
+    expect(rootPackage.pnpm.overrides.next).toBe(webPackage.dependencies.next);
+    expect(dockerfile).toContain(
+      `@lancedb/lancedb@${webPackage.dependencies['@lancedb/lancedb'].replace(/^\D+/, '')}`,
+    );
+    expect(dockerfile).toContain(`@napi-rs/canvas@${webPackage.dependencies['@napi-rs/canvas']}`);
+    expect(dockerfile).toContain('ARG LARKUP_VERSION');
+    expect(dockerfile).toContain('next !== app.dependencies.next');
+    expect(dockerWorkflow).toContain('LARKUP_VERSION=${{ steps.version.outputs.version }}');
+    expect(dockerfile).not.toContain('fluent-ffmpeg');
+    expect(cliPackage.dependencies['apache-arrow']).toBe('18.1.0');
+    expect(vectorStoresPackage.dependencies['apache-arrow']).toBe('18.1.0');
+    expect(webPackage.dependencies.tsx).toBeDefined();
+    expect(webPackage.devDependencies.tsx).toBeUndefined();
+    expect(marketplacePackage.dependencies.tsx).toBeDefined();
+    expect(marketplacePackage.devDependencies.tsx).toBeUndefined();
+    expect(sandboxPackage.optionalDependencies['@daytona/sdk']).toBeDefined();
+    expect(sandboxPackage.optionalDependencies['@daytonaio/sdk']).toBeUndefined();
+    expect(launcher).toContain("'--legacy-peer-deps'");
+    expect(launcher).toContain("'--loglevel=error'");
+    expect(launcher).toContain('https://registry.npmjs.org/larkup/latest');
+    expect(launcher).toContain('`larkup@${latestVersion}`');
+    expect(launcher).not.toContain("'@larkup/cli@latest'");
+    expect(launcher).toContain('You already have the latest version.');
+    expect(launcher).toContain("process.env.LARKUP_NO_OPEN !== '1'");
+    for (const dependency of [
+      '@larkup/connections',
+      '@larkup/core',
+      '@larkup/integrations',
+      '@larkup/marketplace',
+      '@larkup/sandbox',
+      '@larkup/scraper',
+      '@larkup/tool-doc-editor',
+      '@larkup/vector-stores',
+    ]) {
+      expect(webPackage.dependencies[dependency]).not.toContain('workspace:');
+    }
+    expect(webPackage.files).toEqual(['bin', '.next/standalone/apps/web']);
+    expect(corePackage.files).toEqual(['src', '!src/**/*.test.ts', 'CHANGELOG.md']);
+  });
+
+  it('scrubs local project state from every traced workspace before packing', () => {
+    const testRoot = mkdtempSync(path.join(os.tmpdir(), 'larkup-standalone-'));
+    const tracedPackage = path.join(testRoot, '.next/standalone/packages/example');
+    const envFile = path.join(tracedPackage, '.env.local');
+    const envExample = path.join(tracedPackage, '.env.example');
+    const cacheFile = path.join(tracedPackage, '.next/cache/webpack/cache.pack');
+    const devFile = path.join(tracedPackage, '.next/dev/cache/cache.sst');
+    const virtualEnvironmentFile = path.join(
+      tracedPackage,
+      'runtime/.venv/site-packages/native.bin',
+    );
+
+    try {
+      mkdirSync(path.join(tracedPackage, '.larkup/projects/local'), { recursive: true });
+      mkdirSync(path.join(tracedPackage, '.larkupdb'), { recursive: true });
+      writeFileSync(path.join(tracedPackage, '.larkup/projects/local/config.json'), '{}');
+      writeFileSync(envFile, 'PRIVATE=value');
+      writeFileSync(envExample, 'SAFE=example');
+      mkdirSync(path.dirname(cacheFile), { recursive: true });
+      mkdirSync(path.dirname(devFile), { recursive: true });
+      mkdirSync(path.dirname(virtualEnvironmentFile), { recursive: true });
+      writeFileSync(cacheFile, 'cache');
+      writeFileSync(devFile, 'dev cache');
+      writeFileSync(virtualEnvironmentFile, 'environment');
+
+      execFileSync(
+        process.execPath,
+        [path.join(repoRoot, 'apps/web/scripts/prepare-standalone.mjs')],
+        {
+          cwd: testRoot,
+        },
+      );
+
+      expect(existsSync(path.join(tracedPackage, '.larkup'))).toBe(false);
+      expect(existsSync(path.join(tracedPackage, '.larkupdb'))).toBe(false);
+      expect(existsSync(envFile)).toBe(false);
+      expect(existsSync(envExample)).toBe(true);
+      expect(existsSync(cacheFile)).toBe(false);
+      expect(existsSync(devFile)).toBe(false);
+      expect(existsSync(virtualEnvironmentFile)).toBe(false);
+    } finally {
+      rmSync(testRoot, { force: true, recursive: true });
+    }
+  });
+});

package/.next/standalone/apps/web/lib/remote-files.test.ts

@@ -0,0 +1,53 @@
+import { describe, expect, it } from 'vitest';
+import { getRemoteFileName, isPrivateAddress, normalizeRemoteFileUrl } from './remote-files';
+
+describe('remote file URL handling', () => {
+  it('turns GitHub and Hugging Face share links into downloadable file URLs', () => {
+    expect(
+      normalizeRemoteFileUrl('https://github.com/larkup-ai/larkup/blob/main/README.md').toString(),
+    ).toBe('https://raw.githubusercontent.com/larkup-ai/larkup/main/README.md');
+    expect(
+      normalizeRemoteFileUrl('https://huggingface.co/org/data/blob/main/records.json').toString(),
+    ).toBe('https://huggingface.co/org/data/resolve/main/records.json');
+  });
+
+  it('recognizes private network addresses before a server fetch', () => {
+    for (const address of [
+      '127.0.0.1',
+      '10.1.1.1',
+      '172.16.0.1',
+      '192.168.1.1',
+      '::1',
+      'fc00::1',
+    ]) {
+      expect(isPrivateAddress(address)).toBe(true);
+    }
+    expect(isPrivateAddress('8.8.8.8')).toBe(false);
+  });
+
+  it('keeps source-code extensions when a host serves them as plain text', () => {
+    const source = new URL(
+      'https://raw.githubusercontent.com/allenai/OLMo-core/main/src/olmo_core/aliases.py',
+    );
+    expect(getRemoteFileName(new Response('Alias = str\n'), source, 'text/plain')).toBe(
+      'aliases.py',
+    );
+  });
+
+  it('infers document and workbook extensions from their content type when a URL omits one', () => {
+    expect(
+      getRemoteFileName(
+        new Response(''),
+        new URL('https://files.example.com/download'),
+        'application/pdf',
+      ),
+    ).toBe('download.pdf');
+    expect(
+      getRemoteFileName(
+        new Response(''),
+        new URL('https://files.example.com/export'),
+        'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+      ),
+    ).toBe('export.xlsx');
+  });
+});

package/.next/standalone/apps/web/lib/system-cache.test.ts

@@ -0,0 +1,173 @@
+import { lstat, mkdtemp, mkdir, readFile, rm, symlink, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+import {
+  clearBuildCache,
+  clearGeneralFilesystemCaches,
+  findWorkspaceRoot,
+  getBuildCacheStatus,
+  getGeneralCacheStatus,
+} from './system-cache';
+
+const testDirectories: string[] = [];
+
+async function createWorkspace() {
+  const workspace = await mkdtemp(path.join(os.tmpdir(), 'larkup-cache-test-'));
+  testDirectories.push(workspace);
+  await writeFile(path.join(workspace, 'turbo.json'), '{}');
+  await writeFile(path.join(workspace, 'pnpm-workspace.yaml'), 'packages: []');
+  return workspace;
+}
+
+afterEach(async () => {
+  await Promise.all(
+    testDirectories.splice(0).map((directory) => rm(directory, { recursive: true })),
+  );
+});
+
+describe('system cache maintenance', () => {
+  it('finds the workspace from a nested app directory', async () => {
+    const workspace = await createWorkspace();
+    const appDirectory = path.join(workspace, 'apps', 'web');
+    await mkdir(appDirectory, { recursive: true });
+
+    await expect(findWorkspaceRoot(appDirectory)).resolves.toBe(workspace);
+  });
+
+  it('reports and clears only the workspace Turborepo cache', async () => {
+    const workspace = await createWorkspace();
+    const cacheDirectory = path.join(workspace, '.turbo', 'cache');
+    const turboStateFile = path.join(workspace, '.turbo', 'daemon', 'state.json');
+    const configFile = path.join(workspace, '.larkup', 'projects', 'project-1', 'config.json');
+    await mkdir(cacheDirectory, { recursive: true });
+    await mkdir(path.dirname(turboStateFile), { recursive: true });
+    await mkdir(path.dirname(configFile), { recursive: true });
+    await writeFile(path.join(cacheDirectory, 'artifact.bin'), Buffer.alloc(4096));
+    await writeFile(turboStateFile, '{"port":4567}');
+    await writeFile(configFile, '{"chatApiKey":"secret-key"}');
+    await writeFile(path.join(workspace, 'keep.txt'), 'keep');
+
+    const before = await getBuildCacheStatus(workspace);
+    expect(before.available).toBe(true);
+    expect(before.exists).toBe(true);
+    expect(before.sizeBytes).toBeGreaterThanOrEqual(4096);
+
+    await expect(clearBuildCache(workspace)).resolves.toBe(before.sizeBytes);
+    await expect(getBuildCacheStatus(workspace)).resolves.toEqual({
+      available: true,
+      exists: false,
+      sizeBytes: 0,
+    });
+    await expect(accessFile(path.join(workspace, 'keep.txt'))).resolves.toBe(true);
+    await expect(readFile(turboStateFile, 'utf8')).resolves.toBe('{"port":4567}');
+    await expect(readFile(configFile, 'utf8')).resolves.toBe('{"chatApiKey":"secret-key"}');
+  });
+
+  it.skipIf(process.platform === 'win32')('refuses to follow a Turborepo symlink', async () => {
+    const workspace = await createWorkspace();
+    const target = await mkdtemp(path.join(os.tmpdir(), 'larkup-cache-target-'));
+    testDirectories.push(target);
+    await writeFile(path.join(target, 'keep.txt'), 'keep');
+    await mkdir(path.join(target, 'cache'));
+    await writeFile(path.join(target, 'cache', 'artifact.bin'), 'cache');
+    await symlink(target, path.join(workspace, '.turbo'));
+
+    await expect(clearBuildCache(workspace)).resolves.toBe(0);
+
+    await expect(accessFile(path.join(target, 'keep.txt'))).resolves.toBe(true);
+    await expect(accessFile(path.join(target, 'cache', 'artifact.bin'))).resolves.toBe(true);
+  });
+
+  it('is unavailable outside a recognized source workspace', async () => {
+    const directory = await mkdtemp(path.join(os.tmpdir(), 'larkup-installed-test-'));
+    testDirectories.push(directory);
+
+    await expect(getBuildCacheStatus(directory)).resolves.toEqual({
+      available: false,
+      exists: false,
+      sizeBytes: 0,
+    });
+    await expect(clearBuildCache(directory)).resolves.toBe(0);
+  });
+
+  it('tracks and clears rebuildable project and package caches together', async () => {
+    const workspace = await createWorkspace();
+    const dataRoot = path.join(workspace, 'larkup-data');
+    const project = path.join(dataRoot, 'projects', 'project-1');
+    const toolCache = path.join(dataRoot, 'tools', '.npm-cache');
+    const generatedCache = path.join(
+      dataRoot,
+      'servers',
+      'server-1',
+      'generated-server',
+      '.npm-cache',
+    );
+    await Promise.all([
+      mkdir(project, { recursive: true }),
+      mkdir(toolCache, { recursive: true }),
+      mkdir(generatedCache, { recursive: true }),
+    ]);
+    await Promise.all([
+      writeFile(
+        path.join(project, 'grounded-answer-cache.json'),
+        JSON.stringify({
+          entries: [{ feedback: 'liked' }, { feedback: 'disliked' }],
+        }),
+      ),
+      writeFile(path.join(project, 'image-analysis-cache.json'), Buffer.alloc(1024)),
+      writeFile(path.join(project, 'video-semantic-index.json'), Buffer.alloc(2048)),
+      writeFile(path.join(toolCache, 'package.bin'), Buffer.alloc(4096)),
+      writeFile(path.join(generatedCache, 'package.bin'), Buffer.alloc(8192)),
+      writeFile(path.join(project, 'documents.json'), '[{"content":"keep"}]'),
+    ]);
+
+    const before = await getGeneralCacheStatus(workspace, dataRoot);
+    expect(before.available).toBe(true);
+    expect(before.sizeBytes).toBeGreaterThan(15 * 1024);
+    expect(before.answerFeedback).toEqual({
+      likedEntries: 1,
+      sizeBytes: expect.any(Number),
+    });
+
+    await clearGeneralFilesystemCaches(workspace, dataRoot);
+    await expect(getGeneralCacheStatus(workspace, dataRoot)).resolves.toEqual({
+      available: true,
+      exists: false,
+      sizeBytes: 0,
+      answerFeedback: { likedEntries: 0, sizeBytes: 0 },
+    });
+    await expect(readFile(path.join(project, 'documents.json'), 'utf8')).resolves.toContain('keep');
+  });
+
+  it('does not report the empty video cache container as 46 bytes of cache', async () => {
+    const workspace = await createWorkspace();
+    const dataRoot = path.join(workspace, 'larkup-data');
+    const project = path.join(dataRoot, 'projects', 'project-1');
+    await mkdir(project, { recursive: true });
+    await writeFile(
+      path.join(project, 'video-knowledge.json'),
+      JSON.stringify({
+        artifactAnalysisCache: [],
+        answerMemory: [{ userCorrection: { text: 'Keep this correction.' } }],
+        evidence: [{ id: 'source-evidence-that-must-remain' }],
+      }),
+    );
+
+    await expect(getGeneralCacheStatus(workspace, dataRoot)).resolves.toEqual({
+      available: true,
+      exists: false,
+      sizeBytes: 0,
+      answerFeedback: { likedEntries: 0, sizeBytes: 0 },
+    });
+  });
+});
+
+async function accessFile(file: string): Promise<boolean> {
+  try {
+    await lstat(file);
+    return true;
+  } catch {
+    return false;
+  }
+}

package/.next/standalone/apps/web/lib/utils.ts

@@ -0,0 +1,6 @@
+import { clsx, type ClassValue } from 'clsx'
+import { twMerge } from 'tailwind-merge'
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs))
+}

package/.next/standalone/apps/web/next-env.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="next" />
+/// <reference types="next/image-types/global" />
+import "./.next/types/routes.d.ts";
+import "./.next/types/root-params.d.ts";
+
+// NOTE: This file should not be edited
+// see https://nextjs.org/docs/app/api-reference/config/typescript for more information.

package/.next/standalone/apps/web/next.config.mjs

@@ -0,0 +1,82 @@
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+
+// The workspace keeps local provider credentials in its root `.env`, while
+// Next runs from `apps/web`. Load that server-side file once so API routes and
+// local marketplace runtimes receive the same configured AI Models fallback.
+try {
+  process.loadEnvFile(fileURLToPath(new URL('../../.env', import.meta.url)));
+} catch {
+  // A fresh install may not have a root .env yet; the settings UI remains the
+  // supported configuration path in that case.
+}
+
+// Read version from package.json at build time
+const pkg = JSON.parse(readFileSync(new URL('./package.json', import.meta.url), 'utf-8'));
+
+/** @type {import('next').NextConfig} */
+const nextConfig = {
+  transpilePackages: [
+    '@larkup/connections',
+    '@larkup/core',
+    '@larkup/vector-stores',
+    '@larkup/scraper',
+    '@larkup/marketplace',
+    '@larkup/sandbox',
+  ],
+  serverExternalPackages: [
+    '@lancedb/lancedb',
+    '@ffmpeg-installer/ffmpeg',
+    '@ffprobe-installer/ffprobe',
+    'chromadb',
+    '@chroma-core/default-embed',
+    'dockerode',
+    'node-ssh',
+    'nodejs-whisper',
+    '@napi-rs/canvas',
+    'pdf-parse',
+  ],
+  typescript: {
+    ignoreBuildErrors: true,
+  },
+  images: {
+    unoptimized: true,
+  },
+  output: process.env.E2E_BUILD ? undefined : 'standalone',
+  // Standalone tracing runs from this monorepo and must never recursively
+  // package generated dev/desktop outputs. Besides bloating releases, stale
+  // build copies can retain environment names that source code no longer uses.
+  outputFileTracingExcludes: {
+    '/*': [
+      '.next/dev/**/*',
+      '.next/standalone/**/*',
+      '../desktop/src-tauri/target/**/*',
+    ],
+  },
+  env: {
+    NEXT_PUBLIC_APP_VERSION: pkg.version,
+  },
+  async rewrites() {
+    return [
+      {
+        source: '/uploads/:path*',
+        destination: '/api/uploads/:path*',
+      },
+    ];
+  },
+  webpack: (config) => {
+    config.ignoreWarnings = [
+      ...(config.ignoreWarnings || []),
+      { module: /ffmpeg-spawn\.js/ },
+    ];
+    return config;
+  },
+  // `next dev` runs on Turbopack by default (only `next build --webpack` above
+  // hits the `webpack()` hook), so the ffmpeg-spawn warning needs its own
+  // Turbopack-side suppression: https://nextjs.org/docs/app/api-reference/config/next-config-js/turbopackIgnoreIssue
+  turbopack: {
+    ignoreIssue: [{ path: '**/ffmpeg-spawn.js', title: 'Module not found' }],
+  },
+};
+
+export default nextConfig;