@morshoto/framekit 0.1.0 → 0.1.4
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/README.md +42 -17
- package/dist-package/adapters/final-cut/typescript/src/analyzers.js +57 -0
- package/dist-package/adapters/final-cut/typescript/src/connection.js +5 -1
- package/dist-package/adapters/final-cut/typescript/src/export.js +231 -8
- package/dist-package/adapters/final-cut/typescript/src/fcpxml.js +55 -5
- package/dist-package/adapters/final-cut/typescript/src/live.js +2 -2
- package/dist-package/adapters/final-cut/typescript/src/native.js +1000 -100
- package/dist-package/adapters/final-cut/typescript/src/publisher.js +40 -5
- package/dist-package/adapters/final-cut/typescript/src/session.js +21 -5
- package/dist-package/apps/mcp-server/src/main.js +9 -1
- package/dist-package/apps/mcp-server/src/routing.js +172 -0
- package/dist-package/apps/mcp-server/src/server.js +780 -33
- package/dist-package/packages/runtime/src/application/duration-policy-service.js +6 -0
- package/dist-package/packages/runtime/src/application/media-analysis-service.js +370 -0
- package/dist-package/packages/runtime/src/application/project-service.js +127 -0
- package/dist-package/packages/runtime/src/application/runtime-options.js +1 -0
- package/dist-package/packages/runtime/src/application/transaction-store.js +12 -0
- package/dist-package/packages/runtime/src/audio/dialogue-normalization.js +64 -0
- package/dist-package/packages/runtime/src/audio/noise-reduction.js +46 -0
- package/dist-package/packages/runtime/src/capabilities.js +112 -1
- package/dist-package/packages/runtime/src/color-correction.js +48 -0
- package/dist-package/packages/runtime/src/context/context-engine.js +11 -6
- package/dist-package/packages/runtime/src/context/context-service.js +30 -0
- package/dist-package/packages/runtime/src/context/revision.js +3 -0
- package/dist-package/packages/runtime/src/domain/capabilities.js +1 -0
- package/dist-package/packages/runtime/src/domain/context.js +1 -0
- package/dist-package/packages/runtime/src/domain/diff.js +1 -0
- package/dist-package/packages/runtime/src/domain/duration.js +1 -0
- package/dist-package/packages/runtime/src/domain/editing.js +1 -0
- package/dist-package/packages/runtime/src/domain/index.js +12 -0
- package/dist-package/packages/runtime/src/domain/media.js +7 -0
- package/dist-package/packages/runtime/src/domain/ports.js +1 -0
- package/dist-package/packages/runtime/src/domain/primitives.js +1 -0
- package/dist-package/packages/runtime/src/domain/project.js +1 -0
- package/dist-package/packages/runtime/src/domain/rough-cut.js +69 -0
- package/dist-package/packages/runtime/src/domain/skills.js +33 -0
- package/dist-package/packages/runtime/src/domain/types.js +5 -1
- package/dist-package/packages/runtime/src/domain/verification.js +1 -0
- package/dist-package/packages/runtime/src/editing/dialogue-normalization-service.js +141 -0
- package/dist-package/packages/runtime/src/editing/duration-policy.js +187 -0
- package/dist-package/packages/runtime/src/editing/edit-service.js +413 -0
- package/dist-package/packages/runtime/src/editing/filler-removal-service.js +337 -0
- package/dist-package/packages/runtime/src/editing/music-service.js +85 -0
- package/dist-package/packages/runtime/src/index.js +12 -3
- package/dist-package/packages/runtime/src/planning/rough-cut.js +65 -0
- package/dist-package/packages/runtime/src/runtime.js +130 -825
- package/dist-package/packages/runtime/src/skills/builtin.js +339 -0
- package/dist-package/packages/runtime/src/skills/index.js +3 -0
- package/dist-package/packages/runtime/src/skills/registry.js +74 -0
- package/dist-package/packages/runtime/src/skills/requirements.js +170 -0
- package/dist-package/packages/runtime/src/skills/runtime.js +239 -0
- package/dist-package/packages/runtime/src/speech/filler-detector.js +132 -0
- package/dist-package/packages/runtime/src/speech/safe-cut-resolver.js +314 -0
- package/dist-package/packages/runtime/src/timeline/rational-time.js +58 -0
- package/dist-package/packages/runtime/src/verification/verification.js +712 -1
- package/dist-package/packages/testkit/src/fixture-analyzers.js +27 -0
- package/dist-package/packages/testkit/src/in-memory-editor.js +286 -3
- package/dist-package/packages/testkit/src/index.js +1 -0
- package/dist-package/packages/testkit/src/skill-fixtures.js +64 -0
- package/package.json +15 -7
- /package/dist-package/packages/runtime/src/{diff/diff.js → timeline/snapshot-diff.js} +0 -0
- /package/dist-package/packages/runtime/src/{snapshot-digest.js → timeline/snapshot-digest.js} +0 -0
|
@@ -0,0 +1,239 @@
|
|
|
1
|
+
import { randomUUID } from "node:crypto";
|
|
2
|
+
import { sameRevision } from "../context/revision.js";
|
|
3
|
+
import { assertSkillRequirements, resolveSkillRequirements, } from "./requirements.js";
|
|
4
|
+
import { SkillRegistry } from "./registry.js";
|
|
5
|
+
export class SkillRuntime {
|
|
6
|
+
project;
|
|
7
|
+
analysis;
|
|
8
|
+
edits;
|
|
9
|
+
options;
|
|
10
|
+
registry = new SkillRegistry();
|
|
11
|
+
previews = new Map();
|
|
12
|
+
constructor(project, analysis, edits, options = {}) {
|
|
13
|
+
this.project = project;
|
|
14
|
+
this.analysis = analysis;
|
|
15
|
+
this.edits = edits;
|
|
16
|
+
this.options = options;
|
|
17
|
+
}
|
|
18
|
+
register(definition) {
|
|
19
|
+
this.registry.register(definition);
|
|
20
|
+
}
|
|
21
|
+
list() {
|
|
22
|
+
return this.registry.list();
|
|
23
|
+
}
|
|
24
|
+
inspect(skillId, version) {
|
|
25
|
+
return this.registry.inspect(skillId, version);
|
|
26
|
+
}
|
|
27
|
+
async listAvailability() {
|
|
28
|
+
const context = await this.currentResolutionContext();
|
|
29
|
+
return this.registry.list().map((manifest) => ({
|
|
30
|
+
manifest,
|
|
31
|
+
availability: resolveAvailability(manifest, context),
|
|
32
|
+
}));
|
|
33
|
+
}
|
|
34
|
+
async inspectAvailability(skillId, version) {
|
|
35
|
+
const manifest = this.registry.inspect(skillId, version);
|
|
36
|
+
const context = await this.currentResolutionContext();
|
|
37
|
+
return { manifest, availability: resolveAvailability(manifest, context) };
|
|
38
|
+
}
|
|
39
|
+
async preview(request) {
|
|
40
|
+
const definition = this.registry.lookup(request.skillId, request.version);
|
|
41
|
+
const before = await this.project.inspectProject();
|
|
42
|
+
if (!sameRevision(request.baseRevision, before.revision)) {
|
|
43
|
+
throw new Error("STALE_CONTEXT: Skill preview base revision does not match current editor state");
|
|
44
|
+
}
|
|
45
|
+
const inspected = await this.project.inspectEditor();
|
|
46
|
+
assertSkillRequirements(definition.manifest, {
|
|
47
|
+
capabilities: inspected.capabilities,
|
|
48
|
+
editor: inspected.identity,
|
|
49
|
+
revision: before.revision,
|
|
50
|
+
});
|
|
51
|
+
this.assertInputSchema(definition.manifest.inputSchema, request.input);
|
|
52
|
+
const normalizedInput = await normalizeInput(definition, request.input);
|
|
53
|
+
const handlerContext = Object.freeze({
|
|
54
|
+
project: structuredClone(before),
|
|
55
|
+
capabilities: structuredClone(inspected.capabilities),
|
|
56
|
+
baseRevision: structuredClone(before.revision),
|
|
57
|
+
analyzeSpeech: (mediaId, range) => this.analysis.analyzeSpeech(mediaId, range),
|
|
58
|
+
measureAudio: (mediaId, occurrenceId) => this.analysis.measureAudio(mediaId, occurrenceId),
|
|
59
|
+
measureNoise: (mediaId, occurrenceId) => this.analysis.measureNoise(mediaId, occurrenceId),
|
|
60
|
+
});
|
|
61
|
+
const planned = await definition.handler.plan(handlerContext, normalizedInput);
|
|
62
|
+
const plan = {
|
|
63
|
+
id: `plan-${randomUUID()}`,
|
|
64
|
+
skillId: definition.manifest.id,
|
|
65
|
+
skillVersion: definition.manifest.version,
|
|
66
|
+
baseRevision: structuredClone(before.revision),
|
|
67
|
+
normalizedInput: structuredClone(normalizedInput),
|
|
68
|
+
operations: structuredClone(planned.operations),
|
|
69
|
+
affectedRanges: structuredClone(planned.affectedRanges),
|
|
70
|
+
warnings: [...planned.warnings],
|
|
71
|
+
...(planned.verification ? { verification: structuredClone(planned.verification) } : {}),
|
|
72
|
+
...(planned.details ? { details: structuredClone(planned.details) } : {}),
|
|
73
|
+
};
|
|
74
|
+
const editPreview = plan.operations.length > 0
|
|
75
|
+
? await this.edits.previewEdit({
|
|
76
|
+
baseRevision: before.revision,
|
|
77
|
+
operations: plan.operations,
|
|
78
|
+
verification: plan.verification ?? definition.manifest.verification,
|
|
79
|
+
})
|
|
80
|
+
: undefined;
|
|
81
|
+
const previewToken = `skill-preview-${randomUUID()}`;
|
|
82
|
+
const preview = {
|
|
83
|
+
previewToken,
|
|
84
|
+
plan,
|
|
85
|
+
...(editPreview?.expectedDiff ? { expectedDiff: editPreview.expectedDiff } : {}),
|
|
86
|
+
expiresAt: editPreview?.expiresAt ?? new Date(this.now() + (this.options.previewTtlMs ?? 30_000)).toISOString(),
|
|
87
|
+
};
|
|
88
|
+
this.prunePreviews();
|
|
89
|
+
this.previews.set(previewToken, { preview, ...(editPreview ? { editPreviewToken: editPreview.previewToken } : {}) });
|
|
90
|
+
return structuredClone(preview);
|
|
91
|
+
}
|
|
92
|
+
async execute(previewToken) {
|
|
93
|
+
const session = this.previews.get(previewToken);
|
|
94
|
+
if (!session)
|
|
95
|
+
throw new Error(`SKILL_PREVIEW_TOKEN_INVALID: unknown or already used preview ${previewToken}`);
|
|
96
|
+
this.previews.delete(previewToken);
|
|
97
|
+
if (this.now() > Date.parse(session.preview.expiresAt)) {
|
|
98
|
+
throw new Error("SKILL_PREVIEW_TOKEN_EXPIRED: Skill preview has expired");
|
|
99
|
+
}
|
|
100
|
+
const definition = this.registry.lookup(session.preview.plan.skillId, session.preview.plan.skillVersion);
|
|
101
|
+
const before = await this.project.inspectProject();
|
|
102
|
+
if (!sameRevision(session.preview.plan.baseRevision, before.revision)) {
|
|
103
|
+
throw new Error("STALE_CONTEXT: Skill preview base revision does not match current editor state");
|
|
104
|
+
}
|
|
105
|
+
const inspected = await this.project.inspectEditor();
|
|
106
|
+
assertSkillRequirements(definition.manifest, {
|
|
107
|
+
capabilities: inspected.capabilities,
|
|
108
|
+
editor: inspected.identity,
|
|
109
|
+
revision: before.revision,
|
|
110
|
+
});
|
|
111
|
+
if (!session.editPreviewToken) {
|
|
112
|
+
return {
|
|
113
|
+
status: "SKIPPED",
|
|
114
|
+
plan: {
|
|
115
|
+
id: session.preview.plan.id,
|
|
116
|
+
skillId: session.preview.plan.skillId,
|
|
117
|
+
skillVersion: session.preview.plan.skillVersion,
|
|
118
|
+
baseRevision: structuredClone(session.preview.plan.baseRevision),
|
|
119
|
+
},
|
|
120
|
+
transactionIds: [],
|
|
121
|
+
rollback: { attempted: false, succeeded: true, transactionIds: [] },
|
|
122
|
+
};
|
|
123
|
+
}
|
|
124
|
+
const transaction = await this.edits.executeEdit(session.editPreviewToken);
|
|
125
|
+
const rolledBack = transaction.status === "ROLLED_BACK";
|
|
126
|
+
return {
|
|
127
|
+
status: rolledBack ? "ROLLED_BACK" : transaction.status === "VERIFIED" ? "VERIFIED" : "FAILED",
|
|
128
|
+
plan: {
|
|
129
|
+
id: session.preview.plan.id,
|
|
130
|
+
skillId: session.preview.plan.skillId,
|
|
131
|
+
skillVersion: session.preview.plan.skillVersion,
|
|
132
|
+
baseRevision: structuredClone(session.preview.plan.baseRevision),
|
|
133
|
+
},
|
|
134
|
+
transactionIds: [transaction.id],
|
|
135
|
+
diff: structuredClone(transaction.diff),
|
|
136
|
+
...(transaction.verification ? { verification: structuredClone(transaction.verification) } : {}),
|
|
137
|
+
rollback: {
|
|
138
|
+
attempted: rolledBack,
|
|
139
|
+
succeeded: rolledBack,
|
|
140
|
+
transactionIds: rolledBack ? [transaction.id] : [],
|
|
141
|
+
},
|
|
142
|
+
};
|
|
143
|
+
}
|
|
144
|
+
assertInputSchema(schema, input) {
|
|
145
|
+
if (!isRecord(input))
|
|
146
|
+
throw new Error("SKILL_INPUT_INVALID: input must be an object");
|
|
147
|
+
for (const required of schema.required ?? []) {
|
|
148
|
+
if (!(required in input))
|
|
149
|
+
throw new Error(`SKILL_INPUT_INVALID: missing required input ${required}`);
|
|
150
|
+
}
|
|
151
|
+
if (schema.additionalProperties === false) {
|
|
152
|
+
for (const key of Object.keys(input)) {
|
|
153
|
+
if (!(key in schema.properties))
|
|
154
|
+
throw new Error(`SKILL_INPUT_INVALID: unknown input ${key}`);
|
|
155
|
+
}
|
|
156
|
+
}
|
|
157
|
+
for (const [key, property] of Object.entries(schema.properties)) {
|
|
158
|
+
if (key in input)
|
|
159
|
+
validateSchemaValue(property, input[key], key);
|
|
160
|
+
}
|
|
161
|
+
}
|
|
162
|
+
prunePreviews() {
|
|
163
|
+
const now = this.now();
|
|
164
|
+
for (const [token, session] of this.previews) {
|
|
165
|
+
if (now > Date.parse(session.preview.expiresAt))
|
|
166
|
+
this.previews.delete(token);
|
|
167
|
+
}
|
|
168
|
+
const limit = Number.isInteger(this.options.maxActivePreviews) && this.options.maxActivePreviews > 0
|
|
169
|
+
? this.options.maxActivePreviews
|
|
170
|
+
: 128;
|
|
171
|
+
while (this.previews.size >= limit) {
|
|
172
|
+
const oldest = this.previews.keys().next().value;
|
|
173
|
+
if (oldest === undefined)
|
|
174
|
+
break;
|
|
175
|
+
this.previews.delete(oldest);
|
|
176
|
+
}
|
|
177
|
+
}
|
|
178
|
+
now() {
|
|
179
|
+
return this.options.now?.() ?? Date.now();
|
|
180
|
+
}
|
|
181
|
+
async currentResolutionContext() {
|
|
182
|
+
return { inspected: await this.project.inspectEditor() };
|
|
183
|
+
}
|
|
184
|
+
}
|
|
185
|
+
async function normalizeInput(definition, input) {
|
|
186
|
+
try {
|
|
187
|
+
const normalized = await definition.handler.normalize(input);
|
|
188
|
+
if (!isRecord(normalized))
|
|
189
|
+
throw new Error("normalized input must be an object");
|
|
190
|
+
return normalized;
|
|
191
|
+
}
|
|
192
|
+
catch (error) {
|
|
193
|
+
throw new Error(`SKILL_INPUT_INVALID: ${String(error)}`);
|
|
194
|
+
}
|
|
195
|
+
}
|
|
196
|
+
function validateSchemaValue(schema, value, path) {
|
|
197
|
+
if (schema.type === "object") {
|
|
198
|
+
if (!isRecord(value))
|
|
199
|
+
throw new Error(`SKILL_INPUT_INVALID: ${path} must be an object`);
|
|
200
|
+
return;
|
|
201
|
+
}
|
|
202
|
+
if (schema.type === "array") {
|
|
203
|
+
if (!Array.isArray(value))
|
|
204
|
+
throw new Error(`SKILL_INPUT_INVALID: ${path} must be an array`);
|
|
205
|
+
if (schema.minItems !== undefined && value.length < schema.minItems)
|
|
206
|
+
throw new Error(`SKILL_INPUT_INVALID: ${path} has too few items`);
|
|
207
|
+
value.forEach((item, index) => validateSchemaValue(schema.items, item, `${path}[${index}]`));
|
|
208
|
+
return;
|
|
209
|
+
}
|
|
210
|
+
const valid = schema.type === "string"
|
|
211
|
+
? typeof value === "string"
|
|
212
|
+
: schema.type === "boolean"
|
|
213
|
+
? typeof value === "boolean"
|
|
214
|
+
: typeof value === "number" && Number.isFinite(value) && (schema.type !== "integer" || Number.isInteger(value));
|
|
215
|
+
if (!valid)
|
|
216
|
+
throw new Error(`SKILL_INPUT_INVALID: ${path} has type ${schema.type}`);
|
|
217
|
+
if (schema.type === "string" && schema.minLength !== undefined && value.length < schema.minLength) {
|
|
218
|
+
throw new Error(`SKILL_INPUT_INVALID: ${path} is too short`);
|
|
219
|
+
}
|
|
220
|
+
if ((schema.type === "number" || schema.type === "integer") && schema.minimum !== undefined && value < schema.minimum) {
|
|
221
|
+
throw new Error(`SKILL_INPUT_INVALID: ${path} is below minimum`);
|
|
222
|
+
}
|
|
223
|
+
if ((schema.type === "number" || schema.type === "integer") && schema.maximum !== undefined && value > schema.maximum) {
|
|
224
|
+
throw new Error(`SKILL_INPUT_INVALID: ${path} is above maximum`);
|
|
225
|
+
}
|
|
226
|
+
if (schema.type === "string" && schema.enum && !schema.enum.includes(value)) {
|
|
227
|
+
throw new Error(`SKILL_INPUT_INVALID: ${path} is not an allowed value`);
|
|
228
|
+
}
|
|
229
|
+
}
|
|
230
|
+
function isRecord(value) {
|
|
231
|
+
return Boolean(value) && typeof value === "object" && !Array.isArray(value);
|
|
232
|
+
}
|
|
233
|
+
function resolveAvailability(manifest, context) {
|
|
234
|
+
return resolveSkillRequirements(manifest, {
|
|
235
|
+
capabilities: context.inspected.capabilities,
|
|
236
|
+
editor: context.inspected.identity,
|
|
237
|
+
revision: context.project?.revision,
|
|
238
|
+
});
|
|
239
|
+
}
|
|
@@ -0,0 +1,132 @@
|
|
|
1
|
+
import { createHash } from "node:crypto";
|
|
2
|
+
export const DEFAULT_FILLER_VOCABULARY = ["er", "erm", "hmm", "uh", "um"];
|
|
3
|
+
export const DEFAULT_FILLER_CONFIDENCE_THRESHOLD = 0.92;
|
|
4
|
+
const TRAILING_PUNCTUATION = ".,!?;:";
|
|
5
|
+
/** Turn analyzer speech evidence into deterministic, preview-scoped candidates. */
|
|
6
|
+
export class FillerDetector {
|
|
7
|
+
vocabulary;
|
|
8
|
+
confidenceThreshold;
|
|
9
|
+
constructor(options = {}) {
|
|
10
|
+
this.vocabulary = new Set((options.vocabulary ?? DEFAULT_FILLER_VOCABULARY).map(normalizeWord));
|
|
11
|
+
this.confidenceThreshold = options.confidenceThreshold ?? DEFAULT_FILLER_CONFIDENCE_THRESHOLD;
|
|
12
|
+
if (!Number.isFinite(this.confidenceThreshold)
|
|
13
|
+
|| this.confidenceThreshold < 0
|
|
14
|
+
|| this.confidenceThreshold > 1) {
|
|
15
|
+
throw new Error("INVALID_OPERATION: filler confidence threshold must be between 0 and 1");
|
|
16
|
+
}
|
|
17
|
+
}
|
|
18
|
+
detect(input) {
|
|
19
|
+
validateInput(input);
|
|
20
|
+
const words = orderAndValidateWords(input.analysis.words);
|
|
21
|
+
const source = input.occurrence.sourceRange;
|
|
22
|
+
const sequence = input.occurrence.sequenceRange;
|
|
23
|
+
const sourceDuration = source.end - source.start;
|
|
24
|
+
const sequenceDuration = sequence.end - sequence.start;
|
|
25
|
+
if (Math.abs(sourceDuration - sequenceDuration) > 0.000001) {
|
|
26
|
+
throw new Error("AMBIGUOUS_MAPPING: source and sequence occurrence durations differ");
|
|
27
|
+
}
|
|
28
|
+
return words.flatMap((word) => {
|
|
29
|
+
const analyzerMarkedFiller = word.filler === true;
|
|
30
|
+
const vocabularyMatch = this.vocabulary.has(normalizeWord(word.text));
|
|
31
|
+
if (!analyzerMarkedFiller && !vocabularyMatch)
|
|
32
|
+
return [];
|
|
33
|
+
if (word.start < source.start || word.end > source.end)
|
|
34
|
+
return [];
|
|
35
|
+
const sequenceRange = {
|
|
36
|
+
start: sequence.start + (word.start - source.start),
|
|
37
|
+
end: sequence.start + (word.end - source.start),
|
|
38
|
+
};
|
|
39
|
+
const withinTarget = containsRange(input.targetRange, sequenceRange);
|
|
40
|
+
if (!withinTarget)
|
|
41
|
+
return [];
|
|
42
|
+
const eligible = word.confidence >= this.confidenceThreshold;
|
|
43
|
+
const reasonCodes = [];
|
|
44
|
+
if (analyzerMarkedFiller)
|
|
45
|
+
reasonCodes.push("ANALYZER_MARKED_FILLER");
|
|
46
|
+
if (vocabularyMatch)
|
|
47
|
+
reasonCodes.push("VOCABULARY_MATCH");
|
|
48
|
+
if (!eligible)
|
|
49
|
+
reasonCodes.push("BELOW_CONFIDENCE_THRESHOLD");
|
|
50
|
+
const sourceRange = { start: word.start, end: word.end };
|
|
51
|
+
const candidate = {
|
|
52
|
+
id: stableCandidateId(input, sourceRange),
|
|
53
|
+
word: { ...word },
|
|
54
|
+
wordEvidence: { ...word },
|
|
55
|
+
confidence: word.confidence,
|
|
56
|
+
confidenceThreshold: this.confidenceThreshold,
|
|
57
|
+
eligible,
|
|
58
|
+
occurrenceId: input.occurrence.occurrenceId,
|
|
59
|
+
...(input.occurrence.mediaId ? { mediaId: input.occurrence.mediaId } : {}),
|
|
60
|
+
sourceRange,
|
|
61
|
+
sequenceRange,
|
|
62
|
+
reasonCodes,
|
|
63
|
+
evidence: {
|
|
64
|
+
word: { ...word },
|
|
65
|
+
analyzerMarkedFiller,
|
|
66
|
+
vocabularyMatch,
|
|
67
|
+
withinTarget,
|
|
68
|
+
},
|
|
69
|
+
};
|
|
70
|
+
return [candidate];
|
|
71
|
+
});
|
|
72
|
+
}
|
|
73
|
+
}
|
|
74
|
+
function validateInput(input) {
|
|
75
|
+
if (!input.previewId.trim())
|
|
76
|
+
throw new Error("INVALID_OPERATION: filler preview ID is required");
|
|
77
|
+
validateRange(input.targetRange, "target range");
|
|
78
|
+
validateRange(input.occurrence.sourceRange, "source occurrence range");
|
|
79
|
+
validateRange(input.occurrence.sequenceRange, "sequence occurrence range");
|
|
80
|
+
if (!input.occurrence.occurrenceId.trim()) {
|
|
81
|
+
throw new Error("INVALID_OPERATION: filler occurrence ID is required");
|
|
82
|
+
}
|
|
83
|
+
}
|
|
84
|
+
function orderAndValidateWords(words) {
|
|
85
|
+
const ordered = words
|
|
86
|
+
.map((word) => ({ ...word }))
|
|
87
|
+
.sort((left, right) => left.start - right.start || left.end - right.end || left.text.localeCompare(right.text));
|
|
88
|
+
for (let index = 0; index < ordered.length; index += 1) {
|
|
89
|
+
const word = ordered[index];
|
|
90
|
+
if (!word.text.trim()
|
|
91
|
+
|| !Number.isFinite(word.start)
|
|
92
|
+
|| !Number.isFinite(word.end)
|
|
93
|
+
|| word.start < 0
|
|
94
|
+
|| word.end <= word.start
|
|
95
|
+
|| !Number.isFinite(word.confidence)
|
|
96
|
+
|| word.confidence < 0
|
|
97
|
+
|| word.confidence > 1) {
|
|
98
|
+
throw new Error("ANALYSIS_INVALID: speech word boundaries or confidence");
|
|
99
|
+
}
|
|
100
|
+
const previous = ordered[index - 1];
|
|
101
|
+
if (previous && previous.end > word.start) {
|
|
102
|
+
throw new Error("ANALYSIS_INVALID: speech word boundaries overlap");
|
|
103
|
+
}
|
|
104
|
+
}
|
|
105
|
+
return ordered;
|
|
106
|
+
}
|
|
107
|
+
function validateRange(range, label) {
|
|
108
|
+
if (!Number.isFinite(range.start) || !Number.isFinite(range.end) || range.end <= range.start) {
|
|
109
|
+
throw new Error(`INVALID_OPERATION: filler ${label} must be positive`);
|
|
110
|
+
}
|
|
111
|
+
}
|
|
112
|
+
function containsRange(container, candidate) {
|
|
113
|
+
return candidate.start >= container.start && candidate.end <= container.end;
|
|
114
|
+
}
|
|
115
|
+
function normalizeWord(text) {
|
|
116
|
+
const normalized = text.trim().toLocaleLowerCase();
|
|
117
|
+
let end = normalized.length;
|
|
118
|
+
while (end > 0 && TRAILING_PUNCTUATION.includes(normalized.charAt(end - 1))) {
|
|
119
|
+
end -= 1;
|
|
120
|
+
}
|
|
121
|
+
return normalized.slice(0, end);
|
|
122
|
+
}
|
|
123
|
+
function stableCandidateId(input, sourceRange) {
|
|
124
|
+
const identity = JSON.stringify({
|
|
125
|
+
previewId: input.previewId,
|
|
126
|
+
revisionId: input.revisionId ?? "",
|
|
127
|
+
occurrenceId: input.occurrence.occurrenceId,
|
|
128
|
+
mediaId: input.occurrence.mediaId ?? "",
|
|
129
|
+
sourceRange,
|
|
130
|
+
});
|
|
131
|
+
return `filler-candidate-${createHash("sha256").update(identity).digest("hex").slice(0, 24)}`;
|
|
132
|
+
}
|
|
@@ -0,0 +1,314 @@
|
|
|
1
|
+
export const DEFAULT_SAFE_CUT_PRESERVE_PAUSE_MS = 700;
|
|
2
|
+
export const DEFAULT_SAFE_CUT_TARGET_PAUSE_MS = 500;
|
|
3
|
+
/** Resolve filler words to safe frame-aligned operations without mutating an editor. */
|
|
4
|
+
export class SafeCutResolver {
|
|
5
|
+
preservePauseMs;
|
|
6
|
+
targetPauseMs;
|
|
7
|
+
constructor(options = {}) {
|
|
8
|
+
this.preservePauseMs = options.preservePauseMs ?? DEFAULT_SAFE_CUT_PRESERVE_PAUSE_MS;
|
|
9
|
+
this.targetPauseMs = options.targetPauseMs ?? DEFAULT_SAFE_CUT_TARGET_PAUSE_MS;
|
|
10
|
+
if (!Number.isFinite(this.preservePauseMs)
|
|
11
|
+
|| this.preservePauseMs < 0
|
|
12
|
+
|| !Number.isFinite(this.targetPauseMs)
|
|
13
|
+
|| this.targetPauseMs < 0
|
|
14
|
+
|| this.targetPauseMs > this.preservePauseMs) {
|
|
15
|
+
throw new Error("INVALID_OPERATION: safe cut pause settings are invalid");
|
|
16
|
+
}
|
|
17
|
+
}
|
|
18
|
+
resolve(request) {
|
|
19
|
+
const evidence = createEvidence(request);
|
|
20
|
+
const base = {
|
|
21
|
+
candidateId: request.candidate.id,
|
|
22
|
+
occurrenceId: request.occurrence.occurrenceId,
|
|
23
|
+
evidence,
|
|
24
|
+
};
|
|
25
|
+
const initialReasons = [];
|
|
26
|
+
if (request.candidate.occurrenceId !== request.occurrence.occurrenceId) {
|
|
27
|
+
return { ...base, status: "SKIPPED", reasonCodes: ["AMBIGUOUS_MAPPING"] };
|
|
28
|
+
}
|
|
29
|
+
if (!isContained(request.candidate.sequenceRange, request.targetRange)) {
|
|
30
|
+
return { ...base, status: "SKIPPED", reasonCodes: ["OUTSIDE_TARGET_BOUND"] };
|
|
31
|
+
}
|
|
32
|
+
if (!isContained(request.candidate.sequenceRange, request.occurrence.sequenceRange)) {
|
|
33
|
+
return { ...base, status: "SKIPPED", reasonCodes: ["OUTSIDE_OCCURRENCE_BOUND"] };
|
|
34
|
+
}
|
|
35
|
+
if (!isSequenceMappingConsistent(request.candidate, request.occurrence)) {
|
|
36
|
+
return { ...base, status: "SKIPPED", reasonCodes: ["AMBIGUOUS_MAPPING"] };
|
|
37
|
+
}
|
|
38
|
+
const frame = parseRational(request.sequenceFrameDuration);
|
|
39
|
+
if (!frame || frame.numerator <= 0n) {
|
|
40
|
+
return { ...base, status: "SKIPPED", reasonCodes: ["NO_FRAME_ALIGNED_RANGE"] };
|
|
41
|
+
}
|
|
42
|
+
const words = orderWords(request.analysis.words);
|
|
43
|
+
if (!words) {
|
|
44
|
+
return { ...base, status: "SKIPPED", reasonCodes: ["OVERLAPPING_SPEECH"] };
|
|
45
|
+
}
|
|
46
|
+
const wordMatches = words.filter((word) => sameWord(word, request.candidate.word));
|
|
47
|
+
if (wordMatches.length !== 1) {
|
|
48
|
+
return { ...base, status: "SKIPPED", reasonCodes: ["AMBIGUOUS_MAPPING"] };
|
|
49
|
+
}
|
|
50
|
+
const wordIndex = words.indexOf(wordMatches[0]);
|
|
51
|
+
const word = wordMatches[0];
|
|
52
|
+
const previousWord = words[wordIndex - 1];
|
|
53
|
+
const nextWord = words[wordIndex + 1];
|
|
54
|
+
evidence.word = { ...word };
|
|
55
|
+
if (previousWord)
|
|
56
|
+
evidence.previousWord = { ...previousWord };
|
|
57
|
+
if (nextWord)
|
|
58
|
+
evidence.nextWord = { ...nextWord };
|
|
59
|
+
if (!request.analysis.vadSegments) {
|
|
60
|
+
return { ...base, status: "SKIPPED", reasonCodes: ["MISSING_VAD_EVIDENCE"] };
|
|
61
|
+
}
|
|
62
|
+
const vadSegments = validateSegments(request.analysis.vadSegments);
|
|
63
|
+
if (!vadSegments) {
|
|
64
|
+
return { ...base, status: "SKIPPED", reasonCodes: ["INVALID_VAD_EVIDENCE"] };
|
|
65
|
+
}
|
|
66
|
+
evidence.speechSegments = vadSegments.filter((segment) => segment.kind === "speech");
|
|
67
|
+
if (hasOverlappingSpeech(vadSegments)) {
|
|
68
|
+
return { ...base, status: "SKIPPED", reasonCodes: ["OVERLAPPING_SPEECH"] };
|
|
69
|
+
}
|
|
70
|
+
if (hasOverlappingSegments(vadSegments)) {
|
|
71
|
+
return { ...base, status: "SKIPPED", reasonCodes: ["INVALID_VAD_EVIDENCE"] };
|
|
72
|
+
}
|
|
73
|
+
if (!coversRange(evidence.speechSegments, request.candidate.sourceRange)) {
|
|
74
|
+
return { ...base, status: "SKIPPED", reasonCodes: ["MISSING_VAD_EVIDENCE"] };
|
|
75
|
+
}
|
|
76
|
+
const silenceSegments = validateSegments(request.analysis.silenceSegments ?? vadSegments.filter((segment) => segment.kind === "silence"));
|
|
77
|
+
if (!silenceSegments) {
|
|
78
|
+
return { ...base, status: "SKIPPED", reasonCodes: ["INVALID_SILENCE_EVIDENCE"] };
|
|
79
|
+
}
|
|
80
|
+
evidence.silenceSegments = silenceSegments;
|
|
81
|
+
const protectedSegments = validateSegments(request.analysis.protectedSegments ?? []);
|
|
82
|
+
if (!protectedSegments) {
|
|
83
|
+
return { ...base, status: "SKIPPED", reasonCodes: ["INVALID_PROTECTED_EVIDENCE"] };
|
|
84
|
+
}
|
|
85
|
+
evidence.protectedSegments = protectedSegments;
|
|
86
|
+
if (overlapsAny(protectedSegments, request.candidate.sourceRange)) {
|
|
87
|
+
return { ...base, status: "SKIPPED", reasonCodes: ["PROTECTED_SEGMENT_OVERLAP"] };
|
|
88
|
+
}
|
|
89
|
+
const nextStart = nextWord?.start ?? request.occurrence.sourceRange.end;
|
|
90
|
+
const followingPauseMs = Math.max(0, (nextStart - word.end) * 1000);
|
|
91
|
+
evidence.pauseBeforeCutMs = Math.max(0, (word.start - (previousWord?.end ?? word.start)) * 1000);
|
|
92
|
+
let sourceEnd = word.end;
|
|
93
|
+
let pauseReason = false;
|
|
94
|
+
if (followingPauseMs > this.preservePauseMs) {
|
|
95
|
+
const silenceEnd = silenceEndFor(silenceSegments, word.end, nextStart);
|
|
96
|
+
const desiredEnd = word.end + (followingPauseMs - this.targetPauseMs) / 1000;
|
|
97
|
+
if (silenceEnd !== undefined && silenceEnd >= desiredEnd) {
|
|
98
|
+
sourceEnd = Math.min(desiredEnd, nextStart);
|
|
99
|
+
pauseReason = true;
|
|
100
|
+
}
|
|
101
|
+
}
|
|
102
|
+
evidence.pauseAfterCutMs = Math.max(0, (nextStart - sourceEnd) * 1000);
|
|
103
|
+
if (overlapsAny(protectedSegments, { start: word.start, end: sourceEnd })) {
|
|
104
|
+
return { ...base, status: "SKIPPED", reasonCodes: ["PROTECTED_SEGMENT_OVERLAP"] };
|
|
105
|
+
}
|
|
106
|
+
const sourceStart = word.start;
|
|
107
|
+
const minimumSourceStart = previousWord
|
|
108
|
+
? Math.max(previousWord.end, request.occurrence.sourceRange.start)
|
|
109
|
+
: request.occurrence.sourceRange.start;
|
|
110
|
+
const precedingSpeechEnd = evidence.speechSegments
|
|
111
|
+
.filter((segment) => segment.end <= word.start)
|
|
112
|
+
.reduce((latest, segment) => Math.max(latest, segment.end), minimumSourceStart);
|
|
113
|
+
const followingSpeechStart = evidence.speechSegments
|
|
114
|
+
.filter((segment) => segment.start >= sourceEnd)
|
|
115
|
+
.reduce((earliest, segment) => Math.min(earliest, segment.start), nextStart);
|
|
116
|
+
const sequenceStart = mapSourceToSequence(sourceStart, request.occurrence);
|
|
117
|
+
const sequenceEnd = mapSourceToSequence(sourceEnd, request.occurrence);
|
|
118
|
+
const minimumSequenceStart = Math.max(mapSourceToSequence(Math.max(minimumSourceStart, precedingSpeechEnd), request.occurrence), request.targetRange.start, request.occurrence.sequenceRange.start);
|
|
119
|
+
const maximumSequenceEnd = Math.min(mapSourceToSequence(Math.min(nextStart, followingSpeechStart), request.occurrence), request.targetRange.end, request.occurrence.sequenceRange.end);
|
|
120
|
+
const alignedStart = floorMultiple(decimalToRational(sequenceStart), frame);
|
|
121
|
+
const alignedEnd = ceilMultiple(decimalToRational(sequenceEnd), frame);
|
|
122
|
+
const safeStart = rationalToNumber(alignedStart);
|
|
123
|
+
const safeEnd = rationalToNumber(alignedEnd);
|
|
124
|
+
if (!Number.isFinite(safeStart)
|
|
125
|
+
|| !Number.isFinite(safeEnd)
|
|
126
|
+
|| safeEnd <= safeStart
|
|
127
|
+
|| safeStart < minimumSequenceStart - 0.000000001
|
|
128
|
+
|| safeEnd > maximumSequenceEnd + 0.000000001) {
|
|
129
|
+
return { ...base, status: "SKIPPED", reasonCodes: ["NO_FRAME_ALIGNED_RANGE"] };
|
|
130
|
+
}
|
|
131
|
+
const alignedSourceRange = {
|
|
132
|
+
start: request.occurrence.sourceRange.start
|
|
133
|
+
+ (safeStart - request.occurrence.sequenceRange.start),
|
|
134
|
+
end: request.occurrence.sourceRange.start
|
|
135
|
+
+ (safeEnd - request.occurrence.sequenceRange.start),
|
|
136
|
+
};
|
|
137
|
+
if (overlapsAny(protectedSegments, alignedSourceRange)) {
|
|
138
|
+
return { ...base, status: "SKIPPED", reasonCodes: ["PROTECTED_SEGMENT_OVERLAP"] };
|
|
139
|
+
}
|
|
140
|
+
const range = rangeFromRationals(alignedStart, subtractRationals(alignedEnd, alignedStart));
|
|
141
|
+
evidence.safeRange = structuredClone(range);
|
|
142
|
+
initialReasons.push("SAFE_BOUNDARY_RESOLVED");
|
|
143
|
+
if (pauseReason)
|
|
144
|
+
initialReasons.push("PAUSE_PRESERVED");
|
|
145
|
+
if (!request.candidate.eligible || request.candidate.confidence < request.candidate.confidenceThreshold) {
|
|
146
|
+
initialReasons.push("LOW_CONFIDENCE");
|
|
147
|
+
}
|
|
148
|
+
const status = initialReasons.includes("LOW_CONFIDENCE") ? "SUGGESTED" : "AUTO_APPLY";
|
|
149
|
+
return {
|
|
150
|
+
...base,
|
|
151
|
+
status,
|
|
152
|
+
reasonCodes: initialReasons,
|
|
153
|
+
range,
|
|
154
|
+
operation: {
|
|
155
|
+
type: "ripple-delete",
|
|
156
|
+
timelineId: request.timelineId,
|
|
157
|
+
range: structuredClone(range),
|
|
158
|
+
reason: `remove filler candidate ${request.candidate.id}`,
|
|
159
|
+
},
|
|
160
|
+
};
|
|
161
|
+
}
|
|
162
|
+
}
|
|
163
|
+
function createEvidence(request) {
|
|
164
|
+
return {
|
|
165
|
+
word: { ...request.candidate.word },
|
|
166
|
+
speechSegments: [],
|
|
167
|
+
silenceSegments: [],
|
|
168
|
+
protectedSegments: [],
|
|
169
|
+
occurrenceRange: structuredClone(request.occurrence.sequenceRange),
|
|
170
|
+
targetRange: structuredClone(request.targetRange),
|
|
171
|
+
frameDuration: structuredClone(request.sequenceFrameDuration),
|
|
172
|
+
pauseBeforeCutMs: 0,
|
|
173
|
+
pauseAfterCutMs: 0,
|
|
174
|
+
};
|
|
175
|
+
}
|
|
176
|
+
function validateSegments(segments) {
|
|
177
|
+
if (!segments)
|
|
178
|
+
return undefined;
|
|
179
|
+
const ordered = segments.map((segment) => ({ ...segment })).sort((left, right) => left.start - right.start || left.end - right.end);
|
|
180
|
+
for (let index = 0; index < ordered.length; index += 1) {
|
|
181
|
+
const segment = ordered[index];
|
|
182
|
+
if (!Number.isFinite(segment.start)
|
|
183
|
+
|| !Number.isFinite(segment.end)
|
|
184
|
+
|| segment.start < 0
|
|
185
|
+
|| segment.end <= segment.start
|
|
186
|
+
|| !["speech", "silence", "breath", "laughter", "noise"].includes(segment.kind)) {
|
|
187
|
+
return undefined;
|
|
188
|
+
}
|
|
189
|
+
}
|
|
190
|
+
return ordered;
|
|
191
|
+
}
|
|
192
|
+
function orderWords(words) {
|
|
193
|
+
const ordered = words.map((word) => ({ ...word })).sort((left, right) => left.start - right.start || left.end - right.end);
|
|
194
|
+
return hasOverlappingWords(ordered) ? undefined : ordered;
|
|
195
|
+
}
|
|
196
|
+
function hasOverlappingWords(words) {
|
|
197
|
+
return words.some((word, index) => index > 0 && words[index - 1].end > word.start);
|
|
198
|
+
}
|
|
199
|
+
function hasOverlappingSpeech(segments) {
|
|
200
|
+
const speech = segments.filter((segment) => segment.kind === "speech");
|
|
201
|
+
return speech.some((segment, index) => index > 0 && speech[index - 1].end > segment.start);
|
|
202
|
+
}
|
|
203
|
+
function hasOverlappingSegments(segments) {
|
|
204
|
+
return segments.some((segment, index) => index > 0 && segments[index - 1].end > segment.start);
|
|
205
|
+
}
|
|
206
|
+
function coversRange(segments, range) {
|
|
207
|
+
return segments.some((segment) => segment.start <= range.start && segment.end >= range.end);
|
|
208
|
+
}
|
|
209
|
+
function overlapsAny(segments, range) {
|
|
210
|
+
return segments.some((segment) => segment.start < range.end && segment.end > range.start);
|
|
211
|
+
}
|
|
212
|
+
function silenceEndFor(segments, start, end) {
|
|
213
|
+
return segments
|
|
214
|
+
.filter((segment) => segment.kind === "silence" && segment.start <= start && segment.end >= end)
|
|
215
|
+
.map((segment) => segment.end)
|
|
216
|
+
.sort((left, right) => right - left)[0];
|
|
217
|
+
}
|
|
218
|
+
function sameWord(left, right) {
|
|
219
|
+
return left.text === right.text && left.start === right.start && left.end === right.end;
|
|
220
|
+
}
|
|
221
|
+
function isContained(candidate, container) {
|
|
222
|
+
return candidate.start >= container.start && candidate.end <= container.end;
|
|
223
|
+
}
|
|
224
|
+
function isSequenceMappingConsistent(candidate, occurrence) {
|
|
225
|
+
const expectedStart = mapSourceToSequence(candidate.sourceRange.start, occurrence);
|
|
226
|
+
const expectedEnd = mapSourceToSequence(candidate.sourceRange.end, occurrence);
|
|
227
|
+
return Math.abs(expectedStart - candidate.sequenceRange.start) <= 0.000001
|
|
228
|
+
&& Math.abs(expectedEnd - candidate.sequenceRange.end) <= 0.000001;
|
|
229
|
+
}
|
|
230
|
+
function mapSourceToSequence(sourceTime, occurrence) {
|
|
231
|
+
return occurrence.sequenceRange.start + (sourceTime - occurrence.sourceRange.start);
|
|
232
|
+
}
|
|
233
|
+
function parseRational(time) {
|
|
234
|
+
if (!/^-?\d+$/.test(time.value) || !/^\d+$/.test(time.timescale))
|
|
235
|
+
return undefined;
|
|
236
|
+
const denominator = BigInt(time.timescale);
|
|
237
|
+
if (denominator <= 0n)
|
|
238
|
+
return undefined;
|
|
239
|
+
return normalizeRational({ numerator: BigInt(time.value), denominator });
|
|
240
|
+
}
|
|
241
|
+
function decimalToRational(value) {
|
|
242
|
+
const text = value.toString();
|
|
243
|
+
if (/[eE]/u.test(text)) {
|
|
244
|
+
const [coefficient, exponentText] = text.split(/[eE]/u);
|
|
245
|
+
const exponent = Number(exponentText);
|
|
246
|
+
const coefficientParts = decimalToRational(Number(coefficient));
|
|
247
|
+
if (exponent >= 0)
|
|
248
|
+
return normalizeRational({ numerator: coefficientParts.numerator * 10n ** BigInt(exponent), denominator: coefficientParts.denominator });
|
|
249
|
+
return normalizeRational({ numerator: coefficientParts.numerator, denominator: coefficientParts.denominator * 10n ** BigInt(-exponent) });
|
|
250
|
+
}
|
|
251
|
+
const [whole, fraction = ""] = text.split(".");
|
|
252
|
+
const sign = whole.startsWith("-") ? -1n : 1n;
|
|
253
|
+
const unsignedWhole = whole.replace(/^-/, "");
|
|
254
|
+
return normalizeRational({
|
|
255
|
+
numerator: sign * BigInt(`${unsignedWhole}${fraction}` || "0"),
|
|
256
|
+
denominator: 10n ** BigInt(fraction.length),
|
|
257
|
+
});
|
|
258
|
+
}
|
|
259
|
+
function normalizeRational(value) {
|
|
260
|
+
const divisor = greatestCommonDivisor(value.numerator < 0n ? -value.numerator : value.numerator, value.denominator);
|
|
261
|
+
return { numerator: value.numerator / divisor, denominator: value.denominator / divisor };
|
|
262
|
+
}
|
|
263
|
+
function floorMultiple(value, multiple) {
|
|
264
|
+
const quotient = floorDivide(value.numerator * multiple.denominator, value.denominator * multiple.numerator);
|
|
265
|
+
return normalizeRational({ numerator: quotient * multiple.numerator, denominator: multiple.denominator });
|
|
266
|
+
}
|
|
267
|
+
function ceilMultiple(value, multiple) {
|
|
268
|
+
const numerator = value.numerator * multiple.denominator;
|
|
269
|
+
const denominator = value.denominator * multiple.numerator;
|
|
270
|
+
const quotient = ceilDivide(numerator, denominator);
|
|
271
|
+
return normalizeRational({ numerator: quotient * multiple.numerator, denominator: multiple.denominator });
|
|
272
|
+
}
|
|
273
|
+
function floorDivide(numerator, denominator) {
|
|
274
|
+
if (numerator >= 0n)
|
|
275
|
+
return numerator / denominator;
|
|
276
|
+
return -((-numerator + denominator - 1n) / denominator);
|
|
277
|
+
}
|
|
278
|
+
function ceilDivide(numerator, denominator) {
|
|
279
|
+
if (numerator >= 0n)
|
|
280
|
+
return (numerator + denominator - 1n) / denominator;
|
|
281
|
+
return -((-numerator) / denominator);
|
|
282
|
+
}
|
|
283
|
+
function subtractRationals(left, right) {
|
|
284
|
+
return normalizeRational({
|
|
285
|
+
numerator: left.numerator * right.denominator - right.numerator * left.denominator,
|
|
286
|
+
denominator: left.denominator * right.denominator,
|
|
287
|
+
});
|
|
288
|
+
}
|
|
289
|
+
function rangeFromRationals(start, duration) {
|
|
290
|
+
const end = normalizeRational({
|
|
291
|
+
numerator: start.numerator * duration.denominator + duration.numerator * start.denominator,
|
|
292
|
+
denominator: start.denominator * duration.denominator,
|
|
293
|
+
});
|
|
294
|
+
return {
|
|
295
|
+
start: rationalToNumber(start),
|
|
296
|
+
end: rationalToNumber(end),
|
|
297
|
+
startTime: rationalToTime(start),
|
|
298
|
+
durationTime: rationalToTime(duration),
|
|
299
|
+
};
|
|
300
|
+
}
|
|
301
|
+
function rationalToNumber(value) {
|
|
302
|
+
return Number(value.numerator) / Number(value.denominator);
|
|
303
|
+
}
|
|
304
|
+
function rationalToTime(value) {
|
|
305
|
+
return { value: String(value.numerator), timescale: String(value.denominator) };
|
|
306
|
+
}
|
|
307
|
+
function greatestCommonDivisor(left, right) {
|
|
308
|
+
while (right !== 0n) {
|
|
309
|
+
const remainder = left % right;
|
|
310
|
+
left = right;
|
|
311
|
+
right = remainder;
|
|
312
|
+
}
|
|
313
|
+
return left || 1n;
|
|
314
|
+
}
|