취소할 수 없는 것, 그리고 아바타가 아닌 재료

    async def cancel(self, id):
        task = await self.studio.io("get", id, "task")
        if task["state"] in {"queued", "preparing"}:
            return await self.studio.io("update", id, expected=task["version"], state="cancelled", phase="Cancelled before submission")
        if task["state"] in {"submitting", "uncertain"}:
            raise StudioError("Reconcile this task first; its upstream outcome is not known.", 409)
        if task["state"] != "running":
            raise StudioError("This task is no longer cancellable.", 409)
        if is_clip(task):
            raise StudioError("A submitted clip cannot be cancelled: the vendor finishes it, charges it, and it is saved.", 409)
        await self.studio.upstream.json(self.studio.upstream.settings.ember, f"/api/v1/api-generators/jobs/{task['job_id']}/cancel", method="POST", body={})
        return {"requested": True, "message": "Cancellation requested. A metered request already sent may still be billed by the provider."}

    async def reconcile_clip(self, task):
        """Ask Ember what became of this clip: by its id when the submit was
        acknowledged, else by the attempt's request id. Nothing is re-sent."""
        io, upstream, id = self.studio.io, self.studio.upstream, task["id"]
        record = None
        if task.get("job_id"):
            try:
                record = await upstream.video_clip(task["job_id"])
            except StudioError as exc:
                if exc.status != 404:
                    raise
        if record is None:
            attempt = {**task, "attempts": task["attempts"][:-1] if task.get("job_id") and task["attempts"] else task["attempts"]}
            record = await upstream.video_request(clip_request_id(attempt))
        if record is None:
            await io("update", id, phase="Reconcile before retry", reconciliation={"checked_at": now(), "matches": []}, error="Ember has no clip for this task, so nothing was submitted to the vendor. A retry makes and pays for a new clip.")
        elif record["state"] == "done":
            await io("update", id, state="copying", phase="Saving the clip", job_id=record["id"], upstream_result=record, error=None)
        elif record["state"] in CLIP_PENDING:
            await io("update", id, state="running", phase=record.get("phase") or "Generating", job_id=record["id"], error=None)
        elif record["state"] == "failed":
            await io("update", id, state="failed", phase="Generation stopped", job_id=record["id"], error=f"{(record.get('error') or {}).get('message') or 'The vendor could not generate this clip.'} Nothing was charged.")
        else:
            await io("update", id, phase="Reconcile before retry", job_id=record["id"], reconciliation={"checked_at": now(), "matches": [record["id"]]}, error=f"{(record.get('error') or {}).get('message') or 'Ember holds this clip as uncertain.'} Resolve it in Ember's Pro Video tab first.")
        return await io("get", id, "task")

    def save_clip(self, data: bytes, *, label: str, subjects: list[str], width: int | None, height: int | None, duration: float | None, poster: bytes | None = None, references: list[str] | None = None, **metadata) -> dict:
        """A generated video clip, kept like any original: native bytes,
        content-addressed, with the lineage of the references it was made from.
        Its poster frame is a regenerable derivative beside the thumbnails."""
        if len(data) < 12 or data[4:8] != b"ftyp":
            raise StudioError("The clip is not an MP4 file.")
        digest = hashlib.sha256(data).hexdigest()
        filename = f"{digest}.mp4"
        self.write_original(filename, data, digest)
        if poster:
            target = self.root / "thumbnails" / f"{digest}.poster.jpg"
            if not target.exists():
                temporary = target.with_name(f".{identity()}.tmp")
                temporary.write_bytes(poster)
                os.replace(temporary, target)
        return self.add("asset", label=label[:200], subjects=sorted(set(subjects)), origin="generated", references=list(dict.fromkeys(references or [])), filename=filename, sha256=digest, width=width, height=height, duration=duration, mime="video/mp4", media="video", bytes=len(data), archived=False, **metadata)