@tangle-network/agent-app 0.63.29 → 0.63.31
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/{DesignCanvas-3DGZQOD7.js → DesignCanvas-VKZ7Y3JU.js} +2 -3
- package/dist/{DesignCanvasEditor-OG4QY5WJ.js → DesignCanvasEditor-3V53YLLZ.js} +2 -3
- package/dist/agent-profiles/d1.js +4 -3
- package/dist/agent-profiles/d1.js.map +1 -1
- package/dist/agent-profiles/index.js +4 -3
- package/dist/alerting/github.d.ts +33 -0
- package/dist/alerting/index.d.ts +1 -0
- package/dist/alerting/index.js +47 -0
- package/dist/alerting/index.js.map +1 -1
- package/dist/app-auth/index.js +1 -2
- package/dist/app-auth/index.js.map +1 -1
- package/dist/assistant/index.js +4 -4
- package/dist/billing/index.d.ts +15 -0
- package/dist/billing/index.js +5 -3
- package/dist/chat-routes/default-backend.d.ts +19 -2
- package/dist/chat-routes/hybrid-producer.d.ts +7 -2
- package/dist/chat-routes/index.js +16 -15
- package/dist/chat-routes/index.js.map +1 -1
- package/dist/chat-routes/route-storage.d.ts +1 -1
- package/dist/chat-routes/router-producer.d.ts +2 -1
- package/dist/chat-routes/turn-route-contracts.d.ts +1 -1
- package/dist/chat-store/index.js +34 -4
- package/dist/chat-store/index.js.map +1 -1
- package/dist/chat-store/schema.d.ts +286 -0
- package/dist/{chunk-6JEDSKFH.js → chunk-2SDX3OC4.js} +32 -24
- package/dist/{chunk-6JEDSKFH.js.map → chunk-2SDX3OC4.js.map} +1 -1
- package/dist/{chunk-DCJCZ7EP.js → chunk-4CEIZZTH.js} +44 -26
- package/dist/chunk-4CEIZZTH.js.map +1 -0
- package/dist/{chunk-WL7PZK7Q.js → chunk-4PIN6QYQ.js} +43 -1
- package/dist/chunk-4PIN6QYQ.js.map +1 -0
- package/dist/{chunk-6UMIOEDR.js → chunk-AZRPDSRQ.js} +3 -3
- package/dist/{chunk-6LMM3OVX.js → chunk-BMCC2BUP.js} +3 -3
- package/dist/{chunk-36HSG7HU.js → chunk-CRZXEKCX.js} +2 -2
- package/dist/chunk-F4XBNR5L.js +16 -0
- package/dist/chunk-F4XBNR5L.js.map +1 -0
- package/dist/chunk-GY4IPYG4.js +40 -0
- package/dist/chunk-GY4IPYG4.js.map +1 -0
- package/dist/{chunk-QUT3T2IN.js → chunk-L3QR274L.js} +11 -3
- package/dist/chunk-L3QR274L.js.map +1 -0
- package/dist/{chunk-6OG4244Y.js → chunk-MTKD2FN5.js} +2 -251
- package/dist/chunk-MTKD2FN5.js.map +1 -0
- package/dist/{chunk-56JUV4DK.js → chunk-NDXQFEZQ.js} +3332 -3014
- package/dist/chunk-NDXQFEZQ.js.map +1 -0
- package/dist/chunk-NSWLZTJX.js +645 -0
- package/dist/chunk-NSWLZTJX.js.map +1 -0
- package/dist/chunk-PU6AWIRE.js +252 -0
- package/dist/chunk-PU6AWIRE.js.map +1 -0
- package/dist/{chunk-JKECSYDB.js → chunk-PV3GSLUY.js} +3 -3
- package/dist/{chunk-7Y7U7U7X.js → chunk-Q7RSHLEV.js} +5 -3
- package/dist/{chunk-7Y7U7U7X.js.map → chunk-Q7RSHLEV.js.map} +1 -1
- package/dist/{chunk-HRBF4B5L.js → chunk-TUJ4277Q.js} +1 -14
- package/dist/chunk-TUJ4277Q.js.map +1 -0
- package/dist/{chunk-57XPEL7X.js → chunk-V42C72V5.js} +25 -2
- package/dist/chunk-V42C72V5.js.map +1 -0
- package/dist/{chunk-FCYHDENJ.js → chunk-VOIVDEAV.js} +2 -2
- package/dist/{chunk-ACB7KOQ6.js → chunk-WSQSKYXP.js} +4 -4
- package/dist/{chunk-F6J5J4H6.js → chunk-WYQTPFPI.js} +26 -2
- package/dist/chunk-WYQTPFPI.js.map +1 -0
- package/dist/{chunk-PFTOGTHH.js → chunk-Z3IJ7XEW.js} +3 -3
- package/dist/{chunk-ZD2AUFIT.js → chunk-ZGGEYYEQ.js} +3 -3
- package/dist/{chunk-O5AUJQIA.js → chunk-ZNWJJRHP.js} +2 -2
- package/dist/design-canvas/index.js +1 -2
- package/dist/design-canvas/index.js.map +1 -1
- package/dist/design-canvas-react/engine.js +1 -2
- package/dist/design-canvas-react/index.js +2 -3
- package/dist/design-canvas-react/index.js.map +1 -1
- package/dist/design-canvas-react/lazy.js +1 -1
- package/dist/media/generate-request.d.ts +27 -1
- package/dist/media/index.js +36 -426
- package/dist/media/index.js.map +1 -1
- package/dist/media/router-generation.d.ts +7 -0
- package/dist/model-resolution/index.js +1 -1
- package/dist/operator/gateway-keys.d.ts +44 -0
- package/dist/operator/index.d.ts +1 -0
- package/dist/operator/index.js +55 -1
- package/dist/operator/index.js.map +1 -1
- package/dist/plans/decision.d.ts +31 -0
- package/dist/plans/drizzle.js +1 -1
- package/dist/plans/index.js +5 -1
- package/dist/platform/billing.d.ts +3 -2
- package/dist/platform/deployment.d.ts +21 -0
- package/dist/platform/index.d.ts +1 -0
- package/dist/platform/index.js +30 -10
- package/dist/platform/index.js.map +1 -1
- package/dist/preset-cloudflare/index.js +9 -8
- package/dist/preset-cloudflare/index.js.map +1 -1
- package/dist/public-consultation/index.d.ts +1 -1
- package/dist/public-consultation/index.js +14 -13
- package/dist/public-consultation/index.js.map +1 -1
- package/dist/sandbox/computer-files.d.ts +67 -0
- package/dist/sandbox/computer-receipts.d.ts +46 -0
- package/dist/sandbox/computer-step.d.ts +78 -0
- package/dist/sandbox/index.d.ts +5 -0
- package/dist/sandbox/index.js +34 -5
- package/dist/sandbox/router-model-policy.d.ts +31 -0
- package/dist/sandbox/router-models.d.ts +26 -0
- package/dist/sandbox/sandbox-run-tool.d.ts +5 -4
- package/dist/sequences/index.js +1 -2
- package/dist/sequences/index.js.map +1 -1
- package/dist/spend/drizzle.d.ts +195 -0
- package/dist/spend/drizzle.js +22 -0
- package/dist/spend/drizzle.js.map +1 -1
- package/dist/stream/index.js +2 -2
- package/dist/studio/generated-media/flows.d.ts +240 -0
- package/dist/studio/generated-media/index.d.ts +3 -1
- package/dist/studio/generated-media/index.js +357 -138
- package/dist/studio/generated-media/index.js.map +1 -1
- package/dist/studio/index.js +18 -16
- package/dist/studio-react/index.js +28 -26
- package/dist/studio-react/index.js.map +1 -1
- package/dist/teams/index.d.ts +1 -0
- package/dist/teams/index.js +16 -0
- package/dist/teams/index.js.map +1 -1
- package/dist/teams/invitations-api.js +1 -1
- package/dist/teams/members-api.d.ts +5 -3
- package/dist/teams/members-api.js +1 -1
- package/dist/teams/thread-access.d.ts +22 -0
- package/dist/tools/index.js +5 -4
- package/dist/web/index.js +4 -6
- package/dist/web-react/index.js +4 -4
- package/dist/work-product/index.js +3 -2
- package/dist/work-product/index.js.map +1 -1
- package/dist/workspace-export/d1.d.ts +1 -1
- package/dist/workspace-export/index.js +9 -2
- package/dist/workspace-export/index.js.map +1 -1
- package/package.json +1 -1
- package/dist/chunk-56JUV4DK.js.map +0 -1
- package/dist/chunk-57XPEL7X.js.map +0 -1
- package/dist/chunk-6OG4244Y.js.map +0 -1
- package/dist/chunk-6Z7TZVKZ.js +0 -26
- package/dist/chunk-6Z7TZVKZ.js.map +0 -1
- package/dist/chunk-DCJCZ7EP.js.map +0 -1
- package/dist/chunk-F6J5J4H6.js.map +0 -1
- package/dist/chunk-HRBF4B5L.js.map +0 -1
- package/dist/chunk-QUT3T2IN.js.map +0 -1
- package/dist/chunk-WL7PZK7Q.js.map +0 -1
- /package/dist/{DesignCanvas-3DGZQOD7.js.map → DesignCanvas-VKZ7Y3JU.js.map} +0 -0
- /package/dist/{DesignCanvasEditor-OG4QY5WJ.js.map → DesignCanvasEditor-3V53YLLZ.js.map} +0 -0
- /package/dist/{chunk-6UMIOEDR.js.map → chunk-AZRPDSRQ.js.map} +0 -0
- /package/dist/{chunk-6LMM3OVX.js.map → chunk-BMCC2BUP.js.map} +0 -0
- /package/dist/{chunk-36HSG7HU.js.map → chunk-CRZXEKCX.js.map} +0 -0
- /package/dist/{chunk-JKECSYDB.js.map → chunk-PV3GSLUY.js.map} +0 -0
- /package/dist/{chunk-FCYHDENJ.js.map → chunk-VOIVDEAV.js.map} +0 -0
- /package/dist/{chunk-ACB7KOQ6.js.map → chunk-WSQSKYXP.js.map} +0 -0
- /package/dist/{chunk-PFTOGTHH.js.map → chunk-Z3IJ7XEW.js.map} +0 -0
- /package/dist/{chunk-ZD2AUFIT.js.map → chunk-ZGGEYYEQ.js.map} +0 -0
- /package/dist/{chunk-O5AUJQIA.js.map → chunk-ZNWJJRHP.js.map} +0 -0
|
@@ -0,0 +1,645 @@
|
|
|
1
|
+
import {
|
|
2
|
+
isGenerationType
|
|
3
|
+
} from "./chunk-MTKD2FN5.js";
|
|
4
|
+
import {
|
|
5
|
+
isBlockedFetchHostname
|
|
6
|
+
} from "./chunk-V42C72V5.js";
|
|
7
|
+
import {
|
|
8
|
+
validateVaultFilePath
|
|
9
|
+
} from "./chunk-FRAICFTZ.js";
|
|
10
|
+
|
|
11
|
+
// src/studio/generated-media/output.ts
|
|
12
|
+
var DEFAULT_GENERATED_OUTPUT_PATHS = {
|
|
13
|
+
image: "generated/images",
|
|
14
|
+
video: "generated/videos",
|
|
15
|
+
avatar: "generated/avatars",
|
|
16
|
+
speech: "generated/audio",
|
|
17
|
+
transcription: "generated/transcripts"
|
|
18
|
+
};
|
|
19
|
+
var GENERATED_OUTPUT_CONFIG = {
|
|
20
|
+
image: {
|
|
21
|
+
defaultPath: DEFAULT_GENERATED_OUTPUT_PATHS.image,
|
|
22
|
+
extensions: /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg", ".webp", ".gif", ".avif"]),
|
|
23
|
+
defaultExtension: ".png",
|
|
24
|
+
defaultMimeType: "image/png",
|
|
25
|
+
frontmatterType: "generated-image",
|
|
26
|
+
title: "Studio generated image"
|
|
27
|
+
},
|
|
28
|
+
video: {
|
|
29
|
+
defaultPath: DEFAULT_GENERATED_OUTPUT_PATHS.video,
|
|
30
|
+
extensions: /* @__PURE__ */ new Set([".mp4", ".mov", ".m4v", ".webm"]),
|
|
31
|
+
defaultExtension: ".mp4",
|
|
32
|
+
defaultMimeType: "video/mp4",
|
|
33
|
+
frontmatterType: "generated-video",
|
|
34
|
+
title: "Studio generated video"
|
|
35
|
+
},
|
|
36
|
+
avatar: {
|
|
37
|
+
defaultPath: DEFAULT_GENERATED_OUTPUT_PATHS.avatar,
|
|
38
|
+
extensions: /* @__PURE__ */ new Set([".mp4", ".mov", ".m4v", ".webm"]),
|
|
39
|
+
defaultExtension: ".mp4",
|
|
40
|
+
defaultMimeType: "video/mp4",
|
|
41
|
+
frontmatterType: "generated-avatar",
|
|
42
|
+
title: "Studio generated avatar"
|
|
43
|
+
},
|
|
44
|
+
speech: {
|
|
45
|
+
defaultPath: DEFAULT_GENERATED_OUTPUT_PATHS.speech,
|
|
46
|
+
extensions: /* @__PURE__ */ new Set([".mp3", ".wav", ".m4a", ".ogg", ".webm", ".aac"]),
|
|
47
|
+
defaultExtension: ".mp3",
|
|
48
|
+
defaultMimeType: "audio/mpeg",
|
|
49
|
+
frontmatterType: "generated-audio",
|
|
50
|
+
title: "Studio generated audio"
|
|
51
|
+
},
|
|
52
|
+
transcription: {
|
|
53
|
+
defaultPath: DEFAULT_GENERATED_OUTPUT_PATHS.transcription,
|
|
54
|
+
extensions: /* @__PURE__ */ new Set([".md"]),
|
|
55
|
+
defaultExtension: ".md",
|
|
56
|
+
defaultMimeType: "text/markdown",
|
|
57
|
+
frontmatterType: "generated-transcript",
|
|
58
|
+
title: "Studio generated transcript"
|
|
59
|
+
}
|
|
60
|
+
};
|
|
61
|
+
function normalizeGeneratedOutputPath(type, input) {
|
|
62
|
+
const trimmed = (input ?? "").trim().replace(/^\/+|\/+$/g, "");
|
|
63
|
+
const normalized = trimmed.replace(/^vault\/+/i, "") || GENERATED_OUTPUT_CONFIG[type].defaultPath;
|
|
64
|
+
validateVaultFilePath(normalized);
|
|
65
|
+
return normalized;
|
|
66
|
+
}
|
|
67
|
+
function resolveGeneratedVaultPath(input) {
|
|
68
|
+
const config = GENERATED_OUTPUT_CONFIG[input.type];
|
|
69
|
+
const outputPath = normalizeGeneratedOutputPath(input.type, input.outputPath);
|
|
70
|
+
const fileName = input.fileName.trim();
|
|
71
|
+
validateVaultFilePath(fileName);
|
|
72
|
+
const vaultPath = hasConfiguredExtension(outputPath, config.extensions) ? outputPath : `${outputPath}/${fileName}`;
|
|
73
|
+
validateVaultFilePath(vaultPath);
|
|
74
|
+
return vaultPath;
|
|
75
|
+
}
|
|
76
|
+
function extensionForGeneratedMimeType(type, mimeType) {
|
|
77
|
+
const clean = mimeType.toLowerCase().split(";")[0]?.trim();
|
|
78
|
+
if (clean === "image/jpeg") return ".jpg";
|
|
79
|
+
if (clean === "image/webp") return ".webp";
|
|
80
|
+
if (clean === "image/gif") return ".gif";
|
|
81
|
+
if (clean === "image/avif") return ".avif";
|
|
82
|
+
if (clean === "video/webm") return ".webm";
|
|
83
|
+
if (clean === "video/quicktime") return ".mov";
|
|
84
|
+
if (clean === "audio/wav" || clean === "audio/x-wav") return ".wav";
|
|
85
|
+
if (clean === "audio/mp4" || clean === "audio/x-m4a") return ".m4a";
|
|
86
|
+
if (clean === "audio/ogg" || clean === "application/ogg") return ".ogg";
|
|
87
|
+
if (clean === "audio/webm") return ".webm";
|
|
88
|
+
if (clean === "audio/aac") return ".aac";
|
|
89
|
+
return GENERATED_OUTPUT_CONFIG[type].defaultExtension;
|
|
90
|
+
}
|
|
91
|
+
function validateGeneratedMediaSourceUrl(value, type) {
|
|
92
|
+
let url;
|
|
93
|
+
try {
|
|
94
|
+
url = new URL(value);
|
|
95
|
+
} catch {
|
|
96
|
+
throw new Error(`Generated ${generatedMediaLabel(type)} provider returned an invalid URL`);
|
|
97
|
+
}
|
|
98
|
+
if (url.protocol !== "https:") {
|
|
99
|
+
throw new Error(`Generated ${generatedMediaLabel(type)} provider returned a non-https URL`);
|
|
100
|
+
}
|
|
101
|
+
if (isBlockedFetchHostname(url.hostname)) {
|
|
102
|
+
throw new Error(`Generated ${generatedMediaLabel(type)} provider returned a private network URL`);
|
|
103
|
+
}
|
|
104
|
+
return url.toString();
|
|
105
|
+
}
|
|
106
|
+
function generatedExtensionFromUrl(value, type) {
|
|
107
|
+
const ext = fileExtension(new URL(value).pathname);
|
|
108
|
+
if (ext && GENERATED_OUTPUT_CONFIG[type].extensions.has(ext)) return ext;
|
|
109
|
+
return null;
|
|
110
|
+
}
|
|
111
|
+
function generatedMimeTypeFromUrl(value, type) {
|
|
112
|
+
const ext = generatedExtensionFromUrl(value, type);
|
|
113
|
+
if (ext === ".jpg" || ext === ".jpeg") return "image/jpeg";
|
|
114
|
+
if (ext === ".webp") return "image/webp";
|
|
115
|
+
if (ext === ".gif") return "image/gif";
|
|
116
|
+
if (ext === ".avif") return "image/avif";
|
|
117
|
+
if (ext === ".webm" && type !== "speech") return "video/webm";
|
|
118
|
+
if (ext === ".mov") return "video/quicktime";
|
|
119
|
+
if (ext === ".wav") return "audio/wav";
|
|
120
|
+
if (ext === ".m4a") return "audio/mp4";
|
|
121
|
+
if (ext === ".ogg") return "audio/ogg";
|
|
122
|
+
if (ext === ".webm") return "audio/webm";
|
|
123
|
+
if (ext === ".aac") return "audio/aac";
|
|
124
|
+
if (ext === ".mp3") return "audio/mpeg";
|
|
125
|
+
if (ext === ".mp4") return "video/mp4";
|
|
126
|
+
return null;
|
|
127
|
+
}
|
|
128
|
+
function hasConfiguredExtension(path, extensions) {
|
|
129
|
+
const ext = fileExtension(path);
|
|
130
|
+
return Boolean(ext && extensions.has(ext));
|
|
131
|
+
}
|
|
132
|
+
function fileExtension(path) {
|
|
133
|
+
const name = path.split("/").pop() ?? path;
|
|
134
|
+
const dotIndex = name.lastIndexOf(".");
|
|
135
|
+
if (dotIndex === -1) return null;
|
|
136
|
+
return name.slice(dotIndex).toLowerCase();
|
|
137
|
+
}
|
|
138
|
+
function generatedMediaLabel(type) {
|
|
139
|
+
if (type === "speech") return "audio";
|
|
140
|
+
return type;
|
|
141
|
+
}
|
|
142
|
+
function isGeneratedMediaType(value) {
|
|
143
|
+
return value === "image" || value === "video" || value === "avatar" || value === "speech";
|
|
144
|
+
}
|
|
145
|
+
|
|
146
|
+
// src/media/generate-request.ts
|
|
147
|
+
var MIN_IMAGE_COUNT = 1;
|
|
148
|
+
var MAX_IMAGE_COUNT = 4;
|
|
149
|
+
function requiredText(value) {
|
|
150
|
+
return typeof value === "string" && value.trim() ? value.trim() : null;
|
|
151
|
+
}
|
|
152
|
+
function validateGenerateRequest(type, body, prompt) {
|
|
153
|
+
if (type !== "transcription" && type !== "avatar" && !prompt) {
|
|
154
|
+
return { succeeded: false, error: "prompt is required" };
|
|
155
|
+
}
|
|
156
|
+
if (type === "avatar") {
|
|
157
|
+
const audioUrl = requiredHttpsUrl(body.audioUrl, "audioUrl");
|
|
158
|
+
if (!audioUrl.succeeded) return audioUrl;
|
|
159
|
+
const imageUrl = optionalHttpsUrl(body.imageUrl, "imageUrl");
|
|
160
|
+
if (!imageUrl.succeeded) return imageUrl;
|
|
161
|
+
return {
|
|
162
|
+
succeeded: true,
|
|
163
|
+
value: {
|
|
164
|
+
promptLabel: prompt || audioUrl.value,
|
|
165
|
+
audioUrl: audioUrl.value,
|
|
166
|
+
imageUrl: imageUrl.value,
|
|
167
|
+
avatarId: body.avatarId?.trim() || void 0
|
|
168
|
+
}
|
|
169
|
+
};
|
|
170
|
+
}
|
|
171
|
+
if (type === "transcription") {
|
|
172
|
+
const audioUrl = requiredHttpsUrl(body.audioUrl, "audioUrl");
|
|
173
|
+
if (!audioUrl.succeeded) return audioUrl;
|
|
174
|
+
return {
|
|
175
|
+
succeeded: true,
|
|
176
|
+
value: {
|
|
177
|
+
promptLabel: prompt || audioUrl.value,
|
|
178
|
+
audioUrl: audioUrl.value,
|
|
179
|
+
language: body.language?.trim() || void 0,
|
|
180
|
+
responseFormat: body.responseFormat?.trim() || void 0,
|
|
181
|
+
temperature: numberValue(body.temperature)
|
|
182
|
+
}
|
|
183
|
+
};
|
|
184
|
+
}
|
|
185
|
+
if (type === "video") {
|
|
186
|
+
const referenceImageUrl = optionalHttpsUrl(body.referenceImageUrl, "referenceImageUrl");
|
|
187
|
+
if (!referenceImageUrl.succeeded) return referenceImageUrl;
|
|
188
|
+
return {
|
|
189
|
+
succeeded: true,
|
|
190
|
+
value: {
|
|
191
|
+
promptLabel: prompt,
|
|
192
|
+
duration: body.duration,
|
|
193
|
+
resolution: body.resolution,
|
|
194
|
+
aspectRatio: body.aspectRatio?.trim() || void 0,
|
|
195
|
+
referenceImageUrl: referenceImageUrl.value
|
|
196
|
+
}
|
|
197
|
+
};
|
|
198
|
+
}
|
|
199
|
+
return {
|
|
200
|
+
succeeded: true,
|
|
201
|
+
value: {
|
|
202
|
+
promptLabel: prompt,
|
|
203
|
+
size: body.size,
|
|
204
|
+
quality: body.quality,
|
|
205
|
+
n: body.n,
|
|
206
|
+
duration: body.duration,
|
|
207
|
+
resolution: body.resolution,
|
|
208
|
+
voice: body.voice
|
|
209
|
+
}
|
|
210
|
+
};
|
|
211
|
+
}
|
|
212
|
+
function imageCountForRequest(value) {
|
|
213
|
+
if (value == null) return { succeeded: true, value: 1 };
|
|
214
|
+
const count = typeof value === "number" ? value : Number.NaN;
|
|
215
|
+
if (!Number.isInteger(count) || count < MIN_IMAGE_COUNT || count > MAX_IMAGE_COUNT) {
|
|
216
|
+
return { succeeded: false, error: `Images must be an integer between ${MIN_IMAGE_COUNT} and ${MAX_IMAGE_COUNT}` };
|
|
217
|
+
}
|
|
218
|
+
return { succeeded: true, value: count };
|
|
219
|
+
}
|
|
220
|
+
function modelForRequest(type, body, defaults) {
|
|
221
|
+
return body.model?.trim() || defaults[type];
|
|
222
|
+
}
|
|
223
|
+
function checkGenerateRequest(body, defaults) {
|
|
224
|
+
const workspaceId = requiredText(body.workspaceId);
|
|
225
|
+
const type = body.type;
|
|
226
|
+
const prompt = body.prompt?.trim() ?? "";
|
|
227
|
+
if (!workspaceId || !type) return { succeeded: false, error: "Missing workspaceId or type" };
|
|
228
|
+
if (!isGenerationType(type)) {
|
|
229
|
+
return { succeeded: false, error: "Invalid type. Must be one of: image, video, speech, avatar, transcription" };
|
|
230
|
+
}
|
|
231
|
+
const inputs = validateGenerateRequest(type, body, prompt);
|
|
232
|
+
if (!inputs.succeeded) return inputs;
|
|
233
|
+
const imageCount = type === "image" ? imageCountForRequest(body.n) : { succeeded: true, value: 1 };
|
|
234
|
+
if (!imageCount.succeeded) return imageCount;
|
|
235
|
+
let outputPath;
|
|
236
|
+
try {
|
|
237
|
+
outputPath = normalizeGeneratedOutputPath(type, body.outputPath?.trim() || null);
|
|
238
|
+
} catch (err) {
|
|
239
|
+
return { succeeded: false, error: err instanceof Error ? err.message : `Invalid ${type} output path` };
|
|
240
|
+
}
|
|
241
|
+
const negativePrompt = body.negativePrompt?.trim() || void 0;
|
|
242
|
+
return {
|
|
243
|
+
succeeded: true,
|
|
244
|
+
value: {
|
|
245
|
+
workspaceId,
|
|
246
|
+
type,
|
|
247
|
+
prompt,
|
|
248
|
+
negativePrompt,
|
|
249
|
+
effectivePrompt: negativePrompt ? `${prompt}
|
|
250
|
+
|
|
251
|
+
Avoid: ${negativePrompt}` : prompt,
|
|
252
|
+
inputs: inputs.value,
|
|
253
|
+
requestInputs: type === "image" ? { ...inputs.value, n: imageCount.value } : inputs.value,
|
|
254
|
+
imageCount: imageCount.value,
|
|
255
|
+
model: modelForRequest(type, body, defaults),
|
|
256
|
+
clientRequestId: requiredText(body.clientRequestId) ?? void 0,
|
|
257
|
+
outputPath
|
|
258
|
+
}
|
|
259
|
+
};
|
|
260
|
+
}
|
|
261
|
+
function requiredHttpsUrl(value, field) {
|
|
262
|
+
const text3 = requiredText(value);
|
|
263
|
+
if (!text3) return { succeeded: false, error: `${field} is required` };
|
|
264
|
+
return validateExternalHttpsUrl(text3, field);
|
|
265
|
+
}
|
|
266
|
+
function optionalHttpsUrl(value, field) {
|
|
267
|
+
const text3 = requiredText(value);
|
|
268
|
+
if (!text3) return { succeeded: true, value: void 0 };
|
|
269
|
+
return validateExternalHttpsUrl(text3, field);
|
|
270
|
+
}
|
|
271
|
+
function validateExternalHttpsUrl(value, field) {
|
|
272
|
+
try {
|
|
273
|
+
const url = new URL(value);
|
|
274
|
+
if (url.protocol !== "https:") {
|
|
275
|
+
return { succeeded: false, error: `${field} must be an https URL` };
|
|
276
|
+
}
|
|
277
|
+
if (isBlockedFetchHostname(url.hostname)) {
|
|
278
|
+
return { succeeded: false, error: `${field} must not point to localhost or a private network address` };
|
|
279
|
+
}
|
|
280
|
+
return { succeeded: true, value };
|
|
281
|
+
} catch {
|
|
282
|
+
return { succeeded: false, error: `${field} must be a valid URL` };
|
|
283
|
+
}
|
|
284
|
+
}
|
|
285
|
+
function numberValue(value) {
|
|
286
|
+
return typeof value === "number" && Number.isFinite(value) ? value : void 0;
|
|
287
|
+
}
|
|
288
|
+
|
|
289
|
+
// src/media/generation-record.ts
|
|
290
|
+
function metadataResultUrl(value) {
|
|
291
|
+
if (!value || value.startsWith("data:")) return void 0;
|
|
292
|
+
return value;
|
|
293
|
+
}
|
|
294
|
+
function generationMetadata({
|
|
295
|
+
status,
|
|
296
|
+
provider,
|
|
297
|
+
negativePrompt,
|
|
298
|
+
publishPackage,
|
|
299
|
+
resultUrl,
|
|
300
|
+
providerResultUrl,
|
|
301
|
+
...fields
|
|
302
|
+
}) {
|
|
303
|
+
return {
|
|
304
|
+
generationStatus: status,
|
|
305
|
+
provider,
|
|
306
|
+
negativePrompt: negativePrompt || void 0,
|
|
307
|
+
...publishPackage ? { publishPackage } : {},
|
|
308
|
+
...fields,
|
|
309
|
+
resultUrl: metadataResultUrl(resultUrl),
|
|
310
|
+
providerResultUrl: metadataResultUrl(providerResultUrl)
|
|
311
|
+
};
|
|
312
|
+
}
|
|
313
|
+
function browserUsableSourceUrl(source) {
|
|
314
|
+
if (!source || source.authorization) return null;
|
|
315
|
+
return source.url;
|
|
316
|
+
}
|
|
317
|
+
function normalizeProviderJobStatus(value) {
|
|
318
|
+
const record = recordValue(value);
|
|
319
|
+
const rawStatus = text(record.status) ?? "running";
|
|
320
|
+
const resultUrl = [record, recordValue(record.result), recordValue(record.output)].map((source) => text(source.video_url) ?? text(source.url) ?? text(source.result_url) ?? text(source.output_url)).find(Boolean);
|
|
321
|
+
const error = text(record.error) ?? text(record.message);
|
|
322
|
+
const lower = rawStatus.toLowerCase();
|
|
323
|
+
if (lower === "failed" || lower === "error" || lower === "cancelled") {
|
|
324
|
+
return { status: "failed", providerStatus: rawStatus, error: error ?? `Provider job ${rawStatus}` };
|
|
325
|
+
}
|
|
326
|
+
if (lower === "completed" || lower === "complete" || lower === "succeeded" || lower === "success") {
|
|
327
|
+
if (!resultUrl) {
|
|
328
|
+
return { status: "failed", providerStatus: rawStatus, error: "Provider job completed without a result URL" };
|
|
329
|
+
}
|
|
330
|
+
return { status: "succeeded", providerStatus: rawStatus, resultUrl };
|
|
331
|
+
}
|
|
332
|
+
if (resultUrl) return { status: "succeeded", providerStatus: rawStatus, resultUrl };
|
|
333
|
+
return { status: "running", providerStatus: rawStatus };
|
|
334
|
+
}
|
|
335
|
+
function validProviderImages(value) {
|
|
336
|
+
if (!Array.isArray(value)) return [];
|
|
337
|
+
return value.filter((image) => Boolean(requiredText(image.url) || requiredText(image.b64_json)));
|
|
338
|
+
}
|
|
339
|
+
function providerImageBytes(url, b64Json) {
|
|
340
|
+
const cleanUrl = requiredText(url);
|
|
341
|
+
return cleanUrl?.startsWith("data:") ? imageBytesFromDataUri(cleanUrl) : imageBytesFromBase64(requiredText(b64Json));
|
|
342
|
+
}
|
|
343
|
+
function imageBytesFromDataUri(value) {
|
|
344
|
+
const match = /^data:([^;,]+);base64,(.+)$/s.exec(value);
|
|
345
|
+
if (!match) throw new Error("Image provider returned an unsupported data URI");
|
|
346
|
+
return imageBytesFromBase64(match[2] ?? null, match[1]);
|
|
347
|
+
}
|
|
348
|
+
function imageBytesFromBase64(value, mimeType = "image/png") {
|
|
349
|
+
if (!value) return null;
|
|
350
|
+
try {
|
|
351
|
+
const binary = atob(value);
|
|
352
|
+
const bytes = new Uint8Array(binary.length);
|
|
353
|
+
for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
|
|
354
|
+
return { bytes, mimeType };
|
|
355
|
+
} catch {
|
|
356
|
+
throw new Error("Image provider returned invalid image bytes");
|
|
357
|
+
}
|
|
358
|
+
}
|
|
359
|
+
function recordValue(value) {
|
|
360
|
+
return value && typeof value === "object" && !Array.isArray(value) ? value : {};
|
|
361
|
+
}
|
|
362
|
+
function text(value) {
|
|
363
|
+
return typeof value === "string" && value.trim() ? value.trim() : void 0;
|
|
364
|
+
}
|
|
365
|
+
|
|
366
|
+
// src/media/router-client.ts
|
|
367
|
+
var RouterHttpError = class extends Error {
|
|
368
|
+
status;
|
|
369
|
+
code;
|
|
370
|
+
constructor(status, message, code) {
|
|
371
|
+
super(message);
|
|
372
|
+
this.name = "RouterHttpError";
|
|
373
|
+
this.status = status;
|
|
374
|
+
this.code = code;
|
|
375
|
+
}
|
|
376
|
+
};
|
|
377
|
+
var NOT_CONFIGURED = "Media generation is not configured for this deployment.";
|
|
378
|
+
function routerV1Url(value) {
|
|
379
|
+
return `${routerRootUrl(value)}/v1`;
|
|
380
|
+
}
|
|
381
|
+
async function routerResponseError(response) {
|
|
382
|
+
const text3 = await response.text();
|
|
383
|
+
if (!text3) return { message: response.statusText };
|
|
384
|
+
try {
|
|
385
|
+
const json = JSON.parse(text3);
|
|
386
|
+
if (typeof json.error === "string") return { message: json.error };
|
|
387
|
+
const code = typeof json.error?.code === "string" ? json.error.code : void 0;
|
|
388
|
+
if (typeof json.error?.message === "string") return { message: json.error.message, code };
|
|
389
|
+
if (typeof json.message === "string") return { message: json.message, code };
|
|
390
|
+
} catch {
|
|
391
|
+
return { message: text3.slice(0, 500) };
|
|
392
|
+
}
|
|
393
|
+
return { message: text3.slice(0, 500) };
|
|
394
|
+
}
|
|
395
|
+
async function routerResponseErrorMessage(response) {
|
|
396
|
+
return (await routerResponseError(response)).message;
|
|
397
|
+
}
|
|
398
|
+
function createRouterMediaClient(config) {
|
|
399
|
+
const wrap = (headers) => config.headers?.(headers) ?? headers;
|
|
400
|
+
function requiredRouterApiKey(value) {
|
|
401
|
+
const apiKey = text2(value ?? config.defaultApiKey?.());
|
|
402
|
+
if (!apiKey) throw new Error(NOT_CONFIGURED);
|
|
403
|
+
return apiKey;
|
|
404
|
+
}
|
|
405
|
+
function routerMediaUrl(path) {
|
|
406
|
+
return `${routerV1Url(config.baseUrl())}${path}`;
|
|
407
|
+
}
|
|
408
|
+
function routerHeaders(apiKey, extra = {}) {
|
|
409
|
+
return wrap({ Authorization: `Bearer ${requiredRouterApiKey(apiKey)}`, ...extra });
|
|
410
|
+
}
|
|
411
|
+
async function routerJson(path, body, signal, apiKey) {
|
|
412
|
+
const response = await fetch(routerMediaUrl(path), {
|
|
413
|
+
method: "POST",
|
|
414
|
+
headers: routerHeaders(apiKey, { "Content-Type": "application/json" }),
|
|
415
|
+
body: JSON.stringify(pruneUndefined(body)),
|
|
416
|
+
signal
|
|
417
|
+
});
|
|
418
|
+
if (!response.ok) {
|
|
419
|
+
const { message, code } = await routerResponseError(response);
|
|
420
|
+
throw new RouterHttpError(response.status, `Router media request failed: ${response.status} ${message}`, code);
|
|
421
|
+
}
|
|
422
|
+
return await response.json();
|
|
423
|
+
}
|
|
424
|
+
async function routerMediaStatus(id, signal, apiKey) {
|
|
425
|
+
const response = await fetch(routerMediaUrl(`/videos/${encodeURIComponent(id)}`), {
|
|
426
|
+
headers: routerHeaders(apiKey),
|
|
427
|
+
signal
|
|
428
|
+
});
|
|
429
|
+
if (!response.ok) {
|
|
430
|
+
throw new Error(`Router media poll failed: ${response.status} ${await routerResponseErrorMessage(response)}`);
|
|
431
|
+
}
|
|
432
|
+
return await response.json();
|
|
433
|
+
}
|
|
434
|
+
function resolveRouterMediaSource(value, apiKey) {
|
|
435
|
+
if (!value.startsWith("/") || value.startsWith("//")) return { url: value };
|
|
436
|
+
return {
|
|
437
|
+
url: `${routerRootUrl(config.baseUrl())}${value}`,
|
|
438
|
+
authorization: `Bearer ${requiredRouterApiKey(apiKey)}`
|
|
439
|
+
};
|
|
440
|
+
}
|
|
441
|
+
function validateRouterMediaSourceUrl(value) {
|
|
442
|
+
const expected = new URL(routerRootUrl(config.baseUrl())).origin;
|
|
443
|
+
const url = new URL(value);
|
|
444
|
+
if (url.origin !== expected) {
|
|
445
|
+
throw new Error(`Authorized media fetch must target the router origin ${expected}`);
|
|
446
|
+
}
|
|
447
|
+
return url.toString();
|
|
448
|
+
}
|
|
449
|
+
return {
|
|
450
|
+
requiredRouterApiKey,
|
|
451
|
+
routerMediaUrl,
|
|
452
|
+
routerHeaders,
|
|
453
|
+
routerJson,
|
|
454
|
+
routerMediaStatus,
|
|
455
|
+
resolveRouterMediaSource,
|
|
456
|
+
validateRouterMediaSourceUrl
|
|
457
|
+
};
|
|
458
|
+
}
|
|
459
|
+
function routerRootUrl(value) {
|
|
460
|
+
return value.replace(/\/+$/, "").replace(/\/v1$/, "");
|
|
461
|
+
}
|
|
462
|
+
function pruneUndefined(value) {
|
|
463
|
+
return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== void 0));
|
|
464
|
+
}
|
|
465
|
+
function text2(value) {
|
|
466
|
+
return typeof value === "string" && value.trim() ? value.trim() : void 0;
|
|
467
|
+
}
|
|
468
|
+
|
|
469
|
+
// src/media/router-generation.ts
|
|
470
|
+
var MAX_TRANSCRIPTION_BYTES = 25 * 1024 * 1024;
|
|
471
|
+
var SUPPORTED_TRANSCRIPTION_FORMATS = /* @__PURE__ */ new Set(["wav", "mp3", "flac", "m4a", "ogg", "webm", "aac"]);
|
|
472
|
+
function validatePublicHttpUrl(value, field) {
|
|
473
|
+
let url;
|
|
474
|
+
try {
|
|
475
|
+
url = new URL(value);
|
|
476
|
+
} catch {
|
|
477
|
+
throw new Error(`${field} must be a valid public URL`);
|
|
478
|
+
}
|
|
479
|
+
if (url.protocol !== "https:" && url.protocol !== "http:") {
|
|
480
|
+
throw new Error(`${field} must use http or https`);
|
|
481
|
+
}
|
|
482
|
+
if (isBlockedFetchHostname(url.hostname)) {
|
|
483
|
+
throw new Error(`${field} must be a public URL`);
|
|
484
|
+
}
|
|
485
|
+
return url.toString();
|
|
486
|
+
}
|
|
487
|
+
async function fetchBoundedAudio(url, options = {}) {
|
|
488
|
+
const safeUrl = validatePublicHttpUrl(url, "audioUrl");
|
|
489
|
+
const response = await fetch(safeUrl, { signal: options.signal, redirect: "manual" });
|
|
490
|
+
if (response.status >= 300 && response.status < 400) {
|
|
491
|
+
throw new Error("Audio URL redirects are not allowed");
|
|
492
|
+
}
|
|
493
|
+
if (!response.ok) {
|
|
494
|
+
throw new Error(`Audio fetch failed with ${response.status}`);
|
|
495
|
+
}
|
|
496
|
+
const contentLength = Number(response.headers.get("content-length") ?? "0");
|
|
497
|
+
if (contentLength > MAX_TRANSCRIPTION_BYTES) {
|
|
498
|
+
throw new Error("Audio file is too large");
|
|
499
|
+
}
|
|
500
|
+
const contentType = response.headers.get("content-type") ?? "application/octet-stream";
|
|
501
|
+
if (!contentType.startsWith("audio/") && contentType !== "application/octet-stream") {
|
|
502
|
+
throw new Error("Transcription URL must return audio");
|
|
503
|
+
}
|
|
504
|
+
const blob = await response.blob();
|
|
505
|
+
if (blob.size === 0) throw new Error("Transcription audio URL returned an empty file");
|
|
506
|
+
if (blob.size > MAX_TRANSCRIPTION_BYTES) {
|
|
507
|
+
throw new Error("Audio file is too large");
|
|
508
|
+
}
|
|
509
|
+
return blob;
|
|
510
|
+
}
|
|
511
|
+
function createRouterGeneration(client) {
|
|
512
|
+
async function generateVideoViaRouter({ model, prompt, duration, resolution, aspectRatio, referenceImageUrl, callbackUrl }, signal, apiKey) {
|
|
513
|
+
return await client.routerJson(
|
|
514
|
+
"/videos/generate",
|
|
515
|
+
{
|
|
516
|
+
model,
|
|
517
|
+
prompt,
|
|
518
|
+
duration,
|
|
519
|
+
resolution,
|
|
520
|
+
aspect_ratio: aspectRatio,
|
|
521
|
+
image_url: referenceImageUrl,
|
|
522
|
+
callback_url: callbackUrl
|
|
523
|
+
},
|
|
524
|
+
signal,
|
|
525
|
+
apiKey
|
|
526
|
+
);
|
|
527
|
+
}
|
|
528
|
+
async function generateAvatarViaRouter(body, signal, apiKey) {
|
|
529
|
+
return await client.routerJson("/videos/avatar", { ...body }, signal, apiKey);
|
|
530
|
+
}
|
|
531
|
+
async function transcribeViaRouter({
|
|
532
|
+
audioBlob,
|
|
533
|
+
audioUrl,
|
|
534
|
+
model,
|
|
535
|
+
language,
|
|
536
|
+
prompt,
|
|
537
|
+
responseFormat,
|
|
538
|
+
temperature,
|
|
539
|
+
signal,
|
|
540
|
+
apiKey
|
|
541
|
+
}) {
|
|
542
|
+
const format = transcriptionAudioFormat(audioUrl, audioBlob.type);
|
|
543
|
+
const responseFormatText = typeof responseFormat === "string" && responseFormat.trim() ? responseFormat.trim() : null;
|
|
544
|
+
const audioData = bytesToBase64(new Uint8Array(await audioBlob.arrayBuffer()));
|
|
545
|
+
const response = await fetch(client.routerMediaUrl("/audio/transcriptions"), {
|
|
546
|
+
method: "POST",
|
|
547
|
+
headers: client.routerHeaders(apiKey, { "Content-Type": "application/json" }),
|
|
548
|
+
body: JSON.stringify({
|
|
549
|
+
model,
|
|
550
|
+
input_audio: { data: audioData, format },
|
|
551
|
+
language,
|
|
552
|
+
prompt,
|
|
553
|
+
response_format: responseFormat,
|
|
554
|
+
temperature
|
|
555
|
+
}),
|
|
556
|
+
signal
|
|
557
|
+
});
|
|
558
|
+
if (!response.ok) {
|
|
559
|
+
throw new Error(`Transcription provider failed: ${response.status} ${await routerResponseErrorMessage(response)}`);
|
|
560
|
+
}
|
|
561
|
+
if (isRawTranscriptionResponseFormat(responseFormatText)) {
|
|
562
|
+
return { text: await response.text() };
|
|
563
|
+
}
|
|
564
|
+
return await response.json();
|
|
565
|
+
}
|
|
566
|
+
return { generateVideoViaRouter, generateAvatarViaRouter, transcribeViaRouter };
|
|
567
|
+
}
|
|
568
|
+
function isRawTranscriptionResponseFormat(value) {
|
|
569
|
+
const format = value?.toLowerCase();
|
|
570
|
+
return format === "text" || format === "srt" || format === "vtt";
|
|
571
|
+
}
|
|
572
|
+
function transcriptionAudioFormat(audioUrl, contentType) {
|
|
573
|
+
const fromType = contentTypeToAudioFormat(contentType);
|
|
574
|
+
if (fromType) return fromType;
|
|
575
|
+
const ext = new URL(audioUrl).pathname.split(".").pop()?.toLowerCase();
|
|
576
|
+
if (ext && SUPPORTED_TRANSCRIPTION_FORMATS.has(ext)) return ext;
|
|
577
|
+
throw new Error("Transcription audio must be wav, mp3, flac, m4a, ogg, webm, or aac");
|
|
578
|
+
}
|
|
579
|
+
function contentTypeToAudioFormat(contentType) {
|
|
580
|
+
const type = contentType.toLowerCase().split(";")[0]?.trim();
|
|
581
|
+
if (type === "audio/wav" || type === "audio/x-wav") return "wav";
|
|
582
|
+
if (type === "audio/mpeg" || type === "audio/mp3") return "mp3";
|
|
583
|
+
if (type === "audio/flac") return "flac";
|
|
584
|
+
if (type === "audio/mp4" || type === "audio/x-m4a") return "m4a";
|
|
585
|
+
if (type === "audio/ogg" || type === "application/ogg") return "ogg";
|
|
586
|
+
if (type === "audio/webm" || type === "video/webm") return "webm";
|
|
587
|
+
if (type === "audio/aac") return "aac";
|
|
588
|
+
return null;
|
|
589
|
+
}
|
|
590
|
+
function bytesToBase64(bytes) {
|
|
591
|
+
let binary = "";
|
|
592
|
+
for (let i = 0; i < bytes.length; i += 8192) {
|
|
593
|
+
binary += String.fromCharCode(...bytes.subarray(i, i + 8192));
|
|
594
|
+
}
|
|
595
|
+
return btoa(binary);
|
|
596
|
+
}
|
|
597
|
+
function tcloudWebhookCallbackUrl(bindings, requestUrl) {
|
|
598
|
+
const env = bindings;
|
|
599
|
+
const secret = configuredText(env?.TCLOUD_WEBHOOK_SECRET);
|
|
600
|
+
const enabled = secret || truthy(env?.TCLOUD_WEBHOOKS_ENABLED);
|
|
601
|
+
if (!enabled) return void 0;
|
|
602
|
+
if (!secret) throw new Error("TCLOUD_WEBHOOK_SECRET is required when tcloud webhooks are enabled");
|
|
603
|
+
const origin = configuredText(env?.PUBLIC_ORIGIN) ?? configuredText(env?.APP_ORIGIN) ?? new URL(requestUrl).origin;
|
|
604
|
+
return `${origin.replace(/\/+$/, "")}/api/webhooks/tcloud`;
|
|
605
|
+
}
|
|
606
|
+
function configuredText(value) {
|
|
607
|
+
return typeof value === "string" && value.trim() ? value.trim() : null;
|
|
608
|
+
}
|
|
609
|
+
function truthy(value) {
|
|
610
|
+
return value === true || typeof value === "string" && /^(1|true|yes|on)$/i.test(value.trim());
|
|
611
|
+
}
|
|
612
|
+
|
|
613
|
+
export {
|
|
614
|
+
DEFAULT_GENERATED_OUTPUT_PATHS,
|
|
615
|
+
GENERATED_OUTPUT_CONFIG,
|
|
616
|
+
normalizeGeneratedOutputPath,
|
|
617
|
+
resolveGeneratedVaultPath,
|
|
618
|
+
extensionForGeneratedMimeType,
|
|
619
|
+
validateGeneratedMediaSourceUrl,
|
|
620
|
+
generatedExtensionFromUrl,
|
|
621
|
+
generatedMimeTypeFromUrl,
|
|
622
|
+
generatedMediaLabel,
|
|
623
|
+
isGeneratedMediaType,
|
|
624
|
+
requiredText,
|
|
625
|
+
validateGenerateRequest,
|
|
626
|
+
imageCountForRequest,
|
|
627
|
+
modelForRequest,
|
|
628
|
+
checkGenerateRequest,
|
|
629
|
+
optionalHttpsUrl,
|
|
630
|
+
metadataResultUrl,
|
|
631
|
+
generationMetadata,
|
|
632
|
+
browserUsableSourceUrl,
|
|
633
|
+
normalizeProviderJobStatus,
|
|
634
|
+
validProviderImages,
|
|
635
|
+
providerImageBytes,
|
|
636
|
+
RouterHttpError,
|
|
637
|
+
routerV1Url,
|
|
638
|
+
routerResponseErrorMessage,
|
|
639
|
+
createRouterMediaClient,
|
|
640
|
+
validatePublicHttpUrl,
|
|
641
|
+
fetchBoundedAudio,
|
|
642
|
+
createRouterGeneration,
|
|
643
|
+
tcloudWebhookCallbackUrl
|
|
644
|
+
};
|
|
645
|
+
//# sourceMappingURL=chunk-NSWLZTJX.js.map
|