devflare 1.0.0-next.19 → 1.0.0-next.20

package/dist/index-c643s0gv.js

@@ -0,0 +1,488 @@
+// src/dev-server/miniflare-log.ts
+var ANSI_ESCAPE_REGEX = /\u001B\[[0-9;]*m/g;
+var COMPATIBILITY_DATE_FALLBACK_REGEX = /^The latest compatibility date supported by the installed Cloudflare Workers Runtime is "([^"]+)", but you've requested "([^"]+)"\. Falling back to "([^"]+)"\.\.\.$/;
+var MINIFLARE_LOG_LEVEL_FALLBACKS = {
+  WARN: 2,
+  DEBUG: 4
+};
+function normalizeMiniflareMessage(message) {
+  return message.replace(ANSI_ESCAPE_REGEX, "").replace(/\s+/g, " ").trim();
+}
+function formatCompatibilityDateFallbackNotice(message) {
+  const normalizedMessage = normalizeMiniflareMessage(message);
+  const match = COMPATIBILITY_DATE_FALLBACK_REGEX.exec(normalizedMessage);
+  if (!match) {
+    return null;
+  }
+  const [, _supportedDate, requestedDate, fallbackDate] = match;
+  return `Using latest supported Cloudflare Workers Runtime compatibility date ${fallbackDate} (requested ${requestedDate})`;
+}
+function resolveMiniflareLogLevel(logLevel, levelName) {
+  return logLevel?.[levelName] ?? MINIFLARE_LOG_LEVEL_FALLBACKS[levelName];
+}
+function createCompatibilityAwareMiniflareLog(BaseLog, level, logger) {
+  const log = new BaseLog(level);
+  const originalWarn = log.warn.bind(log);
+  const originalInfo = log.info.bind(log);
+  log.warn = (message) => {
+    const notice = formatCompatibilityDateFallbackNotice(message);
+    if (!notice) {
+      originalWarn(message);
+      return;
+    }
+    if (logger) {
+      logger.info(notice);
+      return;
+    }
+    originalInfo(notice);
+  };
+  return log;
+}
+
+// src/bridge/gateway-runtime.ts
+var GATEWAY_RUNTIME_JS = `
+const RAW_EMAIL = 'EmailMessage::raw'
+
+function arrayBufferToBase64(buffer) {
+	const bytes = new Uint8Array(buffer)
+	let binary = ''
+	for (let i = 0; i < bytes.byteLength; i++) binary += String.fromCharCode(bytes[i])
+	return btoa(binary)
+}
+
+function base64ToArrayBuffer(base64) {
+	const binary = atob(base64)
+	const bytes = new Uint8Array(binary.length)
+	for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i)
+	return bytes.buffer
+}
+
+function serializeR2Object(obj) {
+	if (!obj) return null
+	return {
+		__type: 'R2Object',
+		key: obj.key,
+		version: obj.version,
+		size: obj.size,
+		etag: obj.etag,
+		httpEtag: obj.httpEtag,
+		checksums: obj.checksums,
+		uploaded: obj.uploaded?.toISOString(),
+		httpMetadata: obj.httpMetadata,
+		customMetadata: obj.customMetadata,
+		range: obj.range,
+		storageClass: obj.storageClass
+	}
+}
+
+function serializeR2ObjectBody(obj, bodyData) {
+	if (!obj) return null
+	return {
+		__type: 'R2ObjectBody',
+		key: obj.key,
+		version: obj.version,
+		size: obj.size,
+		etag: obj.etag,
+		httpEtag: obj.httpEtag,
+		checksums: obj.checksums,
+		uploaded: obj.uploaded?.toISOString(),
+		httpMetadata: obj.httpMetadata,
+		customMetadata: obj.customMetadata,
+		range: obj.range,
+		storageClass: obj.storageClass,
+		bodyData
+	}
+}
+
+function serializeR2Objects(result) {
+	if (!result) return null
+	return {
+		objects: result.objects.map(serializeR2Object),
+		truncated: result.truncated,
+		cursor: result.cursor,
+		delimitedPrefixes: result.delimitedPrefixes
+	}
+}
+
+async function serializeResponse(response) {
+	let body = null
+	if (response.body) {
+		const bytes = await response.arrayBuffer()
+		if (bytes.byteLength > 0) {
+			body = { type: 'bytes', data: arrayBufferToBase64(bytes) }
+		}
+	}
+	return {
+		status: response.status,
+		statusText: response.statusText,
+		headers: [...response.headers.entries()],
+		body
+	}
+}
+
+function createEmailMessageRaw(raw) {
+	if (typeof raw === 'string' || raw instanceof ReadableStream) {
+		return raw
+	}
+	if (raw instanceof ArrayBuffer || raw instanceof Uint8Array) {
+		return new Response(raw).body
+	}
+	throw new Error('Unsupported EmailMessage raw payload')
+}
+
+function isDurableObjectNamespace(binding) {
+	return !!binding
+		&& typeof binding.idFromName === 'function'
+		&& typeof binding.idFromString === 'function'
+		&& typeof binding.newUniqueId === 'function'
+}
+
+/**
+ * Execute an RPC method against the gateway's bindings.
+ *
+ * Method format: "binding.operation". Operations must be namespaced by
+ * binding kind (e.g. "kv.get", "r2.head", "d1.stmt.first", "do.fetch",
+ * "queue.send", "email.send", "ai.run"). Bare verbs and the legacy
+ * "stmt.*" / "stub.*" sub-prefixes were removed in B3-final and now throw.
+ * Method vocabulary must stay in sync with the canonical server in
+ * src/bridge/server.ts.
+ */
+async function executeRpcMethod(method, params, env, _ctx) {
+	const parts = method.split('.')
+	if (parts.length < 2) throw new Error('Invalid method format: ' + method)
+
+	const bindingName = parts[0]
+	const operation = parts.slice(1).join('.')
+	const binding = env[bindingName]
+
+	if (!binding) throw new Error('Binding not found: ' + bindingName)
+
+	const isNamespaced =
+		operation.indexOf('kv.') === 0 ||
+		operation.indexOf('r2.') === 0 ||
+		operation.indexOf('d1.') === 0 ||
+		operation.indexOf('do.') === 0 ||
+		operation.indexOf('queue.') === 0 ||
+		operation.indexOf('email.') === 0 ||
+		operation.indexOf('ai.') === 0 ||
+		operation.indexOf('var.') === 0
+	if (!isNamespaced) {
+		throw new Error(
+			"[devflare][bridge] Unsupported bridge operation '" + operation + "' for binding '" + bindingName + "'. "
+			+ "Bare verbs and the legacy stmt.*/stub.* sub-prefixes were removed in B3-final; "
+			+ "use the namespaced form (e.g. kv.get, r2.put, d1.stmt.first, do.fetch)."
+		)
+	}
+
+	// KV
+	if (operation === 'kv.get') return binding.get(params[0], params[1])
+	if (operation === 'kv.put') return binding.put(params[0], params[1], params[2])
+	if (operation === 'kv.delete') return binding.delete(params[0])
+	if (operation === 'kv.list') return binding.list(params[0])
+	if (operation === 'kv.getWithMetadata') return binding.getWithMetadata(params[0], params[1])
+
+	// DO get (returns DOStub reference)
+	if (operation === 'do.get') {
+		return { __type: 'DOStub', binding: bindingName, id: params[0] }
+	}
+
+	// R2
+	if (operation === 'r2.head') return serializeR2Object(await binding.head(params[0]))
+	if (operation === 'r2.get') {
+		const obj = await binding.get(params[0], params[1])
+		if (!obj) return null
+		const body = await obj.arrayBuffer()
+		return serializeR2ObjectBody(obj, arrayBufferToBase64(body))
+	}
+	if (operation === 'r2.put') {
+		let value = params[1]
+		if (value && typeof value === 'object') {
+			if (value.__type === 'ArrayBuffer' || value.__type === 'Uint8Array') {
+				value = base64ToArrayBuffer(value.data)
+			}
+		}
+		return serializeR2Object(await binding.put(params[0], value, params[2]))
+	}
+	if (operation === 'r2.delete') return binding.delete(params[0])
+	if (operation === 'r2.list') return serializeR2Objects(await binding.list(params[0]))
+
+	// D1
+	if (operation === 'd1.exec') return binding.exec(params[0])
+	if (operation === 'd1.batch') {
+		const statements = params[0].map((s) => binding.prepare(s.sql).bind(...(s.bindings || [])))
+		return binding.batch(statements)
+	}
+	if (operation.indexOf('d1.stmt.') === 0) {
+		const mode = operation.split('.')[2]
+		const [sql, ...rest] = params
+		let bindings = rest
+		let extraParam
+		if (mode === 'first' || mode === 'raw') {
+			extraParam = rest[rest.length - 1]
+			bindings = rest.slice(0, -1)
+		}
+		let stmt = binding.prepare(sql)
+		if (bindings.length > 0) stmt = stmt.bind(...bindings)
+		if (mode === 'first') {
+			if (typeof extraParam === 'string' && extraParam.length > 0) return stmt.first(extraParam)
+			return stmt.first()
+		}
+		if (mode === 'all') return stmt.all()
+		if (mode === 'run') return stmt.run()
+		if (mode === 'raw') return stmt.raw(extraParam)
+		throw new Error('Unknown stmt mode: ' + mode)
+	}
+
+	// Durable Objects
+	if (operation === 'do.idFromName') {
+		const id = binding.idFromName(params[0])
+		return { __type: 'DOId', hex: id.toString() }
+	}
+	if (operation === 'do.idFromString') {
+		const id = binding.idFromString(params[0])
+		return { __type: 'DOId', hex: id.toString() }
+	}
+	if (operation === 'do.newUniqueId') {
+		const id = binding.newUniqueId(params[0])
+		return { __type: 'DOId', hex: id.toString() }
+	}
+	if (operation === 'do.fetch') {
+		const [, serializedId, serializedReq] = params
+		const id = binding.idFromString(serializedId.hex)
+		const stub = binding.get(id)
+		const response = await stub.fetch(new Request(serializedReq.url, {
+			method: serializedReq.method,
+			headers: serializedReq.headers,
+			body: serializedReq.body?.type === 'bytes'
+				? base64ToArrayBuffer(serializedReq.body.data)
+				: undefined
+		}))
+		return serializeResponse(response)
+	}
+	if (operation === 'do.rpc') {
+		const [, serializedId, methodName, args] = params
+		const id = binding.idFromString(serializedId.hex)
+		const stub = binding.get(id)
+		const response = await stub.fetch(new Request('http://do/_rpc', {
+			method: 'POST',
+			headers: { 'Content-Type': 'application/json' },
+			body: JSON.stringify({ method: methodName, params: args })
+		}))
+		const result = await response.json()
+		if (!result.ok) throw new Error(result.error?.message || 'RPC failed')
+		return result.result
+	}
+
+	// Queues
+	if (operation === 'queue.send') return binding.send(params[0], params[1])
+	if (operation === 'queue.sendBatch') return binding.sendBatch(params[0], params[1])
+
+	// Send Email
+	if (operation === 'email.send') {
+		if (binding && typeof binding.send === 'function') {
+			const message = params[0]
+			if (message && typeof message === 'object' && 'from' in message && 'to' in message && 'raw' in message) {
+				return binding.send({
+					from: message.from,
+					to: message.to,
+					[RAW_EMAIL]: createEmailMessageRaw(message.raw)
+				})
+			}
+			return binding.send(message)
+		}
+		return { ok: true, simulated: true }
+	}
+
+	// AI / generic run()
+	if (operation === 'ai.run') {
+		if (typeof binding.run !== 'function') {
+			throw new Error('Binding ' + bindingName + ' does not support run(): ' + method)
+		}
+		return binding.run(params[0], params[1])
+	}
+
+	throw new Error('Unknown operation: ' + method)
+}
+
+// ---------------------------------------------------------------------------
+// WebSocket bridge (shared with src/bridge/server.ts in shape)
+// ---------------------------------------------------------------------------
+// NOTE: wsProxies is intentionally created per handleBridgeWebSocket call so
+// state never leaks across connections or across gateway-script regenerations.
+
+async function handleBridgeRpcCall(msg, ws, env, ctx) {
+	try {
+		const result = await executeRpcMethod(msg.method, msg.params, env, ctx)
+		ws.send(JSON.stringify({ t: 'rpc.ok', id: msg.id, result }))
+	} catch (error) {
+		ws.send(JSON.stringify({
+			t: 'rpc.err',
+			id: msg.id,
+			error: {
+				code: error?.code || 'INTERNAL_ERROR',
+				message: error?.message || String(error)
+			}
+		}))
+	}
+}
+
+async function handleBridgeWsOpen(msg, ws, env, wsProxies) {
+	try {
+		const binding = env[msg.target.binding]
+		const id = binding.idFromString(msg.target.id)
+		const stub = binding.get(id)
+
+		const headers = new Headers(msg.target.headers || [])
+		headers.set('Upgrade', 'websocket')
+
+		const response = await stub.fetch(new Request(msg.target.url, { method: 'GET', headers }))
+		const doWs = response.webSocket
+
+		if (!doWs) {
+			ws.send(JSON.stringify({
+				t: 'rpc.err',
+				id: 'ws_' + msg.wid,
+				error: { code: 'WS_FAILED', message: 'No WebSocket returned' }
+			}))
+			return
+		}
+
+		doWs.accept()
+		wsProxies.set(msg.wid, { doWs })
+
+		doWs.addEventListener('message', (event) => {
+			const isText = typeof event.data === 'string'
+			const data = isText ? event.data : arrayBufferToBase64(event.data)
+			ws.send(JSON.stringify({ t: 'ws.data', wid: msg.wid, data, isText }))
+		})
+
+		doWs.addEventListener('close', (event) => {
+			ws.send(JSON.stringify({ t: 'ws.close', wid: msg.wid, code: event.code, reason: event.reason }))
+			wsProxies.delete(msg.wid)
+		})
+
+		ws.send(JSON.stringify({ t: 'ws.opened', wid: msg.wid }))
+	} catch (error) {
+		ws.send(JSON.stringify({
+			t: 'rpc.err',
+			id: 'ws_' + msg.wid,
+			error: { code: 'WS_FAILED', message: error.message }
+		}))
+	}
+}
+
+function handleBridgeWsClose(msg, wsProxies) {
+	const proxy = wsProxies.get(msg.wid)
+	if (proxy) {
+		proxy.doWs.close(msg.code, msg.reason)
+		wsProxies.delete(msg.wid)
+	}
+}
+
+async function handleBridgeJsonMessage(data, ws, env, ctx, wsProxies) {
+	const msg = JSON.parse(data)
+	switch (msg.t) {
+		case 'hello':
+			// v2 handshake — acknowledge with welcome echoing the negotiated
+			// capability intersection. Capabilities advertised by the gateway
+			// are kept in sync with src/bridge/client.ts (BRIDGE_CLIENT_CAPABILITIES).
+			ws.send(JSON.stringify({
+				t: 'welcome',
+				protocolVersion: 2,
+				capabilities: ['streams', 'ws-relay', 'http-transfer']
+					.filter((c) => Array.isArray(msg.capabilities) && msg.capabilities.includes(c))
+					.sort()
+			}))
+			break
+		case 'rpc.call':
+			await handleBridgeRpcCall(msg, ws, env, ctx)
+			break
+		case 'ws.open':
+			await handleBridgeWsOpen(msg, ws, env, wsProxies)
+			break
+		case 'ws.close':
+			handleBridgeWsClose(msg, wsProxies)
+			break
+	}
+}
+
+function handleBridgeWebSocket(request, env, ctx) {
+	const { 0: client, 1: server } = new WebSocketPair()
+	server.accept()
+
+	// Per-connection state: recreated for every bridge client so reloads and
+	// concurrent clients never share WS proxy entries.
+	const wsProxies = new Map()
+
+	server.addEventListener('message', async (event) => {
+		try {
+			if (typeof event.data === 'string') {
+				await handleBridgeJsonMessage(event.data, server, env, ctx, wsProxies)
+			}
+		} catch (error) {
+			console.error('[Gateway] Error:', error)
+		}
+	})
+
+	server.addEventListener('close', () => {
+		for (const proxy of wsProxies.values()) {
+			// Best-effort cleanup: the DO-side WS may already be closed or in an
+			// invalid state; any throw here would abort sibling closes. Surface
+			// the swallowed error when DEVFLARE_DEBUG_BRIDGE is enabled.
+			try { proxy.doWs.close() } catch (error) {
+				if (globalThis.DEVFLARE_DEBUG_BRIDGE) {
+					console.warn('[devflare:bridge] proxy.doWs.close() failed', error)
+				}
+			}
+		}
+		wsProxies.clear()
+	})
+
+	return new Response(null, { status: 101, webSocket: client })
+}
+
+// ---------------------------------------------------------------------------
+// HTTP transfer for R2 bodies (shared with src/bridge/server.ts in shape)
+// ---------------------------------------------------------------------------
+
+async function handleHttpTransfer(request, env, url) {
+	const transferIdEncoded = url.pathname.split('/').pop()
+	const transferId = decodeURIComponent(transferIdEncoded || '')
+	const [binding, ...keyParts] = transferId.split(':')
+	const key = keyParts.join(':')
+	const bucket = env[binding]
+
+	if (!bucket) return new Response('Bucket not found: ' + binding, { status: 404 })
+
+	if (request.method === 'PUT' || request.method === 'POST') {
+		const result = await bucket.put(key, request.body)
+		return new Response(JSON.stringify(serializeR2Object(result)), {
+			headers: { 'Content-Type': 'application/json' }
+		})
+	}
+
+	if (request.method === 'GET') {
+		const object = await bucket.get(key)
+		if (!object) return new Response('Not found', { status: 404 })
+		return new Response(object.body, {
+			headers: {
+				'Content-Type': object.httpMetadata?.contentType || 'application/octet-stream',
+				'Content-Length': String(object.size)
+			}
+		})
+	}
+
+	return new Response('Method not allowed', { status: 405 })
+}
+`;
+
+// src/bridge/miniflare.ts
+function isIgnorableMiniflareDisposeError(error) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  const details = error;
+  return details.code === "EBADF" && details.syscall === "kill";
+}
+
+export { resolveMiniflareLogLevel, createCompatibilityAwareMiniflareLog, GATEWAY_RUNTIME_JS, isIgnorableMiniflareDisposeError };

