@fluid-app/fluid-cli-widget 0.1.28 → 0.1.30

package/dist/{src-CVadzcYM.mjs → src-_wfDoBLp.mjs}

@@ -586,12 +586,265 @@ function toDevelopmentCssUrl(url, origin) {
 	return href.includes("?") ? `${href}&direct` : `${href}?direct`;
 }
 //#endregion
+//#region ../widget-tooling/src/dev-routes.ts
+function fluidWidgetDevPlugin(options = {}) {
+	const entryModulePath = options.entryModulePath ?? WIDGET_ENTRY_MODULE_PATH;
+	const configModulePath = options.configModulePath ?? WIDGET_CONFIG_MODULE_PATH;
+	const owner = options.owner ?? "droplet";
+	return {
+		name: "fluid-widget-dev-routes",
+		apply: "serve",
+		config: createWidgetDevServerConfig,
+		configureServer(server) {
+			server.middlewares.use(async (request, response, next) => {
+				const pathname = (request.url ?? "").split("?")[0] ?? "";
+				if (pathname === "/__runtime-entry__" || pathname === "/__runtime-entry__/") {
+					sendJavaScript(request, response, buildRuntimeEntryBootstrapScript(entryModulePath, getRequestOrigin(request)));
+					return;
+				}
+				if (pathname === "/__widget-packages__" || pathname === "/__widget-packages__/") {
+					await sendWidgetPackages(server, request, response, {
+						configModulePath,
+						owner,
+						allowNoPackages: options.allowNoPackages === true
+					});
+					return;
+				}
+				next();
+			});
+		}
+	};
+}
+/**
+* Widget projects intentionally have no HTML entrypoint, so Vite cannot
+* discover the worker's dependency graph during its normal startup scan.
+* Without an explicit entry, the first live-preview request discovers and
+* optimizes the portal worker after the server reports ready. Vite reloads
+* the worker mid-mount, closing its message thread and stranding the preview
+* in a permanent error state.
+*
+* Pre-optimizing the worker entry makes the initial graph stable before a
+* preview can connect. Vite follows this entry's imports, so React and the
+* Remote DOM worker runtime are optimized in the same startup pass.
+*/
+function createWidgetDevServerConfig() {
+	return {
+		optimizeDeps: { include: ["@fluid-app/portal-sdk/widgets/worker"] },
+		ssr: { noExternal: ["@fluid-app/portal-sdk"] }
+	};
+}
+/** Source-relative path of a widget project's entry module. The dev
+*  scaffold always places it here (see the widget template) — this is
+*  the one thing the bootstrap script below needs from the plugin
+*  that isn't itself part of the race/preamble fix. */
+const WIDGET_ENTRY_MODULE_PATH = "/src/index.ts";
+/** Source-relative path of a standalone widget project's package source. */
+const WIDGET_CONFIG_MODULE_PATH = "/fluid.widget.config.ts";
+/**
+* Builds the `/__runtime-entry__` worker bootstrap. Runtime-verified
+* against a real widget dev server + `@fluid-app/widget-runtime` host
+* in a Playwright harness (styled Leaderboard widget rendering,
+* mutation records flowing, `mounted.ready` resolving) — every piece
+* below exists to fix something that reproduced in that harness:
+*
+* 1. **Message-buffer race (the silent-mount killer).** The host
+*    (widget-runtime) posts the "mount" message immediately after
+*    `new Worker(...)`. A production-built worker bundle evaluates
+*    synchronously and never races that message. In dev, though, the
+*    worker's module graph loads asynchronously over many HTTP
+*    requests (this bootstrap script, then the entry module, then
+*    everything it imports, each a separate fetch) — so the "mount"
+*    message can be dispatched and consumed by the Worker's default
+*    (listener-less) handling before the widget entry's own
+*    `message` listener, wired up deep inside the awaited import
+*    below, is ever attached. The message is dropped silently, with
+*    no error anywhere — the old `void import("/src/index.ts")` also
+*    swallowed the import's own rejections, compounding the silence.
+*    Traced live: host→worker "mount" posts, zero worker→host replies
+*    until this buffer-and-replay was added; after it, mutation
+*    records flow and `mounted.ready` resolves. Fix: buffer every
+*    message from the instant the worker boots (before anything else
+*    runs), then replay the buffer, in order, once the entry module
+*    has finished importing and has had the chance to attach its
+*    real listener.
+* 2. **React-refresh preamble.** `@vitejs/plugin-react` injects a
+*    preamble into every dev-transformed `.tsx` module referencing
+*    `window.$RefreshReg$` / `$RefreshSig$`. A Worker global scope has
+*    no `window` and no preamble, so importing a react-based widget
+*    entry throws `window is not defined`, and — once `window` is
+*    aliased to `globalThis` — throws again on the bare
+*    `$RefreshSig$` alias. Installing the canonical preamble
+*    (`RefreshRuntime.injectIntoGlobalHook` + no-op `$RefreshReg$` /
+*    `$RefreshSig$`) before the entry import fixes both. The
+*    `window = globalThis` alias was checked against widget-runtime's
+*    worker lockdown / scope detection (which is
+*    `globalThis.postMessage`-based) — no conflict. `/@react-refresh`
+*    is `@vitejs/plugin-react`'s stable virtual module id, but a
+*    widget project isn't guaranteed to use the react plugin, so the
+*    whole block is try/catch-guarded — a project with no
+*    `/@react-refresh` module (no react plugin) boots straight
+*    through to the entry import unaffected.
+* 3. **`await import`, not `void import`.** A genuine failure to
+*    import the entry module (syntax error, missing dependency, …)
+*    must reject the worker's module evaluation loudly, not vanish
+*    the way a fire-and-forget `void import` did.
+* 4. **Absolute dev-server imports.** Mist and portal previews load the
+*    worker from another origin, so the host wraps this entry in a blob URL.
+*    Root-relative specifiers inside a blob module resolve against the host
+*    page (or fail to resolve at all), not this Vite server. Anchoring both
+*    imports to the request origin keeps the entire dev module graph on the
+*    widget server.
+*
+* Dev-only: this only ever serves from `configureServer` (the
+* plugin's `apply: "serve"` gate), never a built/published package.
+*/
+function buildRuntimeEntryBootstrapScript(entryPath, origin) {
+	const refreshRuntimeUrl = new URL("/@react-refresh", origin).toString();
+	const entryUrl = new URL(entryPath, origin).toString();
+	return [
+		"// Dev-only worker bootstrap — see buildRuntimeEntryBootstrapScript",
+		"// in packages/cli/widget-tooling/src/dev-routes.ts for why each piece",
+		"// here exists (message-buffer race, react-refresh preamble,",
+		"// await-not-void import).",
+		"const __q = [];",
+		"const __buf = (e) => { __q.push(e.data); };",
+		"self.addEventListener(\"message\", __buf);",
+		"if (typeof window === \"undefined\") { globalThis.window = globalThis; }",
+		"try {",
+		`  const { default: RefreshRuntime } = await import(${JSON.stringify(refreshRuntimeUrl)});`,
+		"  RefreshRuntime.injectIntoGlobalHook(window);",
+		"  window.$RefreshReg$ = () => {};",
+		"  window.$RefreshSig$ = () => (type) => type;",
+		"  window.__vite_plugin_react_preamble_installed__ = true;",
+		"} catch {",
+		"  // No @vitejs/plugin-react in this widget project (no",
+		"  // /@react-refresh virtual module) — nothing to preinstall.",
+		"}",
+		`await import(${JSON.stringify(entryUrl)});`,
+		"self.removeEventListener(\"message\", __buf);",
+		"for (const data of __q) {",
+		"  self.dispatchEvent(new MessageEvent(\"message\", { data }));",
+		"}",
+		""
+	].join("\n");
+}
+/**
+* The shared development descriptor workflow appends Vite's `?direct` query
+* to CSS URLs so preview hosts receive real CSS instead of JS style modules.
+* Published descriptors use a separate build path and never receive it.
+*/
+function createDevWidgetPackageDescriptors(configModule, origin, owner = "droplet") {
+	return [createWidgetPackageDevelopmentDescriptor({
+		sourceModule: configModule,
+		owner,
+		origin,
+		workerEntryPath: "/__runtime-entry__",
+		defaultCssPath: "/styles.css"
+	})];
+}
+/**
+* True when validation failed *only* because the project declares no widget
+* package. Checked against the typed diagnostics rather than message text, and
+* deliberately narrow: a config that declares a package and gets it wrong must
+* still be reported.
+*/
+function isNoSourcePackageError(error) {
+	if (!(error instanceof WidgetToolingError)) return false;
+	const diagnostics = error.diagnostics ?? [];
+	return diagnostics.length > 0 && diagnostics.every((diagnostic) => diagnostic.code === "NO_SOURCE_PACKAGE");
+}
+async function sendWidgetPackages(server, request, response, options) {
+	if (handleOptions(request, response)) return;
+	try {
+		sendJson(response, createDevWidgetPackageDescriptors(await server.ssrLoadModule(options.configModulePath), getRequestOrigin(request), options.owner));
+	} catch (error) {
+		if (options.allowNoPackages && isNoSourcePackageError(error)) {
+			sendJson(response, []);
+			return;
+		}
+		server.config.logger.error(`[fluid] Failed to load widget packages: ${String(error)}`);
+		sendJson(response, { error: String(error) }, 500);
+	}
+}
+function sendJavaScript(request, response, source) {
+	if (handleOptions(request, response)) return;
+	setCorsHeaders(response);
+	response.setHeader("Content-Type", "text/javascript");
+	response.statusCode = 200;
+	response.end(source);
+}
+function sendJson(response, body, statusCode = 200) {
+	setCorsHeaders(response);
+	response.setHeader("Content-Type", "application/json");
+	response.statusCode = statusCode;
+	response.end(JSON.stringify(body, null, 2));
+}
+function handleOptions(request, response) {
+	if (request.method !== "OPTIONS") return false;
+	setCorsHeaders(response);
+	response.statusCode = 204;
+	response.end();
+	return true;
+}
+function setCorsHeaders(response) {
+	response.setHeader("Access-Control-Allow-Origin", "*");
+	response.setHeader("Access-Control-Allow-Methods", "GET, HEAD, OPTIONS");
+	response.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
+}
+function getRequestOrigin(request) {
+	const host = readHeader(request.headers.host);
+	if (!host) throw new Error("Widget dev request is missing the Host header.");
+	return `${readHeader(request.headers["x-forwarded-proto"]) === "https" ? "https" : "http"}://${host}`;
+}
+function readHeader(value) {
+	const candidate = Array.isArray(value) ? value[0] : value;
+	return typeof candidate === "string" && candidate.trim().length > 0 ? candidate.trim() : void 0;
+}
+//#endregion
+//#region ../widget-tooling/src/node-runtime.ts
+/**
+* How this package runs the helper scripts it generates.
+*
+* Building a widget package writes two scripts to disk and runs them: a config
+* extractor (under `tsx`) and a Vite build. Both used to assume the same thing —
+* that `process.execPath` is Node and that `tsx` is resolvable from this
+* module. Both assumptions hold for a CLI and neither holds in an Electron main
+* process, where `process.execPath` is the Electron binary. Spawning it without
+* `ELECTRON_RUN_AS_NODE` starts a second copy of the app instead of running the
+* script, and `tsx` is not in a packaged app's dependency closure at all.
+*
+* So the host says how to run a script rather than this package guessing. The
+* default reproduces the old behaviour exactly, which is why both CLIs are
+* unchanged by this.
+*/
+/** The executable to spawn, and the env to spawn it with. */
+function resolveSpawnTarget(runtime) {
+	return {
+		execPath: runtime?.execPath ?? process.execPath,
+		env: runtime?.env ?? {}
+	};
+}
+/**
+* Resolves `tsx`'s CLI, preferring an injected path.
+*
+* Deliberately a function rather than a module-scope constant. It used to be
+* `const TSX_CLI_PATH = require.resolve("tsx/cli")`, which runs on IMPORT — so a
+* host that merely imported this package, and never published anything, crashed
+* at startup if `tsx` was absent. Resolving on use means a missing `tsx` is a
+* publish-time error the caller can report, not a boot failure.
+*/
+function resolveTsxCliPath(runtime) {
+	if (runtime?.tsxCliPath) return runtime.tsxCliPath;
+	return createRequire(import.meta.url).resolve("tsx/cli");
+}
+//#endregion
 //#region ../widget-tooling/src/internal/widget-package-config.ts
 const WIDGET_CONFIG_PATH = "src/widgets.config.ts";
