@morshoto/framekit 0.1.0
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 +67 -0
- package/bin/framekit.mjs +26 -0
- package/dist-package/adapters/final-cut/typescript/src/analyzers.js +116 -0
- package/dist-package/adapters/final-cut/typescript/src/assets.js +112 -0
- package/dist-package/adapters/final-cut/typescript/src/connection.js +379 -0
- package/dist-package/adapters/final-cut/typescript/src/disposable-native.js +282 -0
- package/dist-package/adapters/final-cut/typescript/src/export.js +382 -0
- package/dist-package/adapters/final-cut/typescript/src/fcpxml.js +503 -0
- package/dist-package/adapters/final-cut/typescript/src/index.js +11 -0
- package/dist-package/adapters/final-cut/typescript/src/live.js +415 -0
- package/dist-package/adapters/final-cut/typescript/src/native-operation.js +18 -0
- package/dist-package/adapters/final-cut/typescript/src/native.js +3134 -0
- package/dist-package/adapters/final-cut/typescript/src/publisher.js +102 -0
- package/dist-package/adapters/final-cut/typescript/src/session.js +171 -0
- package/dist-package/apps/cli/src/main.js +130 -0
- package/dist-package/apps/mcp-server/src/main.js +146 -0
- package/dist-package/apps/mcp-server/src/server.js +617 -0
- package/dist-package/packages/runtime/src/capabilities.js +24 -0
- package/dist-package/packages/runtime/src/context/context-engine.js +142 -0
- package/dist-package/packages/runtime/src/diff/diff.js +145 -0
- package/dist-package/packages/runtime/src/domain/types.js +1 -0
- package/dist-package/packages/runtime/src/editing/intent.js +83 -0
- package/dist-package/packages/runtime/src/index.js +8 -0
- package/dist-package/packages/runtime/src/runtime.js +890 -0
- package/dist-package/packages/runtime/src/snapshot-digest.js +24 -0
- package/dist-package/packages/runtime/src/speech/filler-removal.js +87 -0
- package/dist-package/packages/runtime/src/verification/verification.js +113 -0
- package/dist-package/packages/testkit/src/fixture-analyzers.js +39 -0
- package/dist-package/packages/testkit/src/in-memory-editor.js +520 -0
- package/dist-package/packages/testkit/src/index.js +2 -0
- package/package.json +64 -0
|
@@ -0,0 +1,142 @@
|
|
|
1
|
+
import { diffSnapshots } from "../diff/diff.js";
|
|
2
|
+
export class ContextEngine {
|
|
3
|
+
editor;
|
|
4
|
+
snapshots = new Map();
|
|
5
|
+
mediaUnderstanding = new Map();
|
|
6
|
+
constructor(editor) {
|
|
7
|
+
this.editor = editor;
|
|
8
|
+
}
|
|
9
|
+
async inspectProject() {
|
|
10
|
+
const snapshot = await this.editor.readProject();
|
|
11
|
+
const enriched = this.withAttachedUnderstanding(snapshot);
|
|
12
|
+
this.snapshots.set(enriched.revision.id, structuredClone(enriched));
|
|
13
|
+
return enriched;
|
|
14
|
+
}
|
|
15
|
+
async changesSince(revision) {
|
|
16
|
+
const capabilities = await this.editor.getCapabilities();
|
|
17
|
+
if (capabilities.editor.incrementalChanges) {
|
|
18
|
+
const incremental = await this.editor.readChanges?.(revision);
|
|
19
|
+
if (incremental?.timeline)
|
|
20
|
+
return incremental.timeline;
|
|
21
|
+
}
|
|
22
|
+
const before = this.snapshots.get(revision.id);
|
|
23
|
+
if (!capabilities.editor.timelineSnapshotRead) {
|
|
24
|
+
throw new Error("CAPABILITY_UNAVAILABLE: canonical timeline changes");
|
|
25
|
+
}
|
|
26
|
+
if (!before)
|
|
27
|
+
throw new Error(`REVISION_NOT_FOUND: ${revision.id}`);
|
|
28
|
+
return diffSnapshots(before, await this.inspectProject());
|
|
29
|
+
}
|
|
30
|
+
async contextChangesSince(revision, waitMs = 0) {
|
|
31
|
+
const capabilities = await this.editor.getCapabilities();
|
|
32
|
+
const incremental = capabilities.editor.incrementalChanges
|
|
33
|
+
? await this.editor.readChanges?.(revision)
|
|
34
|
+
: undefined;
|
|
35
|
+
const timeline = incremental?.timeline ?? await this.optionalTimelineChanges(revision);
|
|
36
|
+
const stateChanges = [
|
|
37
|
+
...(incremental?.stateChanges ?? []),
|
|
38
|
+
...(await this.liveChangesSince(revision, waitMs)),
|
|
39
|
+
];
|
|
40
|
+
const assetChanges = incremental?.assetChanges ?? [];
|
|
41
|
+
const to = latestRevision(revision, timeline?.to, ...stateChanges.map((change) => change.revision), incremental?.to);
|
|
42
|
+
return {
|
|
43
|
+
from: revision,
|
|
44
|
+
to,
|
|
45
|
+
timeline,
|
|
46
|
+
stateChanges: dedupeStateChanges(stateChanges),
|
|
47
|
+
assetChanges,
|
|
48
|
+
};
|
|
49
|
+
}
|
|
50
|
+
async inspectContext(capabilities) {
|
|
51
|
+
const project = await this.inspectProject();
|
|
52
|
+
const editorState = await this.optionalLiveState();
|
|
53
|
+
const revision = project.revision;
|
|
54
|
+
return {
|
|
55
|
+
revision,
|
|
56
|
+
project,
|
|
57
|
+
...(editorState ? { editorState } : {}),
|
|
58
|
+
media: project.media,
|
|
59
|
+
recentChanges: {
|
|
60
|
+
from: revision,
|
|
61
|
+
to: revision,
|
|
62
|
+
stateChanges: [],
|
|
63
|
+
assetChanges: [],
|
|
64
|
+
},
|
|
65
|
+
capabilities,
|
|
66
|
+
};
|
|
67
|
+
}
|
|
68
|
+
attachMediaUnderstanding(understanding) {
|
|
69
|
+
this.mediaUnderstanding.set(understanding.mediaId, structuredClone(understanding));
|
|
70
|
+
}
|
|
71
|
+
async listAssets(query) {
|
|
72
|
+
if (!this.editor.listAssets)
|
|
73
|
+
throw new Error("CAPABILITY_UNAVAILABLE: editor assets");
|
|
74
|
+
return this.editor.listAssets(query);
|
|
75
|
+
}
|
|
76
|
+
async optionalTimelineChanges(revision) {
|
|
77
|
+
const capabilities = await this.editor.getCapabilities();
|
|
78
|
+
if (!capabilities.editor.timelineSnapshotRead)
|
|
79
|
+
return undefined;
|
|
80
|
+
return this.changesSince(revision);
|
|
81
|
+
}
|
|
82
|
+
async liveChangesSince(revision, waitMs) {
|
|
83
|
+
const candidate = this.editor;
|
|
84
|
+
if (typeof candidate.liveChangesSince !== "function")
|
|
85
|
+
return [];
|
|
86
|
+
try {
|
|
87
|
+
return await candidate.liveChangesSince(revision, waitMs);
|
|
88
|
+
}
|
|
89
|
+
catch (error) {
|
|
90
|
+
if (isOptionalLiveUnavailable(error))
|
|
91
|
+
return [];
|
|
92
|
+
throw error;
|
|
93
|
+
}
|
|
94
|
+
}
|
|
95
|
+
async optionalLiveState() {
|
|
96
|
+
const candidate = this.editor;
|
|
97
|
+
if (typeof candidate.readLiveState !== "function")
|
|
98
|
+
return undefined;
|
|
99
|
+
try {
|
|
100
|
+
return await candidate.readLiveState();
|
|
101
|
+
}
|
|
102
|
+
catch (error) {
|
|
103
|
+
if (isOptionalLiveUnavailable(error))
|
|
104
|
+
return undefined;
|
|
105
|
+
throw error;
|
|
106
|
+
}
|
|
107
|
+
}
|
|
108
|
+
withAttachedUnderstanding(snapshot) {
|
|
109
|
+
const next = structuredClone(snapshot);
|
|
110
|
+
next.media = next.media.map((media) => {
|
|
111
|
+
const understanding = this.mediaUnderstanding.get(media.mediaId);
|
|
112
|
+
if (!understanding || understanding.source !== media.source)
|
|
113
|
+
return media;
|
|
114
|
+
return {
|
|
115
|
+
...media,
|
|
116
|
+
speech: understanding.speech,
|
|
117
|
+
audio: understanding.audio,
|
|
118
|
+
visual: understanding.visual,
|
|
119
|
+
analysisRevision: understanding.analysisRevision.id,
|
|
120
|
+
};
|
|
121
|
+
});
|
|
122
|
+
return next;
|
|
123
|
+
}
|
|
124
|
+
}
|
|
125
|
+
function isOptionalLiveUnavailable(error) {
|
|
126
|
+
const message = String(error);
|
|
127
|
+
return message.includes("FINAL_CUT_LIVE_UNAVAILABLE") || message.includes("CAPABILITY_UNAVAILABLE: live Final Cut editor state");
|
|
128
|
+
}
|
|
129
|
+
function latestRevision(base, ...candidates) {
|
|
130
|
+
return candidates.filter((candidate) => Boolean(candidate))
|
|
131
|
+
.reduce((latest, candidate) => candidate.sequence > latest.sequence ? candidate : latest, base);
|
|
132
|
+
}
|
|
133
|
+
function dedupeStateChanges(changes) {
|
|
134
|
+
const seen = new Set();
|
|
135
|
+
return changes.filter((change) => {
|
|
136
|
+
const key = `${change.kind}:${change.revision.id}`;
|
|
137
|
+
if (seen.has(key))
|
|
138
|
+
return false;
|
|
139
|
+
seen.add(key);
|
|
140
|
+
return true;
|
|
141
|
+
});
|
|
142
|
+
}
|
|
@@ -0,0 +1,145 @@
|
|
|
1
|
+
function withoutId(value) {
|
|
2
|
+
const { id: _id, ...content } = value;
|
|
3
|
+
return content;
|
|
4
|
+
}
|
|
5
|
+
function rangesForClip(clip) {
|
|
6
|
+
return clip ? [{ start: clip.start, end: clip.start + clip.duration, startTime: clip.startTime, durationTime: clip.durationTime }] : [];
|
|
7
|
+
}
|
|
8
|
+
function diffByKey(before, after, keyOf, comparable = (item) => item) {
|
|
9
|
+
const beforeById = new Map(before.map((item) => [keyOf(item), item]));
|
|
10
|
+
const afterById = new Map(after.map((item) => [keyOf(item), item]));
|
|
11
|
+
return {
|
|
12
|
+
added: [...afterById.values()].filter((item) => !beforeById.has(keyOf(item))),
|
|
13
|
+
removed: [...beforeById.values()].filter((item) => !afterById.has(keyOf(item))),
|
|
14
|
+
modified: [...afterById.values()].filter((item) => {
|
|
15
|
+
const previous = beforeById.get(keyOf(item));
|
|
16
|
+
return previous !== undefined && JSON.stringify(comparable(previous)) !== JSON.stringify(comparable(item));
|
|
17
|
+
}).map((afterItem) => ({ after: afterItem, before: beforeById.get(keyOf(afterItem)) })),
|
|
18
|
+
};
|
|
19
|
+
}
|
|
20
|
+
function diffById(before, after) {
|
|
21
|
+
return diffByKey(before, after, (item) => item.id, withoutId);
|
|
22
|
+
}
|
|
23
|
+
function mediaRegistryFields(media) {
|
|
24
|
+
return {
|
|
25
|
+
source: media.source,
|
|
26
|
+
mediaKind: media.mediaKind,
|
|
27
|
+
duration: media.duration,
|
|
28
|
+
sourceDigest: media.sourceDigest,
|
|
29
|
+
};
|
|
30
|
+
}
|
|
31
|
+
export function diffSnapshots(before, after) {
|
|
32
|
+
const clips = diffById(before.timeline.clips, after.timeline.clips);
|
|
33
|
+
const added = clips.added.map((clip) => ({ type: "ITEM_ADDED", itemId: clip.id, after: clip }));
|
|
34
|
+
const removed = clips.removed.map((clip) => ({ type: "ITEM_REMOVED", itemId: clip.id, before: clip }));
|
|
35
|
+
const modified = clips.modified.map(({ before: previous, after: current }) => ({
|
|
36
|
+
type: "ITEM_MODIFIED",
|
|
37
|
+
itemId: current.id,
|
|
38
|
+
before: previous,
|
|
39
|
+
after: current,
|
|
40
|
+
}));
|
|
41
|
+
const markers = diffById(before.timeline.markers, after.timeline.markers);
|
|
42
|
+
const markerChanges = [
|
|
43
|
+
...markers.added.map((marker) => ({ type: "MARKER_ADDED", marker })),
|
|
44
|
+
...markers.removed.map((marker) => ({ type: "MARKER_REMOVED", marker })),
|
|
45
|
+
...markers.modified.map(({ before: previous, after: current }) => ({
|
|
46
|
+
type: "MARKER_MODIFIED",
|
|
47
|
+
marker: current,
|
|
48
|
+
before: previous,
|
|
49
|
+
after: current,
|
|
50
|
+
})),
|
|
51
|
+
];
|
|
52
|
+
const captions = diffById(before.timeline.captions, after.timeline.captions);
|
|
53
|
+
const captionChanges = [
|
|
54
|
+
...captions.added.map((caption) => ({ type: "CAPTION_ADDED", caption })),
|
|
55
|
+
...captions.removed.map((caption) => ({ type: "CAPTION_REMOVED", caption })),
|
|
56
|
+
...captions.modified.map(({ before: previous, after: current }) => ({
|
|
57
|
+
type: "CAPTION_MODIFIED",
|
|
58
|
+
caption: current,
|
|
59
|
+
before: previous,
|
|
60
|
+
after: current,
|
|
61
|
+
})),
|
|
62
|
+
];
|
|
63
|
+
const storyElements = diffById(before.timeline.storyElements, after.timeline.storyElements);
|
|
64
|
+
const storyElementChanges = [
|
|
65
|
+
...storyElements.added.map((element) => ({ type: "STORY_ELEMENT_ADDED", element, after: element })),
|
|
66
|
+
...storyElements.removed.map((element) => ({ type: "STORY_ELEMENT_REMOVED", element, before: element })),
|
|
67
|
+
...storyElements.modified.map(({ before: previous, after: current }) => ({
|
|
68
|
+
type: "STORY_ELEMENT_MODIFIED",
|
|
69
|
+
element: current,
|
|
70
|
+
before: previous,
|
|
71
|
+
after: current,
|
|
72
|
+
})),
|
|
73
|
+
];
|
|
74
|
+
const media = diffByKey(before.media, after.media, (item) => item.mediaId, mediaRegistryFields);
|
|
75
|
+
const mediaChanges = [
|
|
76
|
+
...media.added.map((item) => ({ type: "MEDIA_ADDED", media: item, after: item })),
|
|
77
|
+
...media.removed.map((item) => ({ type: "MEDIA_REMOVED", media: item, before: item })),
|
|
78
|
+
...media.modified.map(({ before: previous, after: current }) => ({
|
|
79
|
+
type: "MEDIA_MODIFIED",
|
|
80
|
+
media: current,
|
|
81
|
+
before: previous,
|
|
82
|
+
after: current,
|
|
83
|
+
})),
|
|
84
|
+
];
|
|
85
|
+
const affectedRanges = uniqueRanges([
|
|
86
|
+
...added.flatMap((change) => rangesForClip(change.after)),
|
|
87
|
+
...removed.flatMap((change) => rangesForClip(change.before)),
|
|
88
|
+
...modified.flatMap((change) => [...rangesForClip(change.before), ...rangesForClip(change.after)]),
|
|
89
|
+
...markerChanges.flatMap(({ marker, before: previous }) => [{
|
|
90
|
+
start: previous?.start ?? marker.start,
|
|
91
|
+
end: Math.max(previous ? previous.start + previous.duration : 0, marker.start + marker.duration),
|
|
92
|
+
startTime: previous?.startTime ?? marker.startTime,
|
|
93
|
+
durationTime: previous?.durationTime ?? marker.durationTime,
|
|
94
|
+
}]),
|
|
95
|
+
...captionChanges.flatMap(({ caption, before: previous }) => [{
|
|
96
|
+
start: previous?.start ?? caption.start,
|
|
97
|
+
end: Math.max(previous ? previous.start + previous.duration : 0, caption.start + caption.duration),
|
|
98
|
+
startTime: previous?.startTime ?? caption.startTime,
|
|
99
|
+
durationTime: previous?.durationTime ?? caption.durationTime,
|
|
100
|
+
}]),
|
|
101
|
+
...storyElementChanges.flatMap(({ element, before: previous }) => [{
|
|
102
|
+
start: previous?.start ?? element.start,
|
|
103
|
+
end: Math.max(previous ? previous.start + previous.duration : 0, element.start + element.duration),
|
|
104
|
+
}]),
|
|
105
|
+
]);
|
|
106
|
+
return {
|
|
107
|
+
from: before.revision,
|
|
108
|
+
to: after.revision,
|
|
109
|
+
added,
|
|
110
|
+
removed,
|
|
111
|
+
modified,
|
|
112
|
+
durationDelta: after.timeline.duration - before.timeline.duration,
|
|
113
|
+
durationDeltaTime: decimalToRational(after.timeline.duration - before.timeline.duration),
|
|
114
|
+
markerChanges,
|
|
115
|
+
captionChanges,
|
|
116
|
+
storyElementChanges,
|
|
117
|
+
mediaChanges,
|
|
118
|
+
affectedRanges,
|
|
119
|
+
};
|
|
120
|
+
}
|
|
121
|
+
function uniqueRanges(ranges) {
|
|
122
|
+
const seen = new Set();
|
|
123
|
+
return ranges.filter((range) => {
|
|
124
|
+
const key = [
|
|
125
|
+
range.start,
|
|
126
|
+
range.end,
|
|
127
|
+
range.startTime?.value ?? "",
|
|
128
|
+
range.startTime?.timescale ?? "",
|
|
129
|
+
range.durationTime?.value ?? "",
|
|
130
|
+
range.durationTime?.timescale ?? "",
|
|
131
|
+
].join("/");
|
|
132
|
+
if (seen.has(key))
|
|
133
|
+
return false;
|
|
134
|
+
seen.add(key);
|
|
135
|
+
return true;
|
|
136
|
+
});
|
|
137
|
+
}
|
|
138
|
+
function decimalToRational(value) {
|
|
139
|
+
const text = value.toFixed(6).replace(/0+$/, "").replace(/\.$/, "");
|
|
140
|
+
if (!text.includes("."))
|
|
141
|
+
return { value: text || "0", timescale: "1" };
|
|
142
|
+
const decimals = text.split(".")[1].length;
|
|
143
|
+
const scale = 10 ** decimals;
|
|
144
|
+
return { value: String(Math.round(value * scale)), timescale: String(scale) };
|
|
145
|
+
}
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
export {};
|
|
@@ -0,0 +1,83 @@
|
|
|
1
|
+
const CLARIFICATION_OPTIONS = [
|
|
2
|
+
"trim_to_duration",
|
|
3
|
+
"blade_at_playhead",
|
|
4
|
+
"delete_range",
|
|
5
|
+
];
|
|
6
|
+
/** Resolve only the explicit destructive language supported by Framekit. */
|
|
7
|
+
export function resolveEditingIntent(request) {
|
|
8
|
+
const normalized = request.trim().replace(/\s+/g, " ").toLowerCase();
|
|
9
|
+
const trimMatch = normalized.match(/^cut at (\d+(?:\.\d+)?) seconds? and remove the rest$/);
|
|
10
|
+
if (trimMatch) {
|
|
11
|
+
const duration = secondsToRational(trimMatch[1]);
|
|
12
|
+
return {
|
|
13
|
+
status: "resolved",
|
|
14
|
+
destructive: true,
|
|
15
|
+
previewRequired: true,
|
|
16
|
+
previewTool: "editor.native.trim-to-duration.preview",
|
|
17
|
+
operation: { type: "trim_to_duration", duration },
|
|
18
|
+
affectedRange: { kind: "tail", start: duration, end: "sequence-end" },
|
|
19
|
+
};
|
|
20
|
+
}
|
|
21
|
+
const bladeMatch = normalized.match(/^blade at (\d+(?:\.\d+)?) seconds?$/);
|
|
22
|
+
if (bladeMatch) {
|
|
23
|
+
const playheadTime = secondsToRational(bladeMatch[1]);
|
|
24
|
+
return {
|
|
25
|
+
status: "resolved",
|
|
26
|
+
destructive: true,
|
|
27
|
+
previewRequired: true,
|
|
28
|
+
previewTool: "editor.native.blade.preview",
|
|
29
|
+
operation: { type: "blade_at_playhead", playheadTime },
|
|
30
|
+
affectedRange: { kind: "playhead", at: playheadTime },
|
|
31
|
+
};
|
|
32
|
+
}
|
|
33
|
+
const deleteMatch = normalized.match(/^remove (\d+(?:\.\d+)?)\s*(?:-|–|—|to)\s*(\d+(?:\.\d+)?) seconds?$/);
|
|
34
|
+
if (deleteMatch) {
|
|
35
|
+
const start = secondsToRational(deleteMatch[1]);
|
|
36
|
+
const end = secondsToRational(deleteMatch[2]);
|
|
37
|
+
if (compareDecimalSeconds(deleteMatch[2], deleteMatch[1]) > 0) {
|
|
38
|
+
return {
|
|
39
|
+
status: "resolved",
|
|
40
|
+
destructive: true,
|
|
41
|
+
previewRequired: true,
|
|
42
|
+
previewTool: "editor.native.delete-range.preview",
|
|
43
|
+
operation: { type: "delete_range", range: { start, end } },
|
|
44
|
+
affectedRange: { kind: "range", start, end },
|
|
45
|
+
};
|
|
46
|
+
}
|
|
47
|
+
}
|
|
48
|
+
return {
|
|
49
|
+
status: "clarification_required",
|
|
50
|
+
destructive: true,
|
|
51
|
+
previewRequired: false,
|
|
52
|
+
question: "Which editing operation should Framekit perform?",
|
|
53
|
+
options: [...CLARIFICATION_OPTIONS],
|
|
54
|
+
};
|
|
55
|
+
}
|
|
56
|
+
function secondsToRational(seconds) {
|
|
57
|
+
if (!seconds.includes("."))
|
|
58
|
+
return { value: seconds, timescale: "1" };
|
|
59
|
+
const [whole, fraction = ""] = seconds.split(".");
|
|
60
|
+
const value = `${whole}${fraction}`.replace(/^0+(?=\d)/, "");
|
|
61
|
+
return {
|
|
62
|
+
value,
|
|
63
|
+
timescale: `1${"0".repeat(fraction.length)}`,
|
|
64
|
+
};
|
|
65
|
+
}
|
|
66
|
+
function compareDecimalSeconds(left, right) {
|
|
67
|
+
const [leftWhole, leftFraction = ""] = normalizeDecimalSeconds(left);
|
|
68
|
+
const [rightWhole, rightFraction = ""] = normalizeDecimalSeconds(right);
|
|
69
|
+
if (leftWhole.length !== rightWhole.length)
|
|
70
|
+
return leftWhole.length > rightWhole.length ? 1 : -1;
|
|
71
|
+
if (leftWhole !== rightWhole)
|
|
72
|
+
return leftWhole > rightWhole ? 1 : -1;
|
|
73
|
+
const precision = Math.max(leftFraction.length, rightFraction.length);
|
|
74
|
+
const paddedLeft = leftFraction.padEnd(precision, "0");
|
|
75
|
+
const paddedRight = rightFraction.padEnd(precision, "0");
|
|
76
|
+
if (paddedLeft === paddedRight)
|
|
77
|
+
return 0;
|
|
78
|
+
return paddedLeft > paddedRight ? 1 : -1;
|
|
79
|
+
}
|
|
80
|
+
function normalizeDecimalSeconds(seconds) {
|
|
81
|
+
const [whole, fraction = ""] = seconds.split(".");
|
|
82
|
+
return [whole.replace(/^0+(?=\d)/, ""), fraction];
|
|
83
|
+
}
|
|
@@ -0,0 +1,8 @@
|
|
|
1
|
+
export * from "./domain/types.js";
|
|
2
|
+
export * from "./runtime.js";
|
|
3
|
+
export * from "./diff/diff.js";
|
|
4
|
+
export * from "./verification/verification.js";
|
|
5
|
+
export * from "./editing/intent.js";
|
|
6
|
+
export * from "./capabilities.js";
|
|
7
|
+
export * from "./snapshot-digest.js";
|
|
8
|
+
export * from "./speech/filler-removal.js";
|