davinci-resolve-mcp 2.66.0 → 2.67.1

package/resolve-advanced/server/tools/deliverable.mjs

@@ -10,11 +10,13 @@
  *   re_delivery_diff       — old vs new render: frame-count/duration Δ + spec drift
  *   render_manifest        — build (checksums + frame counts) / reconcile actual outputs
  *   expand_deliverable     — model texted/textless/stems/slate/leader entities + their rules
+ *   spec_from_authored     — authored deliverable vocabulary → deliverable_qc spec + loudness target
  */
 import { z } from 'zod';
 import { deliverableQc, loudnessQc, reframeBlankingCheck, conformCompleteness, reDeliveryDiff } from '../deliverable-qc.mjs';
 import { buildManifest, reconcileManifest } from '../render-manifest.mjs';
 import { expandDeliverable } from '../deliverable-entities.mjs';
+import { deliverableSpecFromAuthored, deliverableSpecsFromAuthored } from '../deliverable-spec-bridge.mjs';
 
 const specSchema = z.object({}).passthrough();
 
@@ -64,10 +66,21 @@ const expandSchema = z.object({
   entities: z.array(z.enum(['texted', 'textless', 'stems_ME', 'slate', 'leader'])).optional(),
 });
 
+const specFromAuthoredSchema = z
+  .object({
+    deliverable: specSchema
+      .optional()
+      .describe('One authored deliverable: { id?, video:{codec,res,fps,color}, audio:{config,loudness}, container?, naming? }'),
+    deliverables: z.array(specSchema).optional().describe('An authored deliverables: list'),
+  })
+  .refine((a) => !!a.deliverable !== !!a.deliverables, {
+    message: 'pass exactly one of deliverable or deliverables',
+  });
+
 export const deliverableTool = {
   name: 'deliverable',
   description:
-    'Deliverable QC / compliance (Cluster D) — the #1 reject-preventer. MEASURE/report-only (gate: review — never auto-pass-clear). Actions: deliverable_qc (ffprobe a render vs its spec → pass/fail per field: codec/raster/fps/scan/color tags/audio layout/naming/duration), loudness_qc (ebur128 integrated LUFS + true-peak dBTP + LRA vs target), reframe_blanking_check (letterbox/pillarbox + active-picture bounds + illegal edge pixels), conform_completeness (all online, handles, duration == reference frame-exact), re_delivery_diff (old vs new render: frame/duration Δ + spec drift), render_manifest (build checksums+frame-counts / reconcile actual outputs), expand_deliverable (model texted/textless/stems/slate/leader entities + rules). Needs ffmpeg/ffprobe on PATH for the file actions.',
+    'Deliverable QC / compliance (Cluster D) — the #1 reject-preventer. MEASURE/report-only (gate: review — never auto-pass-clear). Actions: deliverable_qc (ffprobe a render vs its spec → pass/fail per field: codec/raster/fps/scan/color tags/audio layout/naming/duration), loudness_qc (ebur128 integrated LUFS + true-peak dBTP + LRA vs target), reframe_blanking_check (letterbox/pillarbox + active-picture bounds + illegal edge pixels), conform_completeness (all online, handles, duration == reference frame-exact), re_delivery_diff (old vs new render: frame/duration Δ + spec drift), render_manifest (build checksums+frame-counts / reconcile actual outputs), expand_deliverable (model texted/textless/stems/slate/leader entities + rules), spec_from_authored (authored deliverable vocabulary — codec display names, "1920x1080", "-16 LUFS", naming templates — into a deliverable_qc spec + loudness_qc target, reporting anything it could not map). Needs ffmpeg/ffprobe on PATH for the file actions.',
   async handler({ action, args }) {
     if (action === 'deliverable_qc') {
       const p = deliverableQcSchema.parse(args);
@@ -100,6 +113,12 @@ export const deliverableTool = {
       const p = expandSchema.parse(args);
       return expandDeliverable({ name: p.name, spec: p.spec, entities: p.entities });
     }
+    if (action === 'spec_from_authored') {
+      const p = specFromAuthoredSchema.parse(args);
+      return p.deliverables
+        ? { deliverables: deliverableSpecsFromAuthored(p.deliverables) }
+        : deliverableSpecFromAuthored(p.deliverable);
+    }
     throw new Error(`Unknown deliverable action: ${action}`);
   },
 };

package/src/granular/common.py

@@ -44,6 +44,10 @@ from src.utils.layout_presets import (
 )
 from src.utils.object_inspection import inspect_object, print_object_help
 from src.utils.platform import get_platform, get_resolve_paths
+from src.utils.render_ids import (
+    render_codec_id_from_codecs,
+    render_format_id_from_formats,
+)
 from src.utils.resolve_connection import connect_resolve
 from src.utils.project_properties import (
     get_all_project_properties,
@@ -81,7 +85,7 @@ if not logging.getLogger().handlers:
         handlers=[logging.StreamHandler()],
     )
 
-VERSION = "2.66.0"
+VERSION = "2.67.1"
 logger = logging.getLogger("davinci-resolve-mcp")
 logger.info(f"Starting DaVinci Resolve MCP Server v{VERSION}")
 logger.info(f"Detected platform: {get_platform()}")

package/src/granular/project.py

@@ -1225,7 +1225,7 @@ def get_render_codecs(format_name: str) -> Dict[str, Any]:
     """Get available codecs for a given render format.
 
     Args:
-        format_name: Render format name (e.g. 'mp4', 'mov', 'avi').
+        format_name: Render format id or display name (e.g. 'mov', 'QuickTime').
     """
     resolve = get_resolve()
     if resolve is None:
@@ -1233,8 +1233,11 @@ def get_render_codecs(format_name: str) -> Dict[str, Any]:
     project = resolve.GetProjectManager().GetCurrentProject()
     if not project:
         return {"error": "No project currently open"}
-    codecs = project.GetRenderCodecs(format_name)
-    return {"format": format_name, "codecs": codecs if codecs else {}}
+    # GetRenderCodecs needs the format *id*; GetRenderFormats returns
+    # {display_name: id}, so an unnormalized display name yields {} (issue #59).
+    format_id = render_format_id_from_formats(project.GetRenderFormats() or {}, format_name)
+    codecs = project.GetRenderCodecs(format_id)
+    return {"format": format_name, "format_id": format_id, "codecs": codecs if codecs else {}}
 
 
 @mcp.tool()
@@ -1255,8 +1258,9 @@ def set_current_render_format_and_codec(format_name: str, codec_name: str) -> Di
     """Set the render format and codec.
 
     Args:
-        format_name: Render format (e.g. 'mp4', 'mov').
-        codec_name: Codec name (e.g. 'H264', 'H265', 'ProRes422HQ').
+        format_name: Render format id or display name (e.g. 'mov', 'QuickTime').
+        codec_name: Codec id or display name (e.g. 'ProRes422HQ',
+            'Apple ProRes 422 HQ', 'H.264').
     """
     resolve = get_resolve()
     if resolve is None:
@@ -1264,8 +1268,19 @@ def set_current_render_format_and_codec(format_name: str, codec_name: str) -> Di
     project = resolve.GetProjectManager().GetCurrentProject()
     if not project:
         return {"error": "No project currently open"}
-    result = project.SetCurrentRenderFormatAndCodec(format_name, codec_name)
-    return {"success": bool(result), "format": format_name, "codec": codec_name}
+    # Both arguments must be *ids*. The display names Resolve shows in the UI are
+    # the dict keys, not the values, so passing them through raw is silently
+    # rejected for every format where label != id (QuickTime/ProRes, not mp4).
+    format_id = render_format_id_from_formats(project.GetRenderFormats() or {}, format_name)
+    codec_id = render_codec_id_from_codecs(project.GetRenderCodecs(format_id) or {}, codec_name)
+    result = project.SetCurrentRenderFormatAndCodec(format_id, codec_id)
+    return {
+        "success": bool(result),
+        "format": format_name,
+        "codec": codec_name,
+        "format_id": format_id,
+        "codec_id": codec_id,
+    }
 
 
 @mcp.tool()

package/src/server.py

@@ -11,7 +11,7 @@ Usage:
     python src/server.py --full       # Start the 341-tool granular server instead
 """
 
-VERSION = "2.66.0"
+VERSION = "2.67.1"
 
 import base64
 import os
@@ -49,6 +49,11 @@ from src.utils.cut_ir import build_cut_list as _build_cut_list
 from src.utils.page_lock import open_page_serialized as _open_page_serialized
 from src.utils.proc import safe_run
 from src.utils.readback import verify_by_readback, verification_stats as _verification_stats
+from src.utils.render_ids import (
+    render_codec_id_from_codecs as _render_codec_id_from_codecs,
+    render_format_id_from_formats as _render_format_id_from_formats,
+)
+from src.utils import delivery_targets as _delivery_targets
 from src.utils.update_check import (
     check_for_updates,
     clear_update_prompt_preferences,
@@ -15233,6 +15238,9 @@ _RENDER_KERNEL_ACTIONS = [
     "quick_export_capabilities",
     "safe_quick_export",
     "export_render_boundary_report",
+    "list_delivery_targets",
+    "resolve_delivery_target",
+    "prepare_delivery_job",
 ]
 
 
@@ -15256,24 +15264,6 @@ def _render_formats(proj):
     return _ser(formats)
 
 
-def _render_format_id_from_formats(formats: Any, fmt: str) -> str:
-    if not isinstance(fmt, str) or not fmt or not isinstance(formats, dict):
-        return fmt
-    if fmt in formats:
-        return formats.get(fmt) or fmt
-    if fmt in formats.values():
-        return fmt
-    needle = fmt.lower()
-    for label, format_id in formats.items():
-        label_text = str(label)
-        id_text = str(format_id)
-        if label_text.lower() == needle:
-            return id_text or fmt
-        if id_text.lower() == needle:
-            return id_text
-    return fmt
-
-
 def _render_format_id(proj, fmt: str, formats: Optional[Dict[str, Any]] = None) -> str:
     if formats is None:
         formats = _render_formats(proj)
@@ -15294,6 +15284,15 @@ def _render_format_requested(requested: Optional[List[Any]], label: str, extensi
     return False
 
 
+def _render_codec_id(proj, fmt: str, codec: str, formats: Optional[Dict[str, Any]] = None) -> str:
+    """Resolve a codec display name to its id for `fmt` (itself label-or-id tolerant)."""
+    try:
+        codecs = proj.GetRenderCodecs(_render_format_id(proj, fmt, formats)) or {}
+    except Exception:
+        return codec
+    return _render_codec_id_from_codecs(codecs, codec)
+
+
 def _render_codecs(proj, fmt: str, formats: Optional[Dict[str, Any]] = None):
     try:
         return _ser(proj.GetRenderCodecs(_render_format_id(proj, fmt, formats)) or {})
@@ -15490,7 +15489,33 @@ def _prepare_render_job(proj, p: Dict[str, Any]):
     before = _render_settings_snapshot(proj)
     format_success = None
     if p.get("format") and p.get("codec"):
-        format_success = bool(proj.SetCurrentRenderFormatAndCodec(_render_format_id(proj, p["format"]), p["codec"]))
+        formats = _render_formats(proj)
+        format_id = _render_format_id_from_formats(formats, p["format"])
+        codec_id = _render_codec_id(proj, format_id, p["codec"], formats)
+        format_success = bool(proj.SetCurrentRenderFormatAndCodec(format_id, codec_id))
+        if not format_success:
+            # Refuse to queue. Continuing here would apply settings, return a real
+            # job id, and report success=True for a job that renders in the
+            # PREVIOUSLY set format/codec — with format_success=False the only
+            # signal, buried in the payload.
+            return _err(
+                f"Could not set render format/codec: {p['format']} / {p['codec']}",
+                code="RENDER_FORMAT_CODEC_REJECTED",
+                category="invalid_input",
+                reason="Resolve rejected the format/codec pair; no render job was queued.",
+                remediation=(
+                    "Check render(action='get_formats') and "
+                    "render(action='get_codecs', params={'format': ...}) for what this "
+                    "machine, license, and plugin set actually support."
+                ),
+                state={
+                    "requested_format": p["format"],
+                    "requested_codec": p["codec"],
+                    "resolved_format_id": format_id,
+                    "resolved_codec_id": codec_id,
+                    "available_codecs": _render_codecs(proj, format_id, formats),
+                },
+            )
     settings_success = bool(proj.SetRenderSettings(settings))
     job_id = proj.AddRenderJob() if settings_success else None
     return {
@@ -15503,6 +15528,186 @@ def _prepare_render_job(proj, p: Dict[str, Any]):
     }
 
 
+# ── Delivery targets ────────────────────────────────────────────────────────
+# Named render intents. One definition emits both the Resolve render settings
+# and the ffprobe-shaped QC spec, so the advanced server can verify a rendered
+# file against the same intent that produced it. See src/utils/delivery_targets.py.
+
+
+def _delivery_target_extras() -> Dict[str, Any]:
+    """User-defined targets from logs/delivery-targets.json; {} if absent/broken."""
+    try:
+        return _delivery_targets.load_user_targets(
+            _delivery_targets.user_targets_path(project_dir)
+        )
+    except Exception as exc:  # pragma: no cover - defensive; loader already tolerates
+        logger.warning("could not load user delivery targets: %s", exc)
+        return {}
+
+
+def _delivery_timeline_fps(proj) -> Optional[float]:
+    """Timeline frame rate for targets that inherit it. None when unavailable.
+
+    Distinct from `_timeline_fps(tl)` above, which takes a timeline and returns a
+    (fps, err) tuple for timecode math.
+    """
+    try:
+        timeline = proj.GetCurrentTimeline()
+        if not timeline:
+            return None
+        value = timeline.GetSetting("timelineFrameRate")
+        return float(value) if value else None
+    except Exception:
+        return None
+
+
+def _resolve_delivery_target_live(proj, p: Dict[str, Any]):
+    """Resolve a named target against the LIVE format/codec matrix.
+
+    Returns (payload, error). Availability is machine/license/plugin dependent,
+    so a target that cannot be satisfied here fails with the actual available
+    lists rather than handing Resolve a name it will reject.
+    """
+    name = p.get("target")
+    if not name:
+        return None, _err(
+            "target is required",
+            code="MISSING_TARGET",
+            category="invalid_input",
+            remediation="Call render(action='list_delivery_targets') to see the available names.",
+        )
+    extras = _delivery_target_extras()
+    target = _delivery_targets.resolve_target(name, p.get("overrides"), extra_targets=extras)
+    if target is None:
+        return None, _err(
+            f"Unknown delivery target: {name}",
+            code="UNKNOWN_DELIVERY_TARGET",
+            category="invalid_input",
+            remediation="Call render(action='list_delivery_targets') to see the available names.",
+            state={"known_targets": sorted(_delivery_targets.list_targets(extras))},
+        )
+
+    formats = _render_formats(proj)
+    format_id = _delivery_targets.select_available(target.format_candidates, formats)
+    if not format_id:
+        return None, _err(
+            f"Delivery target '{target.id}' needs a render format this machine does not expose",
+            code="DELIVERY_TARGET_FORMAT_UNAVAILABLE",
+            category="unsupported",
+            reason="Render format availability depends on the Resolve version, license, and installed IO plugins.",
+            remediation="Check render(action='get_formats'); a codec plugin may need installing, or Resolve restarting.",
+            state={"target": target.id, "tried": list(target.format_candidates), "available_formats": formats},
+        )
+
+    codecs = _render_codecs(proj, format_id, formats)
+    codec_id = _delivery_targets.select_available(target.codec_candidates, codecs)
+    if not codec_id:
+        return None, _err(
+            f"Delivery target '{target.id}' needs a codec this machine does not expose for {format_id}",
+            code="DELIVERY_TARGET_CODEC_UNAVAILABLE",
+            category="unsupported",
+            reason="Codec availability depends on the Resolve version, license, and installed IO plugins.",
+            remediation="Check render(action='get_codecs', params={'format': ...}); a codec plugin may need installing, or Resolve restarting.",
+            state={
+                "target": target.id,
+                "format_id": format_id,
+                "tried": list(target.codec_candidates),
+                "available_codecs": codecs,
+            },
+        )
+
+    fps = _delivery_timeline_fps(proj)
+    qc_spec = _delivery_targets.to_qc_spec(target, timeline_fps=fps)
+    return (
+        {
+            "target": target.id,
+            "label": target.label,
+            "tier": target.tier,
+            "format_id": format_id,
+            "codec_id": codec_id,
+            "timeline_fps": fps,
+            "settings": _delivery_targets.to_render_settings(target, timeline_fps=fps),
+            "qc_spec": qc_spec,
+            "qc_note": (
+                None
+                if qc_spec
+                else "This target renders an image sequence; deliverable_qc probes a single file, so it has no QC spec."
+            ),
+            "notes": list(target.notes),
+        },
+        None,
+    )
+
+
+def _list_delivery_targets(proj, p: Dict[str, Any]):
+    tier = p.get("tier")
+    if tier is not None and tier not in _delivery_targets.TIERS:
+        return _err(
+            f"Unknown tier: {tier}",
+            code="UNKNOWN_DELIVERY_TIER",
+            category="invalid_input",
+            state={"known_tiers": list(_delivery_targets.TIERS)},
+        )
+    extras = _delivery_target_extras()
+    listing = _delivery_targets.list_targets(extras, tier=tier)
+
+    if p.get("check_availability"):
+        # Resolve every target against the live matrix so the caller sees what
+        # this machine/license can actually render, not just what ships.
+        formats = _render_formats(proj)
+        codec_cache: Dict[str, Any] = {}
+        for target_id, entry in listing.items():
+            target = _delivery_targets.resolve_target(target_id, extra_targets=extras)
+            format_id = _delivery_targets.select_available(target.format_candidates, formats)
+            entry["available"] = False
+            entry["format_id"] = format_id
+            entry["codec_id"] = None
+            if not format_id:
+                entry["unavailable_reason"] = "format not exposed by this Resolve install"
+                continue
+            if format_id not in codec_cache:
+                codec_cache[format_id] = _render_codecs(proj, format_id, formats)
+            codec_id = _delivery_targets.select_available(target.codec_candidates, codec_cache[format_id])
+            entry["codec_id"] = codec_id
+            if not codec_id:
+                entry["unavailable_reason"] = f"no matching codec for format '{format_id}'"
+                continue
+            entry["available"] = True
+
+    return _ok(
+        targets=listing,
+        schema_version=_delivery_targets.SCHEMA_VERSION,
+        tiers=list(_delivery_targets.TIERS),
+        availability_checked=bool(p.get("check_availability")),
+    )
+
+
+def _prepare_delivery_job(proj, p: Dict[str, Any]):
+    """Resolve a named target, then queue a render job for it.
+
+    Target settings are the base; anything in `settings` wins, so a caller can
+    pin TargetDir/CustomName (or override a dimension) without restating the target.
+    """
+    resolved, err = _resolve_delivery_target_live(proj, p)
+    if err:
+        return err
+    settings = dict(resolved["settings"])
+    settings.update(p.get("settings") or {})
+    prepared = _prepare_render_job(
+        proj,
+        {
+            **{k: v for k, v in p.items() if k not in ("target", "overrides", "settings")},
+            "settings": settings,
+            "format": resolved["format_id"],
+            "codec": resolved["codec_id"],
+        },
+    )
+    if isinstance(prepared, dict) and not prepared.get("error"):
+        prepared["delivery_target"] = resolved["target"]
+        prepared["qc_spec"] = resolved["qc_spec"]
+    return prepared
+
+
 def _render_job_lifecycle_probe(proj, p: Dict[str, Any]):
     prepared = _prepare_render_job(proj, {**p, "dry_run": False, "require_temp_target": True})
     if prepared.get("error") or not prepared.get("success"):
@@ -15610,6 +15815,16 @@ def render(action: str, params: Optional[Dict[str, Any]] = None) -> Dict[str, An
       quick_export_capabilities() -> {presets, safe_params, guards}
       safe_quick_export(preset, target_dir?|params?, custom_name?, dry_run?, allow_render?) -> {success, status}
       export_render_boundary_report(include_matrix?, max_pairs?, include_quick_export?) -> {capabilities, settings, matrix?}
+      list_delivery_targets(tier?, check_availability?) -> {targets, tiers, schema_version}
+      resolve_delivery_target(target, overrides?) -> {format_id, codec_id, settings, qc_spec}
+      prepare_delivery_job(target, target_dir, overrides?, settings?, custom_name?, dry_run?) -> {success, job_id, qc_spec}
+
+    Delivery targets are named render intents (`prores422hq_master`, `youtube`,
+    `tiktok`, ...). One definition emits both the Resolve render settings and an
+    ffprobe-shaped QC spec, so the advanced server's `deliverable_qc` can verify a
+    rendered file against the same intent that produced it. Format/codec are
+    resolved against the live matrix, so an intent unavailable on this
+    machine/license fails with the actual available lists.
     """
     p = params or {}
     _, proj, err = _check()
@@ -15644,14 +15859,48 @@ def render(action: str, params: Optional[Dict[str, Any]] = None) -> Dict[str, An
         return {"codecs": _render_codecs(proj, p["format"])}
     elif action == "get_format_and_codec":
         return _ser(proj.GetCurrentRenderFormatAndCodec())
+    elif action == "list_delivery_targets":
+        return _list_delivery_targets(proj, p)
+    elif action == "resolve_delivery_target":
+        _resolved, _target_err = _resolve_delivery_target_live(proj, p)
+        return _target_err if _target_err else _ok(**_resolved)
+    elif action == "prepare_delivery_job":
+        return _prepare_delivery_job(proj, p)
     elif action == "set_format_and_codec":
-        return {"success": bool(proj.SetCurrentRenderFormatAndCodec(_render_format_id(proj, p["format"]), p["codec"]))}
+        _formats = _render_formats(proj)
+        _format_id = _render_format_id_from_formats(_formats, p["format"])
+        _codec_id = _render_codec_id(proj, _format_id, p["codec"], _formats)
+        if not proj.SetCurrentRenderFormatAndCodec(_format_id, _codec_id):
+            # Availability is machine/license/plugin dependent, so name what this
+            # install actually exposes instead of just reporting False.
+            return _err(
+                f"Could not set render format/codec: {p['format']} / {p['codec']}",
+                code="RENDER_FORMAT_CODEC_REJECTED",
+                category="invalid_input",
+                reason="Resolve rejected the format/codec pair.",
+                remediation=(
+                    "Check render(action='get_formats') and "
+                    "render(action='get_codecs', params={'format': ...}). If the codec comes "
+                    "from an IO plugin, confirm it is installed and Resolve has been restarted."
+                ),
+                state={
+                    "requested_format": p["format"],
+                    "requested_codec": p["codec"],
+                    "resolved_format_id": _format_id,
+                    "resolved_codec_id": _codec_id,
+                    "available_codecs": _render_codecs(proj, _format_id, _formats),
+                },
+            )
+        return {"success": True, "format_id": _format_id, "codec_id": _codec_id}
     elif action == "get_mode":
         return {"mode": proj.GetCurrentRenderMode()}
     elif action == "set_mode":
         return {"success": bool(proj.SetCurrentRenderMode(p["mode"]))}
     elif action == "get_resolutions":
-        return {"resolutions": _ser(proj.GetRenderResolutions(_render_format_id(proj, p["format"]), p["codec"]))}
+        _formats = _render_formats(proj)
+        _format_id = _render_format_id_from_formats(_formats, p["format"])
+        _codec_id = _render_codec_id(proj, _format_id, p["codec"], _formats)
+        return {"resolutions": _ser(proj.GetRenderResolutions(_format_id, _codec_id))}
     elif action == "get_settings":
         missing = _requires_method(proj, "GetRenderSettings", "unknown")
         if missing:

package/src/utils/api_truth.py

@@ -593,6 +593,49 @@ API_TRUTH: List[Dict[str, Any]] = [
         "issue": 90,
         "mitigation": ["_ensure_lut_in_master"],
     },
+    {
+        "symbol": "Project.GetRenderCodecs",
+        "object": "Project",
+        "signature": "(renderFormat) -> {codec description: codec name}",
+        "reality": "Returns {description: id} — the human-readable description is "
+                   "the KEY and the id Resolve actually accepts is the VALUE. "
+                   "SetCurrentRenderFormatAndCodec, GetRenderCodecs and "
+                   "GetRenderResolutions all require the id, so passing the "
+                   "description a user sees in the Deliver page is rejected. "
+                   "Verified live on Studio 19.1.3.7: ('mov', 'Apple ProRes 422 "
+                   "HQ') -> False while ('mov', 'ProRes422HQ') -> True, and "
+                   "('mp4', 'H.264') -> False while ('mp4', 'H264') -> True. It "
+                   "affects every family, not only the ones whose id differs "
+                   "obviously. Mirrors the same trap in GetRenderFormats, which "
+                   "returns {format: extension}.",
+        "recommended": "Normalize both arguments through the live maps before "
+                       "calling: src.utils.render_ids.render_format_id_from_formats "
+                       "and render_codec_id_from_codecs accept a description or an "
+                       "id and return the id.",
+        "tags": ["render", "deliver", "silent-failure", "id-vs-label"],
+        "submit": "bug",
+        "issue": 59,
+        "mitigation": ["_render_format_id", "_render_codec_id"],
+    },
+    {
+        "symbol": "Project.SetCurrentRenderFormatAndCodec",
+        "object": "Project",
+        "signature": "(format, codec) -> bool",
+        "reality": "Some render formats expose NO codecs at all — "
+                   "GetRenderCodecs('wav') and GetRenderCodecs('gif') both return "
+                   "{} on Studio 19.1.3.7 — and the call then rejects every codec "
+                   "value, including the empty string, the format id itself, and "
+                   "any plausible name ('Linear PCM'). There is no documented way "
+                   "to select such a format through this API, so an audio-only WAV "
+                   "deliverable is not expressible in scripting.",
+        "recommended": "Check GetRenderCodecs(format) first; when it is empty, "
+                       "treat the format as unreachable through this API rather "
+                       "than guessing a codec value. Render audio-only via "
+                       "ExportVideo=False on a format that does expose codecs, or "
+                       "drive it from a saved render preset.",
+        "tags": ["render", "deliver", "audio", "unsupported"],
+        "submit": "missing",
+    },
 ]