devflare 1.0.0-next.14 → 1.0.0-next.16

package/dist/index-sgb7c8nm.js

@@ -0,0 +1,402 @@
+import {
+  account
+} from "./index-e9yw4d6y.js";
+import {
+  listTrackedRegistryState
+} from "./index-epw1jxz5.js";
+import {
+  createCliTheme,
+  green,
+  red,
+  yellow
+} from "./index-stgn34cr.js";
+import {
+  resolveConfigForEnvironment
+} from "./index-6psz1h4c.js";
+
+// src/cli/commands/previews-support/theme.ts
+function shouldUseColor(options) {
+  return createCliTheme(options).useColor;
+}
+function formatRecordDate(date) {
+  return date ? date.toISOString().slice(0, 19).replace("T", " ") : "N/A";
+}
+function formatStatus(value, theme) {
+  switch (value) {
+    case "active":
+      return green(value, theme);
+    case "superseded":
+    case "reassigned":
+    case "orphaned":
+      return yellow(value, theme);
+    case "deleted":
+    case "rolled_back":
+      return red(value, theme);
+    default:
+      return value;
+  }
+}
+function formatOverviewStatus(value, theme) {
+  switch (value) {
+    case "ready":
+      return green(value, theme);
+    case "partial":
+      return yellow(value, theme);
+    case "missing":
+      return red(value, theme);
+    default:
+      return formatStatus(value, theme);
+  }
+}
+
+// src/cli/commands/previews-support/family.ts
+function isRelatedWorkerName(workerName, familyName) {
+  return workerName === familyName || workerName.startsWith(`${familyName}-`);
+}
+function getPreviewDisplayTimestamp(record) {
+  return (record.updatedAt ?? record.createdAt).getTime();
+}
+function getScopeDisplayTimestamp(record) {
+  return (record.updatedAt ?? record.createdAt).getTime();
+}
+function getDeploymentDisplayTimestamp(record) {
+  return record.createdAt.getTime();
+}
+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 ensureWorkerGroup(groups, workerName) {
+  const existing = groups.get(workerName);
+  if (existing) {
+    return existing;
+  }
+  const created = {
+    workerName,
+    previews: [],
+    scopes: [],
+    deployments: [],
+    latestTimestamp: 0
+  };
+  groups.set(workerName, created);
+  return created;
+}
+function appendWorkerGroupRecords(groups, records, options) {
+  for (const record of records) {
+    const group = ensureWorkerGroup(groups, record.workerName);
+    options.append(group, record);
+    group.latestTimestamp = Math.max(group.latestTimestamp, options.getTimestamp(record));
+  }
+}
+function isVisibleTrackedRecord(record, includeAll) {
+  return includeAll || !record.deletedAt && record.status === "active";
+}
+function buildWorkerGroups(previews, scopes, deployments) {
+  const groups = new Map;
+  appendWorkerGroupRecords(groups, previews, {
+    append: (group, record) => {
+      group.previews.push(record);
+    },
+    getTimestamp: getPreviewDisplayTimestamp
+  });
+  appendWorkerGroupRecords(groups, scopes, {
+    append: (group, record) => {
+      group.scopes.push(record);
+    },
+    getTimestamp: getScopeDisplayTimestamp
+  });
+  appendWorkerGroupRecords(groups, deployments, {
+    append: (group, record) => {
+      group.deployments.push(record);
+    },
+    getTimestamp: getDeploymentDisplayTimestamp
+  });
+  return Array.from(groups.values()).sort((left, right) => {
+    if (right.latestTimestamp !== left.latestTimestamp) {
+      return right.latestTimestamp - left.latestTimestamp;
+    }
+    return left.workerName.localeCompare(right.workerName);
+  });
+}
+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());
+}
+function getLatestDeployment(group, predicate) {
+  return [...group.deployments].filter((record) => predicate ? predicate(record) : true).sort((left, right) => right.createdAt.getTime() - left.createdAt.getTime())[0];
+}
+function getGroupDisplayUrl(group) {
+  return getLatestDeployment(group, (record) => record.channel === "production" && record.status === "active" && Boolean(record.url))?.url ?? getLatestDeployment(group, (record) => record.channel === "preview" && record.status === "active" && Boolean(record.url))?.url ?? getLatestDeployment(group, (record) => Boolean(record.url))?.url ?? [...group.previews].sort((left, right) => getPreviewDisplayTimestamp(right) - getPreviewDisplayTimestamp(left))[0]?.scopeUrl ?? [...group.previews].sort((left, right) => getPreviewDisplayTimestamp(right) - getPreviewDisplayTimestamp(left))[0]?.previewUrl;
+}
+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 buildWorkerGroupMap(groups) {
+  return new Map(groups.map((group) => [group.workerName, group]));
+}
+function getDedicatedPreviewFamilyNames(families, groupsByWorker) {
+  const familyNames = new Set;
+  const workerNames = Array.from(groupsByWorker.keys());
+  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 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
+    };
+  }).sort((left, right) => {
+    if (left.role === "primary" && right.role !== "primary") {
+      return -1;
+    }
+    if (left.role !== "primary" && right.role === "primary") {
+      return 1;
+    }
+    return left.workerName.localeCompare(right.workerName);
+  });
+}
+function buildDedicatedWorkerPreviewScopeRows(families, groupsByWorker) {
+  const previewFamilyNames = getDedicatedPreviewFamilyNames(families, groupsByWorker);
+  const expectedFamilies = families.filter((family) => previewFamilyNames.has(family.baseName));
+  const scopeNames = new Set;
+  for (const family of expectedFamilies) {
+    for (const workerName of groupsByWorker.keys()) {
+      const scope = getWorkerScopeSuffix(workerName, family.baseName);
+      if (scope) {
+        scopeNames.add(scope);
+      }
+    }
+  }
+  return Array.from(scopeNames).map((scope) => {
+    const resolvedFamilies = expectedFamilies.map((family) => ({
+      family,
+      group: groupsByWorker.get(`${family.baseName}-${scope}`)
+    }));
+    const presentFamilies = resolvedFamilies.filter((entry) => entry.group);
+    const updatedAt = presentFamilies.reduce((latest, entry) => {
+      const currentDate = entry.group && entry.group.latestTimestamp > 0 ? new Date(entry.group.latestTimestamp) : undefined;
+      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 entryUrl = primaryEntry?.group ? getGroupDisplayUrl(primaryEntry.group) : presentFamilies[0]?.group ? getGroupDisplayUrl(presentFamilies[0].group) : undefined;
+    const missingLabels = resolvedFamilies.filter((entry) => !entry.group).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
+    };
+  }).sort(comparePreviewScopeRows);
+}
+function buildPreviewScopeRows(families, groupsByWorker) {
+  return buildDedicatedWorkerPreviewScopeRows(families, groupsByWorker);
+}
+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 filterFamilyRecords(records, families) {
+  return records.filter((record) => families.some((family) => isRelatedWorkerName(record.workerName, family.baseName)));
+}
+function isVisiblePreviewRecord(record, includeAll) {
+  return isVisibleTrackedRecord(record, includeAll);
+}
+function isVisibleScopeRecord(record, includeAll) {
+  return isVisibleTrackedRecord(record, includeAll);
+}
+function isVisibleDeploymentRecord(record, includeAll) {
+  return isVisibleTrackedRecord(record, includeAll);
+}
+async function loadTrackedPreviewScopeRows(accountId, databaseName, families, apiOptions) {
+  const registry = await account.getPreviewRegistryContext({
+    accountId,
+    databaseName,
+    apiOptions,
+    skipContextCache: true
+  });
+  if (!registry) {
+    return [];
+  }
+  const { previews, scopes, deployments } = await listTrackedRegistryState({
+    registry,
+    workerName: undefined,
+    apiOptions
+  });
+  const filteredPreviews = filterFamilyRecords(previews, families).filter((record) => isVisiblePreviewRecord(record, false));
+  const filteredScopes = filterFamilyRecords(scopes, families).filter((record) => isVisibleScopeRecord(record, false));
+  const filteredDeployments = filterFamilyRecords(deployments, families).filter((record) => isVisibleDeploymentRecord(record, false));
+  const workerGroups = buildWorkerGroups(filteredPreviews, filteredScopes, filteredDeployments);
+  return buildPreviewScopeRows(families, buildWorkerGroupMap(workerGroups));
+}
+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 { shouldUseColor, formatRecordDate, formatOverviewStatus, collectConfiguredWorkerFamilies, buildStableWorkerRowsFromLiveWorkers, buildPreviewScopeRowsFromLiveWorkers, loadTrackedPreviewScopeRows, buildPreviewWorkerCandidatesByScope, orderPreviewWorkerNamesForDeletion };

package/dist/index-sqrksgb2.js

@@ -0,0 +1,133 @@
+import {
+  createAccountOwnedAPIToken,
+  deleteAccountOwnedAPIToken,
+  listAccountOwnedAPITokens,
+  listAccountTokenPermissionGroups,
+  normalizeDevflareTokenName
+} from "./index-72mve6vh.js";
+import {
+  DEVFLARE_PREVIEW_REGISTRY_DATABASE,
+  cleanupPreviewRegistry,
+  ensurePreviewRegistry,
+  getPreviewRegistryContext,
+  listTrackedDeploymentRecords,
+  listTrackedPreviewAliasRecords,
+  listTrackedPreviewRecords,
+  listTrackedRegistryState,
+  reconcilePreviewRegistry,
+  retirePreviewRegistry
+} from "./index-q4kaz181.js";
+import {
+  canProceedWithTest,
+  getAllUsageSummaries,
+  getLimits,
+  getUsage,
+  getUsageSummary,
+  isWithinLimits,
+  recordTestUsage,
+  recordUsage,
+  resetUsage,
+  setLimits,
+  setLimitsEnabled,
+  shouldSkip
+} from "./index-7g8zyws4.js";
+import {
+  clearGlobalDefaultAccountId,
+  createD1Database,
+  deleteWorker,
+  getAccountById,
+  getAccountSummary,
+  getAccounts,
+  getAllServiceStatus,
+  getEffectiveAccountId,
+  getGlobalDefaultAccountId,
+  getPrimaryAccount,
+  getServiceStatus,
+  getWorkerVersionDetail,
+  getWorkersSubdomain,
+  getWorkspaceAccountId,
+  hasService,
+  listAIModels,
+  listD1Databases,
+  listKVNamespaces,
+  listR2Buckets,
+  listVectorizeIndexes,
+  listWorkerDeployments,
+  listWorkerVersions,
+  listWorkers,
+  queryD1Database,
+  rawD1DatabaseQuery,
+  renameWorker,
+  setGlobalDefaultAccountId,
+  setWorkspaceAccountId
+} from "./index-xk9djfjp.js";
+import {
+  getApiToken,
+  getWranglerAuth,
+  hasWranglerConfig,
+  isAuthenticated
+} from "./index-0w826dsr.js";
+
+// src/cloudflare/index.ts
+var account = {
+  isAuthenticated,
+  hasWranglerConfig,
+  getApiToken,
+  getWranglerAuth,
+  getAccounts,
+  getPrimaryAccount,
+  getAccountById,
+  getAccountSummary,
+  workers: listWorkers,
+  renameWorker,
+  deleteWorker,
+  workerVersions: listWorkerVersions,
+  workerVersion: getWorkerVersionDetail,
+  workerDeployments: listWorkerDeployments,
+  workersSubdomain: getWorkersSubdomain,
+  kv: listKVNamespaces,
+  d1: listD1Databases,
+  createD1Database,
+  queryD1Database,
+  rawD1DatabaseQuery,
+  r2: listR2Buckets,
+  vectorize: listVectorizeIndexes,
+  ai: listAIModels,
+  getServiceStatus,
+  getAllServiceStatus,
+  hasService,
+  getUsage,
+  recordUsage,
+  resetUsage,
+  getAllUsageSummaries,
+  getUsageSummary,
+  getLimits,
+  setLimits,
+  setLimitsEnabled,
+  isWithinLimits,
+  canProceedWithTest,
+  recordTestUsage,
+  shouldSkip,
+  getGlobalDefaultAccountId,
+  setGlobalDefaultAccountId,
+  getWorkspaceAccountId,
+  setWorkspaceAccountId,
+  getEffectiveAccountId,
+  clearGlobalDefaultAccountId,
+  listAccountTokenPermissionGroups,
+  listAccountOwnedAPITokens,
+  createAccountOwnedAPIToken,
+  deleteAccountOwnedAPIToken,
+  normalizeDevflareTokenName,
+  previewRegistryDatabase: DEVFLARE_PREVIEW_REGISTRY_DATABASE,
+  ensurePreviewRegistry,
+  getPreviewRegistryContext,
+  listTrackedPreviewRecords,
+  listTrackedRegistryState,
+  listTrackedPreviewAliasRecords,
+  listTrackedDeploymentRecords,
+  reconcilePreviewRegistry,
+  cleanupPreviewRegistry,
+  retirePreviewRegistry
+};
+export { account };

package/dist/index-stgn34cr.js

@@ -0,0 +1,148 @@
+import {
+  BOLD,
+  CYAN,
+  CYAN_BOLD,
+  DIM,
+  GREEN,
+  RED,
+  RESET,
+  WHITE,
+  YELLOW
+} from "./index-3t6rypgc.js";
+
+// src/cli/ui.ts
+var ANSI_REGEX = /\x1b\[[0-9;]*m/g;
+function createCliTheme(options = {}) {
+  if (options["no-color"] === true) {
+    return { useColor: false };
+  }
+  if (process.env.NO_COLOR?.trim()) {
+    return { useColor: false };
+  }
+  if (process.env.TERM === "dumb") {
+    return { useColor: false };
+  }
+  return {
+    useColor: process.stdout?.isTTY === true
+  };
+}
+function paint(value, code, theme) {
+  return theme.useColor ? `${code}${value}${RESET}` : value;
+}
+function dim(value, theme) {
+  return paint(value, DIM, theme);
+}
+function bold(value, theme) {
+  return paint(value, BOLD, theme);
+}
+function cyan(value, theme) {
+  return paint(value, CYAN, theme);
+}
+function cyanBold(value, theme) {
+  return paint(value, CYAN_BOLD, theme);
+}
+function green(value, theme) {
+  return paint(value, GREEN, theme);
+}
+function yellow(value, theme) {
+  return paint(value, YELLOW, theme);
+}
+function yellowBold(value, theme) {
+  return paint(value, `${BOLD}${YELLOW}`, theme);
+}
+function red(value, theme) {
+  return paint(value, RED, theme);
+}
+function whiteDim(value, theme) {
+  return paint(value, `${DIM}${WHITE}`, theme);
+}
+function accent(value, theme, kind = "cyan") {
+  switch (kind) {
+    case "yellow":
+      return yellowBold(value, theme);
+    case "green":
+      return green(value, theme);
+    case "red":
+      return red(value, theme);
+    case "dim":
+      return dim(value, theme);
+    case "bold":
+      return bold(value, theme);
+    case "white-dim":
+      return whiteDim(value, theme);
+    case "cyan":
+    default:
+      return cyanBold(value, theme);
+  }
+}
+function logLine(logger, message = "") {
+  logger.log(message);
+}
+function stripAnsi(value) {
+  return value.replace(ANSI_REGEX, "");
+}
+function truncateCell(value, width) {
+  if (value.length <= width) {
+    return value;
+  }
+  if (width <= 1) {
+    return "…";
+  }
+  return `${value.slice(0, width - 1)}…`;
+}
+function truncateStyledCell(value, width) {
+  const plainValue = stripAnsi(value);
+  if (plainValue.length <= width) {
+    return value;
+  }
+  const truncatedPlainValue = truncateCell(plainValue, width);
+  const prefixMatch = value.match(/^((?:\x1b\[[0-9;]*m)+)/);
+  const suffixMatch = value.match(/((?:\x1b\[[0-9;]*m)+)$/);
+  const prefix = prefixMatch?.[1] ?? "";
+  const suffix = prefix ? RESET : suffixMatch?.[1] ?? "";
+  return `${prefix}${truncatedPlainValue}${suffix}`;
+}
+function padStyledCell(value, width) {
+  const truncatedValue = truncateStyledCell(value, width);
+  const visibleLength = stripAnsi(truncatedValue).length;
+  return `${truncatedValue}${" ".repeat(Math.max(width - visibleLength, 0))}`;
+}
+function formatTableLine(values, widths) {
+  return values.map((value, index) => {
+    const width = widths[index];
+    if (width === undefined || index === values.length - 1) {
+      return value;
+    }
+    return padStyledCell(value, width);
+  }).join("  ");
+}
+function renderTable(rows, columns, theme) {
+  if (rows.length === 0) {
+    return [];
+  }
+  const widths = columns.map((column) => column.width);
+  return [
+    formatTableLine(columns.map((column) => dim(column.label, theme)), widths),
+    ...rows.map((row) => formatTableLine(columns.map((column) => column.value(row)), widths))
+  ];
+}
+function logTable(logger, options) {
+  if (options.rows.length === 0) {
+    return;
+  }
+  logLine(logger, `${accent(options.title, options.theme, options.titleAccent)} ${dim(`(${options.rows.length})`, options.theme)}`);
+  for (const line of renderTable(options.rows, options.columns, options.theme)) {
+    logLine(logger, line);
+  }
+}
+function formatLabelValue(label, value, theme, labelWidth = 12) {
+  return `${dim(label.padEnd(labelWidth), theme)} ${value}`;
+}
+function formatCommand(command, description, theme) {
+  return `  ${cyan(command, theme)}${dim(" — ", theme)}${description}`;
+}
+function formatBullet(text, theme, bullet = "•") {
+  return `  ${dim(bullet, theme)} ${text}`;
+}
+
+export { createCliTheme, dim, bold, cyan, cyanBold, green, yellow, yellowBold, red, whiteDim, accent, logLine, formatTableLine, logTable, formatLabelValue, formatCommand, formatBullet };

package/dist/{index-v8vvsn9x.js → index-t08te69w.js}

@@ -148,22 +148,5 @@ function ref(nameOrImport, maybeImport) {
   });
   return proxy;
 }
-async function resolveRef(configImport, options) {
-  const result = options?.workerName ? ref(options.workerName, configImport) : ref(configImport);
-  await result.resolve();
-  return result;
-}
-function serviceBinding(refOrLegacy, options) {
-  if ("worker" in refOrLegacy) {
-    const entrypoint2 = options?.entrypoint;
-    return entrypoint2 ? refOrLegacy.worker(entrypoint2) : refOrLegacy.worker;
-  }
-  const entrypoint = options?.entrypoint ?? refOrLegacy.entrypoint;
-  return {
-    service: refOrLegacy.name,
-    ...entrypoint && { entrypoint },
-    __ref: refOrLegacy
-  };
-}
 
-export { defineConfig, ref, resolveRef, serviceBinding };
+export { defineConfig, ref };