@hraness/slopcamera 3.2.4

package/apps/desktop/cli/media-ingest-model.ts

@@ -0,0 +1,364 @@
+import { z } from "zod";
+import {
+  ProjectAssetRoleSchema, ProjectAssetV1Schema, ProjectMediaStreamSchema,
+  RepositoryRelativePathSchema, type ProjectAssetV1,
+} from "../contracts";
+import { CliError } from "./errors";
+import type { ProcessRunner } from "./io";
+import type { MediaIngestDurability } from "./media-ingest-platform";
+
+export const MAX_MEDIA_BYTES = 4 * 1024 * 1024 * 1024 * 1024;
+export const MAX_PROBE_BYTES = 4 * 1024 * 1024;
+export const MAX_PROBE_TIMEOUT_MS = 2 * 60_000;
+export const SELF_CONTAINED_MEDIA_INPUT_ARGUMENTS = [
+  "-protocol_whitelist",
+  "file",
+  "-format_whitelist",
+  [
+    "aac",
+    "ac3",
+    "aiff",
+    "alaw",
+    "amr",
+    "ape",
+    "apng",
+    "asf",
+    "au",
+    "av1",
+    "avi",
+    "bmp_pipe",
+    "caf",
+    "dv",
+    "eac3",
+    "flac",
+    "flv",
+    "g722",
+    "g726",
+    "gif",
+    "gsm",
+    "h261",
+    "h263",
+    "h264",
+    "hevc",
+    "ircam",
+    "ivf",
+    "jpeg_pipe",
+    "m4v",
+    "matroska",
+    "mov",
+    "mp3",
+    "mpeg",
+    "mpegts",
+    "mpegvideo",
+    "mulaw",
+    "mxf",
+    "nut",
+    "ogg",
+    "oma",
+    "opus",
+    "png_pipe",
+    "rawvideo",
+    "rm",
+    "vvc",
+    "w64",
+    "wav",
+    "webm",
+    "webp_pipe",
+    "tiff_pipe",
+    "yuv4mpegpipe",
+  ].join(","),
+] as const;
+
+const ProbeStreamSchema = z.strictObject({
+  avg_frame_rate: z.string().optional(),
+  channels: z.number().int().positive().optional(),
+  codec_name: z.string().min(1),
+  codec_type: z.string().min(1).max(64),
+  duration: z.string().optional(),
+  disposition: z.strictObject({
+    attached_pic: z.union([z.boolean(), z.number().int().min(0).max(1)]).optional(),
+    still_image: z.union([z.boolean(), z.number().int().min(0).max(1)]).optional(),
+    timed_thumbnails: z.union([z.boolean(), z.number().int().min(0).max(1)]).optional(),
+  }).optional(),
+  height: z.number().int().positive().optional(),
+  index: z.number().int().nonnegative(),
+  r_frame_rate: z.string().optional(),
+  sample_rate: z.string().optional(),
+  start_time: z.string().optional(),
+  tags: z.strictObject({
+    DURATION: z.string().optional(),
+    duration: z.string().optional(),
+  }).optional(),
+  width: z.number().int().positive().optional(),
+});
+
+const ProbeOutputSchema = z.strictObject({
+  format: z.strictObject({
+    duration: z.string().optional(),
+    format_name: z.string().min(1),
+    start_time: z.string().optional(),
+  }),
+  programs: z.array(z.never()).max(0).optional(),
+  stream_groups: z.array(z.never()).max(0).optional(),
+  streams: z.array(ProbeStreamSchema).min(1).max(256),
+});
+
+export interface ProbedMediaStream extends z.infer<typeof ProbeStreamSchema> {
+  readonly assetRange: Readonly<{ readonly endUs: number; readonly startUs: number }>;
+  readonly fileRange: Readonly<{ readonly endUs: number; readonly startUs: number }>;
+}
+
+export interface ProbedMedia {
+  readonly container: string;
+  readonly durationUs: number;
+  readonly streams: readonly ProbedMediaStream[];
+}
+
+function decimalDurationToUs(value: string | undefined): number | null {
+  if (value === undefined || value.trim() === "") return null;
+  const seconds = Number(value);
+  const microseconds = Math.round(seconds * 1_000_000);
+  return Number.isFinite(seconds) && Number.isSafeInteger(microseconds) && microseconds > 0
+    ? microseconds
+    : null;
+}
+
+function decimalTimestampToUs(value: string | undefined): number | null {
+  if (value === undefined || value.trim() === "") return null;
+  const seconds = Number(value);
+  const microseconds = Math.round(seconds * 1_000_000);
+  return Number.isFinite(seconds) && Number.isSafeInteger(microseconds) ? microseconds : null;
+}
+
+function durationTagToUs(value: string | undefined): number | null {
+  if (value === undefined || value.trim() === "") return null;
+  const match = /^(?<hours>[0-9]+):(?<minutes>[0-5][0-9]):(?<seconds>[0-5][0-9])(?:\.(?<fraction>[0-9]{1,9}))?$/u.exec(value);
+  if (match?.groups === undefined) return null;
+  const wholeSeconds = Number(match.groups.hours) * 3_600
+    + Number(match.groups.minutes) * 60
+    + Number(match.groups.seconds);
+  const fraction = match.groups.fraction ?? "";
+  const microseconds = wholeSeconds * 1_000_000 + Math.round(Number(`0.${fraction}`) * 1_000_000);
+  return Number.isSafeInteger(microseconds) && microseconds > 0 ? microseconds : null;
+}
+
+function safeTimeSum(left: number, right: number, label: string): number {
+  const result = left + right;
+  if (!Number.isSafeInteger(result)) {
+    throw new CliError("invalid-data", `${label} exceeds the supported timestamp range.`);
+  }
+  return result;
+}
+
+function rational(value: string | undefined): number | null {
+  if (value === undefined) return null;
+  const match = /^(?<numerator>[0-9]+)\/(?<denominator>[0-9]+)?$/u.exec(value);
+  if (match?.groups?.numerator === undefined) return null;
+  const numerator = Number(match.groups.numerator);
+  const denominator = Number(match.groups.denominator ?? "1");
+  const result = numerator / denominator;
+  return Number.isFinite(result) && result > 0 ? result : null;
+}
+
+export function parseMediaProbe(input: string): ProbedMedia {
+  let json: unknown;
+  try {
+    json = JSON.parse(input) as unknown;
+  } catch {
+    throw new CliError("invalid-data", "FFprobe media output is not valid JSON.");
+  }
+  const parsed = ProbeOutputSchema.safeParse(json);
+  if (!parsed.success) {
+    throw new CliError("invalid-data", `FFprobe media output is invalid: ${parsed.error.issues[0]?.message ?? "unknown error"}`);
+  }
+  const playableStreams = parsed.data.streams.filter(
+    (stream): stream is typeof stream & { readonly codec_type: "audio" | "video" } => (
+      (stream.codec_type === "audio" || stream.codec_type === "video")
+      && (
+        stream.codec_type !== "video"
+        || (
+          stream.disposition?.attached_pic !== 1
+          && stream.disposition?.attached_pic !== true
+          && stream.disposition?.still_image !== 1
+          && stream.disposition?.still_image !== true
+          && stream.disposition?.timed_thumbnails !== 1
+          && stream.disposition?.timed_thumbnails !== true
+        )
+      )
+    ),
+  );
+  if (playableStreams.length === 0) {
+    throw new CliError("invalid-data", "Media contains no playable audio or video streams after attached pictures are excluded.");
+  }
+  if (playableStreams.length > 64) {
+    throw new CliError("invalid-data", "Media contains more than 64 playable audio/video streams.");
+  }
+  const formatDurationUs = decimalDurationToUs(parsed.data.format.duration);
+  if (
+    formatDurationUs === null
+    && playableStreams.every(stream => (
+      decimalDurationToUs(stream.duration) === null
+      && durationTagToUs(stream.tags?.DURATION ?? stream.tags?.duration) === null
+    ))
+  ) {
+    throw new CliError("invalid-data", "Media has no positive finite duration.");
+  }
+  const formatStartUs = decimalTimestampToUs(parsed.data.format.start_time);
+  const explicitStarts = playableStreams.flatMap(stream => {
+    const startUs = decimalTimestampToUs(stream.start_time);
+    return startUs === null ? [] : [startUs];
+  });
+  const clockOriginUs = Math.min(formatStartUs ?? Number.POSITIVE_INFINITY, ...explicitStarts);
+  const commonOriginUs = Number.isFinite(clockOriginUs) ? clockOriginUs : 0;
+  const formatEndUs = formatDurationUs === null
+    ? null
+    : safeTimeSum(formatStartUs ?? commonOriginUs, formatDurationUs, "Media format duration");
+  const streams: ProbedMediaStream[] = [];
+  for (const stream of playableStreams) {
+    if (stream.codec_type === "video") {
+      if (stream.width === undefined || stream.height === undefined) {
+        throw new CliError("invalid-data", `Video stream ${stream.index} omits pixel dimensions.`);
+      }
+      if ((rational(stream.avg_frame_rate) ?? rational(stream.r_frame_rate)) === null) {
+        throw new CliError("invalid-data", `Video stream ${stream.index} omits a positive frame rate.`);
+      }
+    } else {
+      if (stream.channels === undefined || !/^[1-9][0-9]*$/u.test(stream.sample_rate ?? "")) {
+        throw new CliError("invalid-data", `Audio stream ${stream.index} omits channel or sample-rate facts.`);
+      }
+    }
+    const nativeStartUs = decimalTimestampToUs(stream.start_time) ?? formatStartUs ?? commonOriginUs;
+    const startUs = nativeStartUs - commonOriginUs;
+    if (!Number.isSafeInteger(startUs) || startUs < 0) {
+      throw new CliError("invalid-data", `Stream ${stream.index} has an invalid start time.`);
+    }
+    const streamDurationUs = decimalDurationToUs(stream.duration)
+      ?? durationTagToUs(stream.tags?.DURATION ?? stream.tags?.duration)
+      ?? (formatEndUs === null ? null : formatEndUs - nativeStartUs);
+    if (streamDurationUs === null || !Number.isSafeInteger(streamDurationUs) || streamDurationUs <= 0) {
+      throw new CliError("invalid-data", `Stream ${stream.index} has no positive finite duration.`);
+    }
+    const endUs = safeTimeSum(startUs, streamDurationUs, `Stream ${stream.index} duration`);
+    streams.push({
+      ...stream,
+      assetRange: { endUs, startUs },
+      fileRange: { endUs, startUs },
+    });
+  }
+  const formatCoverageEndUs = formatEndUs === null ? 0 : formatEndUs - commonOriginUs;
+  const durationUs = Math.max(formatCoverageEndUs, ...streams.map(stream => stream.assetRange.endUs));
+  if (!Number.isSafeInteger(durationUs) || durationUs <= 0) {
+    throw new CliError("invalid-data", "Media has no positive finite duration.");
+  }
+  return {
+    container: parsed.data.format.format_name.split(",")[0]!,
+    durationUs,
+    streams,
+  };
+}
+
+function importedStreamRole(
+  assetRole: z.infer<typeof ProjectAssetRoleSchema>,
+  streamKind: "audio" | "video",
+): string {
+  if (streamKind === "video") {
+    if (assetRole === "camera") return "camera";
+    if (assetRole === "b-roll") return "b-roll";
+    if (assetRole === "screen") return "screen";
+    return "other";
+  }
+  if (
+    assetRole === "system-audio"
+    || assetRole === "microphone"
+    || assetRole === "portable-audio"
+    || assetRole === "music"
+    || assetRole === "dialogue"
+  ) return assetRole;
+  return "other";
+}
+
+export interface IngestProjectMediaOptions {
+  /** @internal Injectable durability boundary for focused fault and ordering tests. */
+  readonly durability?: MediaIngestDurability;
+  readonly ffprobe: string;
+  readonly now: Date;
+  readonly projectDirectory: string;
+  readonly repositoryRoot: string;
+  readonly role: z.input<typeof ProjectAssetRoleSchema>;
+  readonly runner: ProcessRunner;
+  readonly sourcePath: string;
+}
+
+export interface IngestedProjectMedia {
+  readonly absolutePath: string;
+  readonly asset: ProjectAssetV1;
+  readonly created: boolean;
+}
+
+export interface StagedMediaImport {
+  readonly absolutePath: string;
+  readonly bytes: number;
+  readonly sha256: string;
+  readonly temporaryPath: string;
+  readonly importsDirectory: string;
+  readonly identity: Readonly<{ dev: number; ino: number }>;
+}
+
+export function importedAsset(
+  options: IngestProjectMediaOptions,
+  role: z.infer<typeof ProjectAssetRoleSchema>,
+  imported: StagedMediaImport,
+  probe: ProbedMedia,
+  path: z.infer<typeof RepositoryRelativePathSchema>,
+  label: string,
+): ProjectAssetV1 {
+  const assetId = `asset_${imported.sha256.slice(0, 24)}`;
+  const streams = probe.streams.map(stream => {
+    const base = {
+      label: `${stream.codec_type} stream ${stream.index}`,
+      segments: [{
+        assetRange: stream.assetRange,
+        bytes: imported.bytes,
+        codec: stream.codec_name,
+        container: probe.container,
+        fileRange: stream.fileRange,
+        path,
+        sha256: imported.sha256,
+        streamIndex: stream.index,
+      }],
+      streamId: `stream_${imported.sha256.slice(0, 20)}_${stream.index}`,
+    };
+    if (stream.codec_type === "video") {
+      return ProjectMediaStreamSchema.parse({
+        ...base,
+        frameRate: rational(stream.avg_frame_rate) ?? rational(stream.r_frame_rate)!,
+        kind: "video",
+        pixelHeight: stream.height,
+        pixelWidth: stream.width,
+        role: importedStreamRole(role, "video"),
+      });
+    }
+    return ProjectMediaStreamSchema.parse({
+      ...base,
+      channels: stream.channels,
+      kind: "audio",
+      role: importedStreamRole(role, "audio"),
+      sampleRateHz: Number(stream.sample_rate),
+    });
+  });
+  const asset = ProjectAssetV1Schema.parse({
+    assetId,
+    createdAt: options.now.toISOString(),
+    durationUs: probe.durationUs,
+    label: label,
+    role,
+    source: {
+      importedAt: options.now.toISOString(),
+      kind: "imported",
+      originalName: label,
+      sourceSha256: imported.sha256,
+    },
+    streams,
+  });
+  return asset;
+}

