@morshoto/framekit 0.1.14 → 0.1.17
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist-package/adapters/final-cut/typescript/src/background-materialization.js +28 -0
- package/dist-package/adapters/final-cut/typescript/src/canonical.js +144 -35
- package/dist-package/adapters/final-cut/typescript/src/connection.js +8 -5
- package/dist-package/adapters/final-cut/typescript/src/disposable-native.js +36 -7
- package/dist-package/adapters/final-cut/typescript/src/fcpxml.js +21 -7
- package/dist-package/adapters/final-cut/typescript/src/index.js +2 -0
- package/dist-package/adapters/final-cut/typescript/src/live.js +56 -1
- package/dist-package/adapters/final-cut/typescript/src/native.js +311 -20
- package/dist-package/adapters/final-cut/typescript/src/pasteboard-snapshot.js +312 -0
- package/dist-package/adapters/final-cut/typescript/src/publisher.js +68 -8
- package/dist-package/adapters/final-cut/typescript/src/sqlite-wal-observation.js +263 -0
- package/dist-package/adapters/final-cut/typescript/src/timeline-ir-fcpxml.js +179 -25
- package/dist-package/adapters/headless/typescript/src/ffmpeg-media-probe.js +62 -0
- package/dist-package/adapters/headless/typescript/src/ffmpeg-renderer.js +551 -0
- package/dist-package/adapters/headless/typescript/src/ffmpeg-verifier.js +181 -0
- package/dist-package/adapters/headless/typescript/src/index.js +3 -0
- package/dist-package/apps/mcp-server/src/headless-projects.js +370 -0
- package/dist-package/apps/mcp-server/src/headless-sessions.js +3 -0
- package/dist-package/apps/mcp-server/src/main.js +28 -4
- package/dist-package/apps/mcp-server/src/materialization-jobs.js +233 -4
- package/dist-package/apps/mcp-server/src/readback-policy.js +26 -0
- package/dist-package/apps/mcp-server/src/routing.js +134 -5
- package/dist-package/apps/mcp-server/src/server.js +311 -34
- package/dist-package/packages/runtime/src/application/local-media.js +157 -0
- package/dist-package/packages/runtime/src/application/media-analysis-service.js +347 -27
- package/dist-package/packages/runtime/src/application/project-store.js +234 -0
- package/dist-package/packages/runtime/src/application/project-transactions.js +227 -0
- package/dist-package/packages/runtime/src/application/semantic-media-index-store.js +86 -0
- package/dist-package/packages/runtime/src/index.js +7 -0
- package/dist-package/packages/runtime/src/planning/rough-cut.js +103 -7
- package/dist-package/packages/runtime/src/render/render-and-verify.js +126 -0
- package/dist-package/packages/runtime/src/render/render-contract.js +146 -0
- package/dist-package/packages/runtime/src/runtime.js +5 -2
- package/dist-package/packages/runtime/src/timeline/editing-session.js +277 -9
- package/dist-package/packages/runtime/src/timeline/fast-observation.js +141 -0
- package/package.json +2 -1
|
@@ -6,8 +6,10 @@ export function planRoughCut(entries, revision, request) {
|
|
|
6
6
|
}
|
|
7
7
|
const candidates = entries
|
|
8
8
|
.filter((entry) => entry.sourceIdentity.mediaKind !== "audio")
|
|
9
|
-
.flatMap((entry) =>
|
|
9
|
+
.flatMap((entry) => candidatesForEntry(entry, request))
|
|
10
10
|
.sort((left, right) => {
|
|
11
|
+
if (left.queryMatches !== right.queryMatches)
|
|
12
|
+
return right.queryMatches - left.queryMatches;
|
|
11
13
|
const mediaOrder = left.entry.sourceIdentity.mediaId.localeCompare(right.entry.sourceIdentity.mediaId);
|
|
12
14
|
if (mediaOrder !== 0)
|
|
13
15
|
return mediaOrder;
|
|
@@ -15,14 +17,14 @@ export function planRoughCut(entries, revision, request) {
|
|
|
15
17
|
return left.range.start - right.range.start;
|
|
16
18
|
return left.range.end - right.range.end;
|
|
17
19
|
});
|
|
18
|
-
const shots = candidates.slice(0, maxShots).map(({ entry, range }, index) => shotFor(entry, range, request, index + 1));
|
|
20
|
+
const shots = candidates.slice(0, maxShots).map(({ entry, range, evidence }, index) => shotFor(entry, range, request, index + 1, evidence));
|
|
19
21
|
const excludedAudioMediaIds = entries
|
|
20
22
|
.filter((entry) => entry.sourceIdentity.mediaKind === "audio" && entry.semantic.usableRanges.length > 0)
|
|
21
23
|
.map((entry) => entry.sourceIdentity.mediaId);
|
|
22
24
|
const warnings = excludedAudioMediaIds.length > 0
|
|
23
25
|
? [`Excluded audio-only media from rough-cut shot candidates: ${excludedAudioMediaIds.join(", ")}`]
|
|
24
26
|
: entries.length > 0 && candidates.length === 0
|
|
25
|
-
? ["No matching media has an explicitly analyzed usable range"]
|
|
27
|
+
? ["No matching media has an explicitly analyzed usable speech or usable range"]
|
|
26
28
|
: [];
|
|
27
29
|
return {
|
|
28
30
|
planner: { id: "framekit.rough-cut", version: 1 },
|
|
@@ -32,7 +34,93 @@ export function planRoughCut(entries, revision, request) {
|
|
|
32
34
|
warnings,
|
|
33
35
|
};
|
|
34
36
|
}
|
|
35
|
-
function
|
|
37
|
+
function candidatesForEntry(entry, request) {
|
|
38
|
+
const speechCandidates = speechCandidatesForEntry(entry, request);
|
|
39
|
+
if (speechCandidates.length > 0)
|
|
40
|
+
return speechCandidates;
|
|
41
|
+
return entry.semantic.usableRanges.map((range) => ({
|
|
42
|
+
entry,
|
|
43
|
+
range: structuredClone(range),
|
|
44
|
+
queryMatches: 0,
|
|
45
|
+
}));
|
|
46
|
+
}
|
|
47
|
+
function speechCandidatesForEntry(entry, request) {
|
|
48
|
+
const speech = entry.speech;
|
|
49
|
+
if (!speech)
|
|
50
|
+
return [];
|
|
51
|
+
const speechSegments = speech.vadSegments?.filter((segment) => segment.kind === "speech") ?? [];
|
|
52
|
+
const ranges = speechSegments.length > 0
|
|
53
|
+
? speechSegments.map((segment) => ({ range: { start: segment.start, end: segment.end }, vad: segment }))
|
|
54
|
+
: wordRanges(speech.words).map((range) => ({ range }));
|
|
55
|
+
return ranges.flatMap(({ range, vad }) => clipToUsableRanges(entry, range).map((clipped) => {
|
|
56
|
+
const words = speech.words.filter((word) => word.end > clipped.start && word.start < clipped.end);
|
|
57
|
+
const transcript = words.filter((word) => word.filler !== true).map((word) => word.text).join(" ").trim();
|
|
58
|
+
const queryMatches = queryMatchCount(request.query, words);
|
|
59
|
+
const averageWordConfidence = words.length === 0
|
|
60
|
+
? 0
|
|
61
|
+
: words.reduce((sum, word) => sum + word.confidence, 0) / words.length;
|
|
62
|
+
return {
|
|
63
|
+
entry,
|
|
64
|
+
range: clipped,
|
|
65
|
+
queryMatches,
|
|
66
|
+
evidence: {
|
|
67
|
+
kind: "speech",
|
|
68
|
+
transcript,
|
|
69
|
+
wordCount: words.length,
|
|
70
|
+
averageWordConfidence,
|
|
71
|
+
...(vad ? {
|
|
72
|
+
vad: {
|
|
73
|
+
kind: vad.kind,
|
|
74
|
+
...(vad.confidence !== undefined ? { confidence: vad.confidence } : {}),
|
|
75
|
+
},
|
|
76
|
+
} : {}),
|
|
77
|
+
...(entry.audio ? {
|
|
78
|
+
audio: {
|
|
79
|
+
...(Number.isFinite(entry.audio.integratedLufs) ? { integratedLufs: entry.audio.integratedLufs } : {}),
|
|
80
|
+
...(Number.isFinite(entry.audio.truePeakDb) ? { truePeakDb: entry.audio.truePeakDb } : {}),
|
|
81
|
+
...(Number.isFinite(entry.audio.silenceMs) ? { silenceMs: entry.audio.silenceMs } : {}),
|
|
82
|
+
},
|
|
83
|
+
} : {}),
|
|
84
|
+
},
|
|
85
|
+
};
|
|
86
|
+
}));
|
|
87
|
+
}
|
|
88
|
+
function wordRanges(words) {
|
|
89
|
+
const validWords = words
|
|
90
|
+
.filter((word) => Number.isFinite(word.start) && Number.isFinite(word.end) && word.end > word.start)
|
|
91
|
+
.sort((left, right) => left.start - right.start || left.end - right.end);
|
|
92
|
+
const ranges = [];
|
|
93
|
+
for (const word of validWords) {
|
|
94
|
+
const current = ranges[ranges.length - 1];
|
|
95
|
+
if (current && word.start - current.end <= 0.8) {
|
|
96
|
+
current.end = Math.max(current.end, word.end);
|
|
97
|
+
}
|
|
98
|
+
else {
|
|
99
|
+
ranges.push({ start: word.start, end: word.end });
|
|
100
|
+
}
|
|
101
|
+
}
|
|
102
|
+
return ranges;
|
|
103
|
+
}
|
|
104
|
+
function clipToUsableRanges(entry, range) {
|
|
105
|
+
const bounds = entry.semantic.usableRanges.length > 0 ? entry.semantic.usableRanges : [range];
|
|
106
|
+
const duration = entry.sourceIdentity.duration;
|
|
107
|
+
return bounds.flatMap((bound) => {
|
|
108
|
+
const start = Math.max(range.start, bound.start, 0);
|
|
109
|
+
const end = Math.min(range.end, bound.end, duration ?? Number.POSITIVE_INFINITY);
|
|
110
|
+
return end > start ? [{ start, end }] : [];
|
|
111
|
+
});
|
|
112
|
+
}
|
|
113
|
+
function queryMatchCount(query, words) {
|
|
114
|
+
const terms = tokenize(query);
|
|
115
|
+
if (terms.length === 0)
|
|
116
|
+
return 0;
|
|
117
|
+
const transcript = words.map((word) => word.text.toLowerCase());
|
|
118
|
+
return terms.filter((term) => transcript.some((word) => word.includes(term))).length;
|
|
119
|
+
}
|
|
120
|
+
function tokenize(query) {
|
|
121
|
+
return query?.trim().toLowerCase().split(/\s+/u).filter(Boolean) ?? [];
|
|
122
|
+
}
|
|
123
|
+
function shotFor(entry, range, request, order, evidence) {
|
|
36
124
|
const matchedProperties = [
|
|
37
125
|
...(request.query ? [`query:${request.query}`] : []),
|
|
38
126
|
...(request.subject ? [`subject:${request.subject}`] : []),
|
|
@@ -54,18 +142,26 @@ function shotFor(entry, range, request, order) {
|
|
|
54
142
|
? activeAnnotations.flatMap(({ query, tags }) => tags.filter((tag) => tag.value.toLowerCase() === query.trim().toLowerCase()))
|
|
55
143
|
: semanticAnnotations.flatMap(({ tags }) => tags);
|
|
56
144
|
const confidence = Math.max(0, ...confidenceTags.map((tag) => tag.confidence));
|
|
145
|
+
const speechConfidence = evidence?.averageWordConfidence ?? 0;
|
|
146
|
+
const combinedConfidence = evidence ? Math.max(confidence, speechConfidence) : confidence;
|
|
57
147
|
const reason = matchedProperties.length > 0
|
|
58
148
|
? `matches ${matchedProperties.map((property) => {
|
|
59
149
|
const [kind, ...value] = property.split(":");
|
|
60
150
|
return `${kind} "${value.join(":")}"`;
|
|
61
151
|
}).join(", ")}`
|
|
62
|
-
:
|
|
152
|
+
: evidence
|
|
153
|
+
? `contains speech "${evidence.transcript || "(no transcript text)"}" in a VAD speech interval`
|
|
154
|
+
: "has an explicitly analyzed usable range";
|
|
155
|
+
const speechDetails = evidence
|
|
156
|
+
? ` Speech evidence covers ${evidence.wordCount} word${evidence.wordCount === 1 ? "" : "s"} ("${evidence.transcript || "no transcript text"}") with average confidence ${evidence.averageWordConfidence.toFixed(2)}.`
|
|
157
|
+
: "";
|
|
63
158
|
return {
|
|
64
159
|
order,
|
|
65
160
|
sourceIdentity: structuredClone(entry.sourceIdentity),
|
|
66
161
|
range: structuredClone(range),
|
|
67
|
-
confidence,
|
|
162
|
+
confidence: combinedConfidence,
|
|
68
163
|
matchedProperties,
|
|
69
|
-
rationale: `Selected ${entry.sourceIdentity.mediaId} because it ${reason}
|
|
164
|
+
rationale: `Selected ${entry.sourceIdentity.mediaId} because it ${reason}.${speechDetails}`,
|
|
165
|
+
...(evidence ? { evidence } : {}),
|
|
70
166
|
};
|
|
71
167
|
}
|
|
@@ -0,0 +1,126 @@
|
|
|
1
|
+
import { createFramekitRenderPlan, } from "./render-contract.js";
|
|
2
|
+
/**
|
|
3
|
+
* Owns the closed loop: immutable plan, provider render, then an independent
|
|
4
|
+
* artifact verification gate. Provider success alone never yields `passed`.
|
|
5
|
+
*/
|
|
6
|
+
export async function renderAndVerifyFramekitProject(request, provider, verifier, options = {}) {
|
|
7
|
+
let plan;
|
|
8
|
+
try {
|
|
9
|
+
const capabilities = options.capabilities ?? provider.capabilities(request);
|
|
10
|
+
plan = createFramekitRenderPlan(request, capabilities);
|
|
11
|
+
}
|
|
12
|
+
catch (error) {
|
|
13
|
+
return failureResult(error, options.isUnavailable);
|
|
14
|
+
}
|
|
15
|
+
let render;
|
|
16
|
+
try {
|
|
17
|
+
render = await provider.render(plan);
|
|
18
|
+
}
|
|
19
|
+
catch (error) {
|
|
20
|
+
return { ...failureResult(error, options.isUnavailable), plan };
|
|
21
|
+
}
|
|
22
|
+
const binding = checkRenderBinding(plan, render);
|
|
23
|
+
if (!binding.passed) {
|
|
24
|
+
return {
|
|
25
|
+
status: "failed",
|
|
26
|
+
plan,
|
|
27
|
+
render,
|
|
28
|
+
verification: { status: "failed", checks: [binding] },
|
|
29
|
+
};
|
|
30
|
+
}
|
|
31
|
+
let verification;
|
|
32
|
+
try {
|
|
33
|
+
verification = await verifier.verify(plan, render);
|
|
34
|
+
}
|
|
35
|
+
catch (error) {
|
|
36
|
+
return {
|
|
37
|
+
status: "failed",
|
|
38
|
+
plan,
|
|
39
|
+
render,
|
|
40
|
+
verification: {
|
|
41
|
+
status: "failed",
|
|
42
|
+
checks: [],
|
|
43
|
+
error: errorDetails(error),
|
|
44
|
+
},
|
|
45
|
+
};
|
|
46
|
+
}
|
|
47
|
+
if (verification.status !== "passed" || !verification.artifact) {
|
|
48
|
+
if (verification.status === "passed" && !verification.artifact) {
|
|
49
|
+
const invalidVerification = {
|
|
50
|
+
...verification,
|
|
51
|
+
status: "failed",
|
|
52
|
+
checks: [...verification.checks, {
|
|
53
|
+
name: "artifact",
|
|
54
|
+
passed: false,
|
|
55
|
+
detail: "a passed render verification must include artifact metadata",
|
|
56
|
+
}],
|
|
57
|
+
error: { code: "RENDER_VERIFICATION_CONTRACT_INVALID", message: "passed verification omitted artifact metadata" },
|
|
58
|
+
};
|
|
59
|
+
return { status: "failed", plan, render, verification: invalidVerification };
|
|
60
|
+
}
|
|
61
|
+
return { status: verification.status, plan, render, verification };
|
|
62
|
+
}
|
|
63
|
+
const semanticChecks = await Promise.all((options.semanticAssertions ?? []).map(async (assertion) => {
|
|
64
|
+
try {
|
|
65
|
+
const value = await assertion.verify({ plan, result: render, artifact: verification.artifact });
|
|
66
|
+
return typeof value === "boolean"
|
|
67
|
+
? { name: assertion.name, passed: value, detail: value ? "semantic assertion passed" : "semantic assertion failed" }
|
|
68
|
+
: { ...value, name: value.name || assertion.name };
|
|
69
|
+
}
|
|
70
|
+
catch (error) {
|
|
71
|
+
return { name: assertion.name, passed: false, detail: errorDetails(error).message };
|
|
72
|
+
}
|
|
73
|
+
}));
|
|
74
|
+
const checks = [...verification.checks, ...semanticChecks];
|
|
75
|
+
const passed = checks.every((check) => check.passed);
|
|
76
|
+
return {
|
|
77
|
+
status: passed ? "passed" : "failed",
|
|
78
|
+
plan,
|
|
79
|
+
render,
|
|
80
|
+
verification: { ...verification, status: passed ? "passed" : "failed", checks },
|
|
81
|
+
};
|
|
82
|
+
}
|
|
83
|
+
function checkRenderBinding(plan, result) {
|
|
84
|
+
const passed = result.contractVersion === plan.contractVersion
|
|
85
|
+
&& sameTarget(plan.target, result.target)
|
|
86
|
+
&& sameRevision(plan.projectRevision, result.projectRevision)
|
|
87
|
+
&& result.renderer.id === plan.renderer.id
|
|
88
|
+
&& result.renderer.version === plan.renderer.version
|
|
89
|
+
&& result.planDigest === plan.planDigest
|
|
90
|
+
&& result.output.path === plan.parameters.outputPath
|
|
91
|
+
&& result.output.format === plan.parameters.format
|
|
92
|
+
&& result.verificationRequired === true;
|
|
93
|
+
return {
|
|
94
|
+
name: "render-binding",
|
|
95
|
+
passed,
|
|
96
|
+
detail: passed
|
|
97
|
+
? "render output is bound to the requested target, revision, renderer, plan, and format"
|
|
98
|
+
: "render output provenance does not match the requested plan",
|
|
99
|
+
expected: {
|
|
100
|
+
target: plan.target,
|
|
101
|
+
projectRevision: plan.projectRevision,
|
|
102
|
+
renderer: plan.renderer,
|
|
103
|
+
planDigest: plan.planDigest,
|
|
104
|
+
output: plan.parameters,
|
|
105
|
+
},
|
|
106
|
+
observed: result,
|
|
107
|
+
};
|
|
108
|
+
}
|
|
109
|
+
function failureResult(error, isUnavailable) {
|
|
110
|
+
const details = errorDetails(error);
|
|
111
|
+
const unavailable = isUnavailable?.(error) ?? /UNAVAILABLE|CAPABILITY_UNAVAILABLE|unsupported/i.test(`${details.code} ${details.message}`);
|
|
112
|
+
return { status: unavailable ? "unavailable" : "failed", error: details };
|
|
113
|
+
}
|
|
114
|
+
function errorDetails(error) {
|
|
115
|
+
if (error instanceof Error) {
|
|
116
|
+
const match = /^([A-Z][A-Z0-9_]+):\s*(.*)$/.exec(error.message);
|
|
117
|
+
return { code: match?.[1] ?? error.name, message: match?.[2] ?? error.message };
|
|
118
|
+
}
|
|
119
|
+
return { code: "RENDER_ORCHESTRATION_FAILED", message: String(error) };
|
|
120
|
+
}
|
|
121
|
+
function sameTarget(left, right) {
|
|
122
|
+
return left.projectId === right.projectId && left.sequenceId === right.sequenceId;
|
|
123
|
+
}
|
|
124
|
+
function sameRevision(left, right) {
|
|
125
|
+
return left.id === right.id && left.sequence === right.sequence && left.timestamp === right.timestamp;
|
|
126
|
+
}
|
|
@@ -0,0 +1,146 @@
|
|
|
1
|
+
import { createHash } from "node:crypto";
|
|
2
|
+
import { validateTimelineIr } from "../timeline/editing-session.js";
|
|
3
|
+
import { parseRational } from "../timeline/rational-time.js";
|
|
4
|
+
export const FRAMEKIT_RENDER_CONTRACT_VERSION = 1;
|
|
5
|
+
export class FramekitRenderContractError extends Error {
|
|
6
|
+
code;
|
|
7
|
+
constructor(code, message) {
|
|
8
|
+
super(`${code}: ${message}`);
|
|
9
|
+
this.code = code;
|
|
10
|
+
this.name = "FramekitRenderContractError";
|
|
11
|
+
}
|
|
12
|
+
}
|
|
13
|
+
export function createFramekitRenderRequest(input) {
|
|
14
|
+
validateTimelineIr(input.timeline);
|
|
15
|
+
if (!text(input.target?.projectId) || !text(input.target?.sequenceId)) {
|
|
16
|
+
throw new FramekitRenderContractError("RENDER_INVALID_REQUEST", "target requires projectId and sequenceId");
|
|
17
|
+
}
|
|
18
|
+
if (input.target.projectId !== input.timeline.project.id || input.target.sequenceId !== input.timeline.sequence.id) {
|
|
19
|
+
throw new FramekitRenderContractError("RENDER_INVALID_REQUEST", "target does not match the Timeline IR");
|
|
20
|
+
}
|
|
21
|
+
if (input.revision && !sameRevision(input.revision, input.timeline.revision)) {
|
|
22
|
+
throw new FramekitRenderContractError("RENDER_STALE_REVISION", "requested revision does not match the Timeline IR");
|
|
23
|
+
}
|
|
24
|
+
validateParameters(input.parameters);
|
|
25
|
+
const requiredFeatures = [...new Set([
|
|
26
|
+
...inferFramekitRenderFeatures(input.timeline),
|
|
27
|
+
...(input.requiredFeatures ?? []),
|
|
28
|
+
])];
|
|
29
|
+
for (const feature of requiredFeatures) {
|
|
30
|
+
if (!RENDER_FEATURES.includes(feature))
|
|
31
|
+
throw new FramekitRenderContractError("RENDER_INVALID_REQUEST", `unsupported required feature: ${feature}`);
|
|
32
|
+
}
|
|
33
|
+
return deepFreeze({
|
|
34
|
+
contractVersion: FRAMEKIT_RENDER_CONTRACT_VERSION,
|
|
35
|
+
target: structuredClone(input.target),
|
|
36
|
+
projectRevision: structuredClone(input.timeline.revision),
|
|
37
|
+
timeline: structuredClone(input.timeline),
|
|
38
|
+
parameters: structuredClone(input.parameters),
|
|
39
|
+
requiredFeatures,
|
|
40
|
+
});
|
|
41
|
+
}
|
|
42
|
+
export function inferFramekitRenderFeatures(timeline) {
|
|
43
|
+
const features = ["local-media", "structural-edits"];
|
|
44
|
+
if (timeline.sequence.occurrences.some(({ gainDb }) => gainDb !== undefined))
|
|
45
|
+
features.push("audio-gain");
|
|
46
|
+
if (timeline.sequence.occurrences.some(({ role }) => role === "audio" || role === "music"))
|
|
47
|
+
features.push("audio-mixing");
|
|
48
|
+
if (timeline.sequence.occurrences.some(({ transform }) => transform !== undefined))
|
|
49
|
+
features.push("transform");
|
|
50
|
+
if ((timeline.sequence.titles ?? []).length > 0)
|
|
51
|
+
features.push("titles");
|
|
52
|
+
if ((timeline.sequence.transitions ?? []).some(({ kind }) => kind === "cross-dissolve"))
|
|
53
|
+
features.push("cross-dissolve");
|
|
54
|
+
return features;
|
|
55
|
+
}
|
|
56
|
+
export function createFramekitRenderPlan(request, capabilities) {
|
|
57
|
+
if (!text(capabilities.renderer?.id) || !text(capabilities.renderer?.version)) {
|
|
58
|
+
throw new FramekitRenderContractError("RENDER_INVALID_RESULT", "renderer identity and version are required");
|
|
59
|
+
}
|
|
60
|
+
const unavailable = request.requiredFeatures.filter((feature) => capabilities.features[feature] !== "supported");
|
|
61
|
+
if (unavailable.length > 0) {
|
|
62
|
+
throw new FramekitRenderContractError("RENDER_CAPABILITY_UNAVAILABLE", `required features are not fully supported: ${unavailable.join(", ")}`);
|
|
63
|
+
}
|
|
64
|
+
const planBase = {
|
|
65
|
+
contractVersion: FRAMEKIT_RENDER_CONTRACT_VERSION,
|
|
66
|
+
target: structuredClone(request.target),
|
|
67
|
+
projectRevision: structuredClone(request.projectRevision),
|
|
68
|
+
timeline: structuredClone(request.timeline),
|
|
69
|
+
parameters: structuredClone(request.parameters),
|
|
70
|
+
requiredFeatures: [...request.requiredFeatures],
|
|
71
|
+
renderer: structuredClone(capabilities.renderer),
|
|
72
|
+
capabilities: structuredClone(capabilities),
|
|
73
|
+
};
|
|
74
|
+
const plan = {
|
|
75
|
+
...planBase,
|
|
76
|
+
planDigest: createHash("sha256").update(stableJson(planBase)).digest("hex"),
|
|
77
|
+
};
|
|
78
|
+
return deepFreeze(plan);
|
|
79
|
+
}
|
|
80
|
+
export function createFramekitRenderResult(plan, output) {
|
|
81
|
+
assertPlanIntegrity(plan);
|
|
82
|
+
if (!text(output.path) || output.path !== plan.parameters.outputPath || output.format !== plan.parameters.format) {
|
|
83
|
+
throw new FramekitRenderContractError("RENDER_INVALID_RESULT", "render output must match the explicit request format and path");
|
|
84
|
+
}
|
|
85
|
+
return {
|
|
86
|
+
contractVersion: FRAMEKIT_RENDER_CONTRACT_VERSION,
|
|
87
|
+
status: "rendered",
|
|
88
|
+
target: structuredClone(plan.target),
|
|
89
|
+
projectRevision: structuredClone(plan.projectRevision),
|
|
90
|
+
renderer: structuredClone(plan.renderer),
|
|
91
|
+
planDigest: plan.planDigest,
|
|
92
|
+
output: structuredClone(output),
|
|
93
|
+
verificationRequired: true,
|
|
94
|
+
};
|
|
95
|
+
}
|
|
96
|
+
const RENDER_FEATURES = [
|
|
97
|
+
"local-media",
|
|
98
|
+
"structural-edits",
|
|
99
|
+
"audio-gain",
|
|
100
|
+
"audio-mixing",
|
|
101
|
+
"transform",
|
|
102
|
+
"titles",
|
|
103
|
+
"cross-dissolve",
|
|
104
|
+
];
|
|
105
|
+
function validateParameters(parameters) {
|
|
106
|
+
if (!parameters || typeof parameters !== "object" || !text(parameters.outputPath)) {
|
|
107
|
+
throw new FramekitRenderContractError("RENDER_INVALID_REQUEST", "outputPath is required");
|
|
108
|
+
}
|
|
109
|
+
if (parameters.format !== "mp4" && parameters.format !== "mov") {
|
|
110
|
+
throw new FramekitRenderContractError("RENDER_INVALID_REQUEST", "format must be mp4 or mov");
|
|
111
|
+
}
|
|
112
|
+
if (!Number.isSafeInteger(parameters.width) || parameters.width <= 0 || !Number.isSafeInteger(parameters.height) || parameters.height <= 0) {
|
|
113
|
+
throw new FramekitRenderContractError("RENDER_INVALID_REQUEST", "width and height must be positive safe integers");
|
|
114
|
+
}
|
|
115
|
+
const frameRate = parseRational(parameters.frameRate, "RENDER_INVALID_REQUEST");
|
|
116
|
+
if (frameRate.value <= 0n)
|
|
117
|
+
throw new FramekitRenderContractError("RENDER_INVALID_REQUEST", "frameRate must be positive");
|
|
118
|
+
}
|
|
119
|
+
function sameRevision(left, right) {
|
|
120
|
+
return left.id === right.id && left.sequence === right.sequence && left.timestamp === right.timestamp;
|
|
121
|
+
}
|
|
122
|
+
function text(value) {
|
|
123
|
+
return typeof value === "string" && value.trim().length > 0;
|
|
124
|
+
}
|
|
125
|
+
function stableJson(value) {
|
|
126
|
+
if (value === null || typeof value !== "object")
|
|
127
|
+
return JSON.stringify(value);
|
|
128
|
+
if (Array.isArray(value))
|
|
129
|
+
return `[${value.map(stableJson).join(",")}]`;
|
|
130
|
+
const entries = Object.entries(value).filter(([, child]) => child !== undefined).sort(([left], [right]) => left.localeCompare(right));
|
|
131
|
+
return `{${entries.map(([key, child]) => `${JSON.stringify(key)}:${stableJson(child)}`).join(",")}}`;
|
|
132
|
+
}
|
|
133
|
+
function assertPlanIntegrity(plan) {
|
|
134
|
+
const { planDigest, ...planBase } = plan;
|
|
135
|
+
const actualDigest = createHash("sha256").update(stableJson(planBase)).digest("hex");
|
|
136
|
+
if (actualDigest !== planDigest) {
|
|
137
|
+
throw new FramekitRenderContractError("RENDER_INVALID_RESULT", "render plan was modified after it was created");
|
|
138
|
+
}
|
|
139
|
+
}
|
|
140
|
+
function deepFreeze(value) {
|
|
141
|
+
if (value === null || typeof value !== "object" || Object.isFrozen(value))
|
|
142
|
+
return value;
|
|
143
|
+
for (const child of Object.values(value))
|
|
144
|
+
deepFreeze(child);
|
|
145
|
+
return Object.freeze(value);
|
|
146
|
+
}
|
|
@@ -153,8 +153,8 @@ export class AgentVideoRuntime {
|
|
|
153
153
|
async analyzeSpeech(mediaId, range) {
|
|
154
154
|
return this.media.analyzeSpeech(mediaId, range);
|
|
155
155
|
}
|
|
156
|
-
async analyzeAudio(mediaId) {
|
|
157
|
-
return this.media.analyzeAudio(mediaId);
|
|
156
|
+
async analyzeAudio(mediaId, range) {
|
|
157
|
+
return this.media.analyzeAudio(mediaId, range);
|
|
158
158
|
}
|
|
159
159
|
async analyzeNoise(mediaId, range) {
|
|
160
160
|
return this.media.analyzeNoise(mediaId, range);
|
|
@@ -180,6 +180,9 @@ export class AgentVideoRuntime {
|
|
|
180
180
|
async planRoughCut(request) {
|
|
181
181
|
return this.media.planRoughCut(request);
|
|
182
182
|
}
|
|
183
|
+
async inspectTimelineSemanticContext(query = {}) {
|
|
184
|
+
return this.media.inspectTimelineSemanticContext(query);
|
|
185
|
+
}
|
|
183
186
|
async listAssets(query) {
|
|
184
187
|
return this.projects.listAssets(query);
|
|
185
188
|
}
|