+/** Long enough for a cold tsx start on a slow machine, short enough to fail. */
+const CONFIG_EVAL_TIMEOUT_MS = 6e4;
 const SOURCE_PACKAGE_EXTRACT_FILENAME = "extract-widget-packages.ts";
 const SOURCE_PACKAGE_OUTPUT_FILENAME = "source-widget-packages.json";
 const SOURCE_PACKAGE_OUTPUT_SENTINEL = "fluid-widget-source-packages:v1";
-const TSX_CLI_PATH = createRequire(import.meta.url).resolve("tsx/cli");
 async function resolvePortalWidgetSourceConfig(projectDir) {
 	const candidate = path.join(projectDir, WIDGET_CONFIG_PATH);
 	return await fs.pathExists(candidate) ? {
@@ -599,7 +852,7 @@ async function resolvePortalWidgetSourceConfig(projectDir) {
 		relativePath: WIDGET_CONFIG_PATH
 	} : void 0;
 }
-async function loadSourceWidgetPackages(projectDir) {
+async function loadSourceWidgetPackages(projectDir, nodeRuntime) {
 	const config = await resolvePortalWidgetSourceConfig(projectDir);
 	if (!config) return success([]);
 	let tempDir;
@@ -614,8 +867,9 @@ async function loadSourceWidgetPackages(projectDir) {
 			encoding: "utf-8",
 			flag: "wx"
 		});
-		await execa(process.execPath, [
-			TSX_CLI_PATH,
+		const spawn = resolveSpawnTarget(nodeRuntime);
+		await execa(spawn.execPath, [
+			resolveTsxCliPath(nodeRuntime),
 			extractFile,
 			outputFile
 		], {
@@ -623,8 +877,11 @@ async function loadSourceWidgetPackages(projectDir) {
 			stdio: "pipe",
 			env: {
 				...process.env,
+				...spawn.env,
 				NODE_ENV: "production"
-			}
+			},
+			timeout: CONFIG_EVAL_TIMEOUT_MS,
+			killSignal: "SIGKILL"
 		});
 		const outputResult = await readSourcePackageExtractorOutput(outputFile);
 		if (!outputResult.success) return outputResult;
@@ -812,6 +1069,21 @@ function validateSharedWidgetPackagePublishDir(projectDir, publishDir = DEFAULT_
 	const relative = path.relative(resolvedProjectDir, resolvedPublishDir);
 	if (relative === "" || relative.startsWith("..") || path.isAbsolute(relative)) throw new Error(`${label} must stay inside the project directory.`);
 }
+/**
+* Restamps each loaded source package with `version`.
+*
+* Object spread carries own enumerable SYMBOL keys as well as string ones,
+* which matters here: `defineWidgetPackage` marks its result with a symbol that
+* validation uses to recognise a real source package. A copy that dropped it
+* would fail validation with a message about a missing package rather than
+* about the version.
+*/
+function withVersionOverride(sourcePackages, version) {
+	return sourcePackages.map((sourcePackage) => typeof sourcePackage === "object" && sourcePackage !== null ? {
+		...sourcePackage,
+		version
+	} : sourcePackage);
+}
 async function buildSharedWidgetPackage(options) {
 	const publishDirInput = options.publishDir ?? DEFAULT_PUBLISH_DIR;
 	try {
@@ -823,13 +1095,13 @@ async function buildSharedWidgetPackage(options) {
 			details: (err instanceof Error ? err : new Error(String(err))).message
 		});
 	}
-	const sourcePackageResult = await loadSourceWidgetPackages(options.projectDir);
+	const sourcePackageResult = await loadSourceWidgetPackages(options.projectDir, options.nodeRuntime);
 	if (!sourcePackageResult.success) return failure({
 		code: "CONFIG_LOAD_FAILED",
 		message: sourcePackageResult.error.message,
 		details: sourcePackageResult.error.details
 	});
-	const validation = validateSingleSourceWidgetPackage(sourcePackageResult.value, { owner: options.owner });
+	const validation = validateSingleSourceWidgetPackage(options.versionOverride ? withVersionOverride(sourcePackageResult.value, options.versionOverride) : sourcePackageResult.value, { owner: options.owner });
 	if (!validation.success || !validation.value) return failure({
 		code: "VALIDATION_FAILED",
 		message: validation.errors.map((error) => error.message).join("\n")
@@ -847,7 +1119,8 @@ async function buildSharedWidgetPackage(options) {
 				projectDir: options.projectDir,
 				tempDir,
 				publishDir,
-				validated: validation.value
+				validated: validation.value,
+				...options.nodeRuntime ? { nodeRuntime: options.nodeRuntime } : {}
 			});
 		} catch (error) {
 			buildFailure = { error };
@@ -959,7 +1232,8 @@ async function buildWidgetScriptBundle(options) {
 		projectConfigPath: await resolveProjectViteConfigPath(options.projectDir)
 	}), "utf-8");
 	const viteCliPath = resolveViteCliPath(options.projectDir);
-	await execa(process.execPath, [
+	const spawn = resolveSpawnTarget(options.nodeRuntime);
+	await execa(spawn.execPath, [
 		viteCliPath,
 		"build",
 		"--config",
@@ -969,6 +1243,7 @@ async function buildWidgetScriptBundle(options) {
 		stdio: "pipe",
 		env: {
 			...process.env,
+			...spawn.env,
 			NODE_ENV: "production"
 		}
 	});
@@ -1355,28 +1630,63 @@ function isRecord$1(value) {
 	return typeof value === "object" && value !== null;
 }
 //#endregion
-//#region ../../api-clients/fluidos/src/namespaces/fluid_os_v0.ts
+//#region ../../api-clients/fluidos/src/hey-api/sdk.gen.ts
 /**
 * Create a Fluid OS widget package version
-* Start a company-owned Fluid OS widget package publish flow and return signed upload URLs for each artifact.
 *
-* @param client - Fetch client instance
-* @param body - body
+* Start a company-owned Fluid OS widget package publish flow and return signed upload URLs for each artifact.
 */
-async function fluid_os_v0_create_widget_package_version(client, body) {
-	return client.post(`/api/company/fluid_os/widget_package_versions`, body);
-}
+const fluidOsV0CreateWidgetPackageVersion = (options) => options.client.post({
+	responseStyle: "data",
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/company/fluid_os/widget_package_versions",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
 /**
 * Complete a Fluid OS widget package upload
+*
 * Verify uploaded artifacts for a company-owned Fluid OS widget package version and approve the version when verification succeeds. Uploaded manifest.json is verified for matching packageId, matching version, and valid company-owned `company.<package_key>.` widget type prefixes.
+*/
+const fluidOsV0CompleteWidgetPackageVersionUpload = (options) => options.client.post({
+	responseStyle: "data",
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/company/fluid_os/widget_package_versions/{version}/complete_upload",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Mint a short-lived git credential for the company widget repo
+*
+* Returns an HTTPS clone URL with a fresh installation token from the
+* Fluid GitHub App embedded as the password. The CLI uses it
+* transparently — no `gh`, no PAT, no SSH key.
+*
+* Valid for ~1 hour (GitHub installation token TTL); re-mint on each
+* operation.
 *
-* @param client - Fetch client instance
-* @param version - version
-* @param [body] - body
 */
-async function fluid_os_v0_complete_widget_package_version_upload(client, version, body) {
-	return client.post(`/api/company/fluid_os/widget_package_versions/${version}/complete_upload`, body);
-}
+const fluidOsV0WidgetPackageGitCredentialCreate = (options) => options.client.post({
+	responseStyle: "data",
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/company/fluid_os/widget_package/git_credential",
+	...options
+});
 //#endregion
 //#region ../widget-tooling/src/internal/widget-package-upload.ts
 var WidgetPackageUploadError = class extends Error {
@@ -1428,7 +1738,14 @@ function getWidgetPackageCompleteUploadRoute(owner, version) {
 async function requestWidgetPackageUploadSession(client, owner, request) {
 	const payload = buildWidgetPackageUploadSessionPayload(request);
 	try {
-		return normalizeWidgetPackageUploadSession(owner.kind === "company" ? await fluid_os_v0_create_widget_package_version(client, payload) : await client.post(getWidgetPackageUploadSessionRoute(owner), payload), request.version, request.artifacts);
+		return normalizeWidgetPackageUploadSession(owner.kind === "company" ? await fluidOsV0CreateWidgetPackageVersion({
+			body: payload,
+			client
+		}) : await client.post({
+			body: payload,
+			responseStyle: "data",
+			url: getWidgetPackageUploadSessionRoute(owner)
+		}), request.version, request.artifacts);
 	} catch (err) {
 		if (err instanceof WidgetPackageUploadError) throw err;
 		throw new WidgetPackageUploadError("SESSION_REQUEST_FAILED", `Failed to create widget package upload session: ${formatUnknownError(err)}`);
@@ -1467,7 +1784,15 @@ async function uploadWidgetPackageArtifacts(session, artifacts, fetchImpl = fetc
 async function completeWidgetPackageUpload(client, owner, version, packageKey, artifacts) {
 	const payload = buildWidgetPackageCompleteUploadPayload(packageKey, artifacts);
 	try {
-		return normalizeWidgetPackageCompleteResponse(owner.kind === "company" ? await fluid_os_v0_complete_widget_package_version_upload(client, version, payload) : await client.post(getWidgetPackageCompleteUploadRoute(owner, version), payload), version);
+		return normalizeWidgetPackageCompleteResponse(owner.kind === "company" ? await fluidOsV0CompleteWidgetPackageVersionUpload({
+			body: payload,
+			client,
+			path: { version }
+		}) : await client.post({
+			body: payload,
+			responseStyle: "data",
+			url: getWidgetPackageCompleteUploadRoute(owner, version)
+		}), version);
 	} catch (err) {
 		if (err instanceof WidgetPackageUploadError) throw err;
 		throw new WidgetPackageUploadError("COMPLETE_UPLOAD_FAILED", `Failed to complete widget package upload: ${formatUnknownError(err)}`);
@@ -1479,7 +1804,7 @@ async function publishWidgetPackageVersion(options) {
 		dryRun: true,
 		sessionPayload
 	};
-	if (!options.client) throw new Error("A FetchClient is required when dryRun is false.");
+	if (!options.client) throw new Error("A FluidOS API client is required when dryRun is false.");
 	const session = await requestWidgetPackageUploadSession(options.client, options.owner, options.request);
 	return {
 		dryRun: false,
@@ -1594,7 +1919,7 @@ function safeStringify(value) {
 //#region ../widget-tooling/src/workflows.ts
 async function loadAndValidateWidgetPackage(options) {
 	const sourceConfig = await resolvePortalWidgetSourceConfig(options.projectDir);
-	const loadResult = await loadSourceWidgetPackages(options.projectDir);
+	const loadResult = await loadSourceWidgetPackages(options.projectDir, options.nodeRuntime);
 	if (!loadResult.success) throw new WidgetToolingError("CONFIG_LOAD_FAILED", loadResult.error.message, { details: loadResult.error.details });
 	const validation = validateSingleSourceWidgetPackage(loadResult.value, { owner: options.owner });
 	if (!validation.success || !validation.value) throw new WidgetToolingError("VALIDATION_FAILED", validation.errors.map((error) => error.message).join("\n") || "Widget package validation failed.", { diagnostics: validation.errors });
@@ -1609,14 +1934,16 @@ async function buildWidgetPackage(options) {
 		projectDir: options.projectDir,
 		publishDir: options.outDir,
 		owner: options.owner,
-		cliVersion: options.cliVersion
+		cliVersion: options.cliVersion,
+		...options.version ? { versionOverride: options.version } : {},
+		...options.nodeRuntime ? { nodeRuntime: options.nodeRuntime } : {}
 	});
 	if (result.success) return result.value;
 	throw new WidgetToolingError(result.error.code === "CONFIG_LOAD_FAILED" ? "CONFIG_LOAD_FAILED" : result.error.code === "VALIDATION_FAILED" ? "VALIDATION_FAILED" : result.error.code === "INVALID_PUBLISH_DIR" ? "INVALID_OUTPUT_DIR" : "BUILD_FAILED", result.error.message, { details: result.error.details });
 }
 async function publishWidgetPackage(options) {
 	if (options.owner !== options.uploadOwner.kind) throw new WidgetToolingError("OWNER_MISMATCH", `Widget package build owner "${options.owner}" must match upload owner kind "${options.uploadOwner.kind}".`);
-	if (!options.dryRun && !options.client) throw new WidgetToolingError("CLIENT_REQUIRED", "A FetchClient is required when dryRun is false.");
+	if (!options.dryRun && !options.client) throw new WidgetToolingError("CLIENT_REQUIRED", "A FluidOS API client is required when dryRun is false.");
 	const build = await buildWidgetPackage(options);
 	let request;
 	try {
@@ -1665,6 +1992,6 @@ function toPublicUploadErrorCode(code) {
 	}
 }
 //#endregion
-export { WidgetToolingError as a, createWidgetPackageDevelopmentDescriptor as i, loadAndValidateWidgetPackage as n, publishWidgetPackage as r, buildWidgetPackage as t };
+export { buildRuntimeEntryBootstrapScript as a, fluidWidgetDevPlugin as c, fluidOsV0WidgetPackageGitCredentialCreate as i, WidgetToolingError as l, loadAndValidateWidgetPackage as n, createDevWidgetPackageDescriptors as o, publishWidgetPackage as r, createWidgetDevServerConfig as s, buildWidgetPackage as t };
 
-//# sourceMappingURL=src-CVadzcYM.mjs.map
+//# sourceMappingURL=src-_wfDoBLp.mjs.map