package/apps/desktop/cli/media-ingest-platform.ts

@@ -0,0 +1,227 @@
+import { createHash, randomUUID } from "node:crypto";
+import { constants, createReadStream, type Stats } from "node:fs";
+import { type FileHandle, lstat, link, mkdir, open, realpath, rm } from "node:fs/promises";
+import { basename, isAbsolute, join, relative, resolve } from "node:path";
+import { pipeline } from "node:stream/promises";
+import { Transform, Writable } from "node:stream";
+import { Cause, Context, Effect, Layer } from "effect";
+import {
+  operationBoundary, operationResource, operationValidation, type OperationEffectFailure,
+} from "../application/operation-effects";
+import { RepositoryRelativePathSchema } from "../contracts";
+import { CliError } from "./errors";
+import type { ProcessRunner, RunResult } from "./io";
+import {
+  MAX_MEDIA_BYTES, MAX_PROBE_BYTES, MAX_PROBE_TIMEOUT_MS,
+  SELF_CONTAINED_MEDIA_INPUT_ARGUMENTS,
+} from "./media-ingest-model";
+import { ensurePrivateDirectory } from "./paths";
+import { verifyPhysicalProjectMedia } from "./project-media-integrity";
+
+export interface MediaIngestDurability {
+  syncDirectory(path: string): Promise<void>;
+  syncFile(handle: FileHandle, path: string): Promise<void>;
+}
+
+function isWithin(root: string, candidate: string): boolean {
+  const pathFromRoot = relative(root, candidate);
+  return pathFromRoot === "" || (!pathFromRoot.startsWith("..") && !isAbsolute(pathFromRoot));
+}
+
+type Native<A> = Effect.Effect<A, OperationEffectFailure>;
+export interface MediaIngestPlatformService {
+  realpath(path: string): Native<string>;
+  sourcePath(path: string): Native<string>;
+  importsPath(root: string): Native<string>;
+  temporaryPath(imports: string, name: string): Native<string>;
+  destinationPath(imports: string, sha256: string): Native<string>;
+  assertWithin(root: string, candidate: string, message: string): Native<void>;
+  assetLocation(root: string, destination: string, source: string): Native<Readonly<{
+    path: ReturnType<typeof RepositoryRelativePathSchema.parse>; label: string;
+  }>>;
+  lstat(path: string): Native<Stats>;
+  ensurePrivateDirectory(path: string): Native<void>;
+  mkdir(path: string): Native<void>;
+  uniqueName(): Native<string>;
+  openSource(path: string): Native<FileHandle>;
+  openTemporary(path: string): Native<FileHandle>;
+  stat(handle: FileHandle): Native<Stats>;
+  close(handle: FileHandle): Native<void>;
+  copy(source: FileHandle, staged: FileHandle): Native<Readonly<{ bytes: number; sha256: string }>>;
+  syncFile(handle: FileHandle, path: string): Native<void>;
+  syncDirectory(path: string): Native<void>;
+  remove(path: string): Native<void>;
+  link(source: string, destination: string): Native<void>;
+  verify(path: string, expected: Readonly<{ bytes: number; sha256: string }>, label: string): Native<void>;
+  probe(ffprobe: string, runner: ProcessRunner, path: string): Native<RunResult>;
+}
+
+export class MediaIngestPlatform extends Context.Tag("@slopcamera/local/MediaIngestPlatform")<
+  MediaIngestPlatform, MediaIngestPlatformService
+>() { }
+
+/** Each admitted foreign call retains custody until its actual settlement. */
+function native<A>(execute: () => A | Promise<A>): Native<A> {
+  return Effect.uninterruptible(operationBoundary("media", execute));
+}
+
+interface NativeStreamFailure {
+  readonly cause: unknown;
+  readonly signal: Error;
+}
+
+type CopyObservation =
+  | Readonly<{ success: true; bytes: number; sha256: string }>
+  | Readonly<{ success: false; cause: unknown; prior: readonly NativeStreamFailure[] }>;
+
+function fileHandleReadStream(handle: FileHandle, recordFailure: (cause: unknown) => Error) {
+  let pending = Promise.resolve();
+  // The built-in stream owns backpressure, but borrows the numeric descriptor.
+  // FileHandle.createReadStream adds a second close/ref owner on pinned Bun.
+  // With an fd supplied, the empty path is never opened.
+  const stream = createReadStream("", {
+    fd: handle.fd, autoClose: false, highWaterMark: 65_536,
+    fs: {
+      read(_fd: number, buffer: Buffer, offset: number, length: number, position: number | null, callback: (error: Error | null, bytesRead: number, buffer: Buffer) => void) {
+        pending = handle.read(buffer, offset, length, position).then(
+          result => callback(null, result.bytesRead, result.buffer),
+          (cause: unknown) => callback(recordFailure(cause), 0, buffer),
+        );
+      },
+      close(_fd: number, callback: (error: Error | null) => void) { callback(null); },
+    },
+  });
+  return { stream, settle: async () => { await pending; } };
+}
+
+function fileHandleWriteStream(handle: FileHandle, recordFailure: (cause: unknown) => Error): {
+  readonly stream: Writable;
+  readonly settle: () => Promise<void>;
+} {
+  let position = 0;
+  let pending = Promise.resolve();
+  const stream = new Writable({
+    write(chunk: Buffer, _encoding, callback) {
+      const writeAll = async (): Promise<void> => {
+        let offset = 0;
+        while (offset < chunk.byteLength) {
+          const result = await handle.write(chunk, offset, chunk.byteLength - offset, position + offset);
+          if (result.bytesWritten <= 0) {
+            throw new Error("Media import made no progress while writing its staged file.");
+          }
+          offset += result.bytesWritten;
+        }
+        position += chunk.byteLength;
+      };
+      pending = writeAll().then(() => callback(), (cause: unknown) => callback(recordFailure(cause)));
+    },
+  });
+  return { stream, settle: async () => { await pending; } };
+}
+
+async function copyMedia(source: FileHandle, staged: FileHandle): Promise<CopyObservation> {
+  const hash = createHash("sha256");
+  let bytes = 0;
+  const failures: NativeStreamFailure[] = [];
+  const recordFailure = (cause: unknown): Error => {
+    // Callback streams interpret falsey errors as success. Keep rejection
+    // presence separately from the real Error used only as a stream signal.
+    const signal = cause instanceof Error ? cause : new Error("Native media I/O failed.");
+    failures.push({ cause, signal });
+    return signal;
+  };
+  const reader = fileHandleReadStream(source, recordFailure);
+  const writer = fileHandleWriteStream(staged, recordFailure);
+  const result = await pipeline(
+    reader.stream,
+    new Transform({
+      transform(chunk: Buffer, _encoding, callback) {
+        bytes += chunk.byteLength;
+        if (bytes > MAX_MEDIA_BYTES) return callback(new Error("Media source exceeded its size bound while reading."));
+        hash.update(chunk);
+        callback(null, chunk);
+      },
+    }),
+    writer.stream,
+  ).then(() => ({ success: true as const }), (cause: unknown) => ({ success: false as const, cause }));
+  // Destruction stops new stream admission, not already-issued native I/O.
+  // Join both before the operation owner closes descriptors or removes staging.
+  await Promise.all([reader.settle(), writer.settle()]);
+  if (!result.success) {
+    const selected = failures.find(failure => result.cause === failure.signal);
+    return {
+      success: false, cause: selected === undefined ? result.cause : selected.cause,
+      prior: failures.filter(failure => failure !== selected),
+    };
+  }
+  const [first, ...prior] = failures;
+  if (first !== undefined) return { success: false, cause: first.cause, prior };
+  return { success: true, bytes, sha256: hash.digest("hex") };
+}
+
+export function createMediaIngestPlatform(durability?: MediaIngestDurability): MediaIngestPlatformService {
+  return {
+    realpath: path => native(() => realpath(path)),
+    sourcePath: path => operationValidation("media", () => resolve(path)),
+    importsPath: root => operationValidation("media", () => join(root, "imports")),
+    temporaryPath: (imports, name) => operationValidation("media", () => join(imports, name)),
+    destinationPath: (imports, sha256) => operationValidation("media", () => join(imports, `${sha256}.media`)),
+    assertWithin: (root, candidate, message) => operationValidation("media", () => {
+      if (!isWithin(root, candidate)) throw new CliError("unsafe-path", message);
+    }),
+    assetLocation: (root, destination, source) => operationValidation("media", () => {
+      const repositoryPath = relative(root, destination);
+      if (!isWithin(root, destination) || isAbsolute(repositoryPath)) {
+        throw new CliError("unsafe-path", "Imported media destination is outside the repository.");
+      }
+      return { path: RepositoryRelativePathSchema.parse(repositoryPath), label: basename(source) };
+    }),
+    lstat: path => native(() => lstat(path)),
+    ensurePrivateDirectory: path => native(() => ensurePrivateDirectory(path)),
+    mkdir: path => native(() => mkdir(path, { mode: 0o700 })),
+    uniqueName: () => operationValidation("media", () => `.import-${randomUUID()}.tmp`),
+    openSource: path => native(() => open(path, constants.O_RDONLY | constants.O_NOFOLLOW)),
+    openTemporary: path => native(() => open(path, constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW | constants.O_WRONLY, 0o600)),
+    stat: handle => native(() => handle.stat()),
+    close: handle => native(() => handle.close()),
+    copy: (source, staged) => native(() => copyMedia(source, staged)).pipe(Effect.flatMap(result => result.success
+      ? Effect.succeed({ bytes: result.bytes, sha256: result.sha256 })
+      : Effect.fail({
+          _tag: "OperationBoundaryFailure" as const,
+          phase: "media" as const,
+          cause: result.cause,
+          ...(result.prior.length === 0 ? {} : { priorCause: result.prior.reduce<Cause.Cause<OperationEffectFailure>>(
+            (prior, failure) => Cause.sequential(prior, Cause.fail({
+              _tag: "OperationBoundaryFailure", phase: "media", cause: failure.cause,
+            })), Cause.empty,
+          ) }),
+        }))),
+    syncFile: (handle, path) => native(() => durability === undefined ? handle.sync() : durability.syncFile(handle, path)),
+    syncDirectory: path => durability === undefined
+      ? operationResource(
+          native(() => open(path, constants.O_RDONLY | constants.O_NOFOLLOW)),
+          directory => Effect.gen(function*() {
+            const details = yield* native(() => directory.stat());
+            yield* operationValidation("media", () => {
+              if (!details.isDirectory()) throw new CliError("unsafe-path", `Media durability path is not a physical directory: ${path}`);
+            });
+            yield* native(() => directory.sync());
+          }),
+          directory => native(() => directory.close()),
+        )
+      : native(() => durability.syncDirectory(path)),
+    remove: path => native(() => rm(path, { force: true })),
+    link: (source, destination) => native(() => link(source, destination)),
+    verify: (path, expected, label) => native(() => verifyPhysicalProjectMedia(path, expected, label)),
+    probe: (ffprobe, runner, path) => native(() => runner.run([
+      ffprobe,
+      "-v", "error",
+      ...SELF_CONTAINED_MEDIA_INPUT_ARGUMENTS,
+      "-show_entries", "format=duration,format_name,start_time:stream=index,codec_type,codec_name,width,height,avg_frame_rate,r_frame_rate,sample_rate,channels,start_time,duration:stream_disposition=attached_pic,still_image,timed_thumbnails:stream_tags=duration",
+      "-of", "json", path,
+    ], { maxOutputBytes: MAX_PROBE_BYTES, timeoutMs: MAX_PROBE_TIMEOUT_MS })),
+  };
+}
+
+export const MediaIngestPlatformLive = (durability?: MediaIngestDurability): Layer.Layer<MediaIngestPlatform> =>
+  Layer.succeed(MediaIngestPlatform, createMediaIngestPlatform(durability));