package/dist/index-d2md1j3d.js

@@ -0,0 +1,185 @@
+import {
+  resolveConfigForEnvironment
+} from "./index-w4c9vmvg.js";
+
+// src/cli/commands/previews-support/family.ts
+function compareConfiguredWorkerFamilies(left, right) {
+  if (left.role === "primary" && right.role !== "primary") {
+    return -1;
+  }
+  if (left.role !== "primary" && right.role === "primary") {
+    return 1;
+  }
+  return left.baseName.localeCompare(right.baseName);
+}
+function comparePreviewScopeRows(left, right) {
+  const leftTime = left.updatedAt?.getTime() ?? 0;
+  const rightTime = right.updatedAt?.getTime() ?? 0;
+  if (rightTime !== leftTime) {
+    return rightTime - leftTime;
+  }
+  return left.scope.localeCompare(right.scope);
+}
+function collectConfiguredWorkerFamilies(config, environment) {
+  const resolvedConfig = resolveConfigForEnvironment(config, environment);
+  const families = new Map;
+  families.set(resolvedConfig.name, {
+    baseName: resolvedConfig.name,
+    roleLabel: "primary",
+    role: "primary"
+  });
+  for (const [bindingName, binding] of Object.entries(resolvedConfig.bindings?.services ?? {})) {
+    const existing = families.get(binding.service);
+    if (existing) {
+      continue;
+    }
+    families.set(binding.service, {
+      baseName: binding.service,
+      roleLabel: bindingName,
+      role: "service"
+    });
+  }
+  return Array.from(families.values()).sort(compareConfiguredWorkerFamilies);
+}
+function getWorkerUrl(workerName, workersSubdomain) {
+  if (!workersSubdomain) {
+    return;
+  }
+  return `https://${workerName}.${workersSubdomain}.workers.dev`;
+}
+function getWorkerScopeSuffix(workerName, baseName) {
+  if (!workerName.startsWith(`${baseName}-`)) {
+    return;
+  }
+  const suffix = workerName.slice(baseName.length + 1).trim();
+  return suffix || undefined;
+}
+function buildStableWorkerRowsFromLiveWorkers(families, workers, workersSubdomain) {
+  const workersByName = new Map(workers.map((worker) => [worker.name, worker]));
+  return families.map((family) => {
+    const worker = workersByName.get(family.baseName);
+    const status = worker ? "active" : "missing";
+    return {
+      workerName: family.baseName,
+      role: family.roleLabel,
+      status,
+      updatedAt: worker?.modifiedOn,
+      url: worker ? getWorkerUrl(family.baseName, workersSubdomain) : undefined
+    };
+  });
+}
+function getDedicatedPreviewFamilyNamesFromWorkers(families, workers) {
+  const familyNames = new Set;
+  const workerNames = workers.map((worker) => worker.name);
+  for (const family of families) {
+    if (family.role === "primary") {
+      familyNames.add(family.baseName);
+      continue;
+    }
+    if (workerNames.some((workerName) => Boolean(getWorkerScopeSuffix(workerName, family.baseName)))) {
+      familyNames.add(family.baseName);
+    }
+  }
+  return familyNames;
+}
+function buildPreviewScopeRowsFromLiveWorkers(families, workers, workersSubdomain) {
+  const workersByName = new Map(workers.map((worker) => [worker.name, worker]));
+  const previewFamilyNames = getDedicatedPreviewFamilyNamesFromWorkers(families, workers);
+  const expectedFamilies = families.filter((family) => previewFamilyNames.has(family.baseName));
+  const workerCandidatesByScope = buildPreviewWorkerCandidatesByScope(families, workers);
+  return Array.from(workerCandidatesByScope.keys()).map((scope) => {
+    const resolvedFamilies = expectedFamilies.map((family) => ({
+      family,
+      worker: workersByName.get(`${family.baseName}-${scope}`)
+    }));
+    const presentFamilies = resolvedFamilies.filter((entry) => entry.worker);
+    const updatedAt = presentFamilies.reduce((latest, entry) => {
+      const currentDate = entry.worker?.modifiedOn;
+      if (!currentDate) {
+        return latest;
+      }
+      if (!latest || currentDate.getTime() > latest.getTime()) {
+        return currentDate;
+      }
+      return latest;
+    }, undefined);
+    const primaryEntry = resolvedFamilies.find((entry) => entry.family.role === "primary");
+    const entryWorker = primaryEntry?.worker ?? presentFamilies[0]?.worker;
+    const missingLabels = resolvedFamilies.filter((entry) => !entry.worker).map((entry) => entry.family.role === "primary" ? "primary" : entry.family.roleLabel);
+    const notes = [];
+    if (missingLabels.length > 0) {
+      notes.push(`missing ${missingLabels.join(", ")}`);
+    }
+    const strategy = "dedicated workers";
+    const status = presentFamilies.length === resolvedFamilies.length ? "ready" : "partial";
+    return {
+      scope,
+      strategy,
+      workersLabel: `${presentFamilies.length}/${resolvedFamilies.length}`,
+      status,
+      updatedAt,
+      notes: notes.length > 0 ? notes.join(" · ") : undefined,
+      entryUrl: entryWorker ? getWorkerUrl(entryWorker.name, workersSubdomain) : undefined
+    };
+  }).sort(comparePreviewScopeRows);
+}
+function buildPreviewWorkerCandidatesByScope(families, workers) {
+  const candidates = new Map;
+  for (const worker of workers) {
+    for (const family of families) {
+      const scope = getWorkerScopeSuffix(worker.name, family.baseName);
+      if (!scope) {
+        continue;
+      }
+      const names = candidates.get(scope) ?? new Set;
+      names.add(worker.name);
+      candidates.set(scope, names);
+    }
+  }
+  return new Map(Array.from(candidates.entries()).map(([scope, workerNames]) => {
+    return [scope, Array.from(workerNames).sort((left, right) => left.localeCompare(right))];
+  }));
+}
+function orderPreviewWorkerNamesForDeletion(workerNames, scope, families) {
+  const familyPriority = new Map;
+  for (const family of families) {
+    familyPriority.set(family.baseName, {
+      priority: family.role === "primary" ? 0 : 1,
+      roleLabel: family.roleLabel
+    });
+  }
+  const resolveFamilyForWorker = (workerName) => {
+    for (const family of families) {
+      if (getWorkerScopeSuffix(workerName, family.baseName) === scope) {
+        const resolved = familyPriority.get(family.baseName);
+        if (resolved) {
+          return {
+            priority: resolved.priority,
+            roleLabel: resolved.roleLabel,
+            baseName: family.baseName
+          };
+        }
+      }
+    }
+    return {
+      priority: 2,
+      roleLabel: workerName
+    };
+  };
+  return [...workerNames].sort((left, right) => {
+    const leftFamily = resolveFamilyForWorker(left);
+    const rightFamily = resolveFamilyForWorker(right);
+    if (leftFamily.priority !== rightFamily.priority) {
+      return leftFamily.priority - rightFamily.priority;
+    }
+    if (leftFamily.roleLabel !== rightFamily.roleLabel) {
+      return leftFamily.roleLabel.localeCompare(rightFamily.roleLabel);
+    }
+    if (leftFamily.baseName && rightFamily.baseName && leftFamily.baseName !== rightFamily.baseName) {
+      return leftFamily.baseName.localeCompare(rightFamily.baseName);
+    }
+    return left.localeCompare(right);
+  });
+}
+
+export { collectConfiguredWorkerFamilies, buildStableWorkerRowsFromLiveWorkers, buildPreviewScopeRowsFromLiveWorkers, buildPreviewWorkerCandidatesByScope, orderPreviewWorkerNamesForDeletion };