devflare 1.0.0-next.3 → 1.0.0-next.31

package/dist/index-1d4jg11n.js

@@ -0,0 +1,542 @@
+import {
+  CloudflareAPIError,
+  apiDelete,
+  apiGet,
+  apiGetAll,
+  apiPatch,
+  apiPost,
+  kvDelete,
+  kvGet,
+  kvPut
+} from "./index-mg8vwqxf.js";
+import {
+  __require
+} from "./index-37x76zdn.js";
+
+// src/cloudflare/account-core.ts
+async function getAccounts(options) {
+  const accounts = await apiGetAll("/accounts", options);
+  return accounts.map((account) => ({
+    id: account.id,
+    name: account.name,
+    type: account.type,
+    createdOn: account.created_on ? new Date(account.created_on) : undefined
+  }));
+}
+async function getPrimaryAccount(options) {
+  const accounts = await getAccounts(options);
+  return accounts[0] ?? null;
+}
+async function getAccountById(accountId, options) {
+  try {
+    const account = await apiGet(`/accounts/${accountId}`, options);
+    return {
+      id: account.id,
+      name: account.name,
+      type: account.type,
+      createdOn: account.created_on ? new Date(account.created_on) : undefined
+    };
+  } catch {
+    return null;
+  }
+}
+
+// src/cloudflare/account-workers.ts
+async function listWorkers(accountId, options) {
+  const scripts = await apiGetAll(`/accounts/${accountId}/workers/scripts`, options);
+  return scripts.map((script) => ({
+    name: script.name ?? script.id,
+    createdOn: new Date(script.created_on),
+    modifiedOn: new Date(script.modified_on)
+  }));
+}
+async function renameWorker(accountId, workerId, newName, options) {
+  const encodedWorkerId = encodeURIComponent(workerId);
+  const result = await apiPatch(`/accounts/${accountId}/workers/workers/${encodedWorkerId}`, { name: newName }, options);
+  return {
+    id: result.id,
+    name: result.name
+  };
+}
+async function deleteWorker(accountId, scriptName, options) {
+  const encodedScriptName = encodeURIComponent(scriptName);
+  await apiDelete(`/accounts/${accountId}/workers/scripts/${encodedScriptName}`, options);
+}
+function mapWorkerVersionInfo(version) {
+  return {
+    id: version.id ?? "",
+    number: version.number,
+    metadata: {
+      authorEmail: version.metadata?.author_email,
+      authorId: version.metadata?.author_id,
+      createdOn: version.metadata?.created_on ? new Date(version.metadata.created_on) : undefined,
+      modifiedOn: version.metadata?.modified_on ? new Date(version.metadata.modified_on) : undefined,
+      hasPreview: version.metadata?.has_preview === true || version.metadata?.hasPreview === true,
+      source: version.metadata?.source
+    }
+  };
+}
+async function listWorkerVersions(accountId, scriptName, options) {
+  const versions = [];
+  const encodedScriptName = encodeURIComponent(scriptName);
+  for (let page = 1;page <= 100; page++) {
+    const result = await apiGet(`/accounts/${accountId}/workers/scripts/${encodedScriptName}/versions?page=${page}&per_page=100`, options);
+    const items = result.items ?? [];
+    versions.push(...items.map((item) => mapWorkerVersionInfo(item)));
+    if (items.length < 100) {
+      break;
+    }
+  }
+  return versions;
+}
+async function getWorkerVersionDetail(accountId, scriptName, versionId, options) {
+  const encodedScriptName = encodeURIComponent(scriptName);
+  const result = await apiGet(`/accounts/${accountId}/workers/scripts/${encodedScriptName}/versions/${versionId}`, options);
+  return mapWorkerVersionInfo(result);
+}
+async function listWorkerDeployments(accountId, scriptName, options) {
+  const encodedScriptName = encodeURIComponent(scriptName);
+  const result = await apiGet(`/accounts/${accountId}/workers/scripts/${encodedScriptName}/deployments`, options);
+  return (result.deployments ?? []).map((deployment) => ({
+    id: deployment.id,
+    createdOn: new Date(deployment.created_on),
+    source: deployment.source,
+    strategy: deployment.strategy,
+    versions: deployment.versions.map((version) => ({
+      percentage: version.percentage,
+      versionId: version.version_id
+    })),
+    message: deployment.annotations?.["workers/message"],
+    triggeredBy: deployment.annotations?.["workers/triggered_by"],
+    authorEmail: deployment.author_email
+  }));
+}
+async function getWorkersSubdomain(accountId, options) {
+  try {
+    const result = await apiGet(`/accounts/${accountId}/workers/subdomain`, options);
+    return result.subdomain || null;
+  } catch {
+    return null;
+  }
+}
+
+// src/cloudflare/account-resources.ts
+async function listKVNamespaces(accountId, options) {
+  const namespaces = await apiGetAll(`/accounts/${accountId}/storage/kv/namespaces`, options);
+  return namespaces.map((namespace) => ({
+    id: namespace.id,
+    name: namespace.title
+  }));
+}
+async function createKVNamespace(accountId, title, options) {
+  const namespace = await apiPost(`/accounts/${accountId}/storage/kv/namespaces`, { title }, options);
+  return {
+    id: namespace.id,
+    name: namespace.title
+  };
+}
+async function deleteKVNamespace(accountId, namespaceId, options) {
+  const encodedNamespaceId = encodeURIComponent(namespaceId);
+  await apiDelete(`/accounts/${accountId}/storage/kv/namespaces/${encodedNamespaceId}`, options);
+}
+async function listD1Databases(accountId, options) {
+  const databases = await apiGetAll(`/accounts/${accountId}/d1/database`, options);
+  return databases.map((database) => ({
+    id: database.uuid,
+    name: database.name,
+    version: database.version,
+    tableCount: database.num_tables,
+    sizeBytes: database.file_size
+  }));
+}
+async function createD1Database(accountId, name, options) {
+  const created = await apiPost(`/accounts/${accountId}/d1/database`, {
+    name,
+    ...options?.jurisdiction ? { jurisdiction: options.jurisdiction } : {},
+    ...options?.primaryLocationHint ? { primary_location_hint: options.primaryLocationHint } : {}
+  }, options);
+  return {
+    id: created.uuid,
+    name: created.name,
+    version: created.version,
+    tableCount: created.num_tables,
+    sizeBytes: created.file_size
+  };
+}
+async function deleteD1Database(accountId, databaseId, options) {
+  const encodedDatabaseId = encodeURIComponent(databaseId);
+  await apiDelete(`/accounts/${accountId}/d1/database/${encodedDatabaseId}`, options);
+}
+async function queryD1Database(accountId, databaseId, query, options) {
+  const { apiPost: apiPost2 } = await import("./api-2n6dd2ws.js");
+  return apiPost2(`/accounts/${accountId}/d1/database/${databaseId}/query`, query, options);
+}
+async function rawD1DatabaseQuery(accountId, databaseId, query, options) {
+  const { apiPost: apiPost2 } = await import("./api-2n6dd2ws.js");
+  return apiPost2(`/accounts/${accountId}/d1/database/${databaseId}/raw`, query, options);
+}
+async function listQueues(accountId, options) {
+  const queues = await apiGetAll(`/accounts/${accountId}/queues`, options);
+  return queues.filter((queue) => {
+    return typeof queue.queue_id === "string" && queue.queue_id.length > 0 && typeof queue.queue_name === "string" && queue.queue_name.length > 0;
+  }).map((queue) => ({
+    id: queue.queue_id,
+    name: queue.queue_name,
+    createdOn: queue.created_on ? new Date(queue.created_on) : undefined,
+    modifiedOn: queue.modified_on ? new Date(queue.modified_on) : undefined,
+    deliveryDelay: queue.settings?.delivery_delay,
+    deliveryPaused: queue.settings?.delivery_paused,
+    messageRetentionPeriod: queue.settings?.message_retention_period
+  }));
+}
+async function createQueue(accountId, queueName, options) {
+  const queue = await apiPost(`/accounts/${accountId}/queues`, { queue_name: queueName }, options);
+  return {
+    id: queue.queue_id ?? "",
+    name: queue.queue_name ?? queueName,
+    createdOn: queue.created_on ? new Date(queue.created_on) : undefined,
+    modifiedOn: queue.modified_on ? new Date(queue.modified_on) : undefined,
+    deliveryDelay: queue.settings?.delivery_delay,
+    deliveryPaused: queue.settings?.delivery_paused,
+    messageRetentionPeriod: queue.settings?.message_retention_period
+  };
+}
+async function deleteQueue(accountId, queueId, options) {
+  const encodedQueueId = encodeURIComponent(queueId);
+  await apiDelete(`/accounts/${accountId}/queues/${encodedQueueId}`, options);
+}
+async function listR2Buckets(accountId, options) {
+  const buckets = await apiGetAll(`/accounts/${accountId}/r2/buckets`, options);
+  return buckets.map((bucket) => ({
+    name: bucket.name,
+    createdOn: new Date(bucket.creation_date),
+    location: bucket.location
+  }));
+}
+async function createR2Bucket(accountId, name, options) {
+  const bucket = await apiPost(`/accounts/${accountId}/r2/buckets`, {
+    name,
+    ...options?.locationHint ? { locationHint: options.locationHint } : {},
+    ...options?.storageClass ? { storageClass: options.storageClass } : {}
+  }, options);
+  return {
+    name: bucket.name,
+    createdOn: bucket.creation_date ? new Date(bucket.creation_date) : new Date,
+    location: bucket.location
+  };
+}
+async function deleteR2Bucket(accountId, bucketName, options) {
+  const encodedBucketName = encodeURIComponent(bucketName);
+  await apiDelete(`/accounts/${accountId}/r2/buckets/${encodedBucketName}`, options);
+}
+async function listHyperdrives(accountId, options) {
+  const hyperdrives = await apiGetAll(`/accounts/${accountId}/hyperdrive/configs`, options);
+  return hyperdrives.map((hyperdrive) => ({
+    id: hyperdrive.id,
+    name: hyperdrive.name,
+    createdOn: hyperdrive.created_on ? new Date(hyperdrive.created_on) : undefined,
+    modifiedOn: hyperdrive.modified_on ? new Date(hyperdrive.modified_on) : undefined
+  }));
+}
+async function deleteHyperdrive(accountId, hyperdriveId, options) {
+  const encodedHyperdriveId = encodeURIComponent(hyperdriveId);
+  await apiDelete(`/accounts/${accountId}/hyperdrive/configs/${encodedHyperdriveId}`, options);
+}
+async function listVectorizeIndexes(accountId, options) {
+  try {
+    const indexes = await apiGetAll(`/accounts/${accountId}/vectorize/v2/indexes`, options);
+    return indexes.map((index) => ({
+      name: index.name,
+      dimensions: index.config.dimensions,
+      metric: index.config.metric,
+      description: index.description
+    }));
+  } catch (error) {
+    if (error instanceof CloudflareAPIError && error.code === 404) {
+      return [];
+    }
+    throw error;
+  }
+}
+async function createVectorizeIndex(accountId, index, options) {
+  const created = await apiPost(`/accounts/${accountId}/vectorize/v2/indexes`, {
+    name: index.name,
+    config: {
+      dimensions: index.dimensions,
+      metric: index.metric
+    },
+    ...index.description ? { description: index.description } : {}
+  }, options);
+  return {
+    name: created.name,
+    dimensions: created.config.dimensions,
+    metric: created.config.metric,
+    description: created.description
+  };
+}
+async function deleteVectorizeIndex(accountId, indexName, options) {
+  const encodedIndexName = encodeURIComponent(indexName);
+  await apiDelete(`/accounts/${accountId}/vectorize/v2/indexes/${encodedIndexName}`, options);
+}
+async function listAIModels(accountId, options) {
+  try {
+    const models = await apiGetAll(`/accounts/${accountId}/ai/models/search`, options);
+    return models.map((model) => ({
+      id: model.id,
+      name: model.name,
+      task: model.task?.name,
+      description: model.description
+    }));
+  } catch {
+    return [];
+  }
+}
+
+// src/cloudflare/account-status.ts
+var SERVICE_STATUS_TIMEOUT_MS = 1e4;
+var serviceInventoryFetchers = {
+  workers: listWorkers,
+  kv: listKVNamespaces,
+  d1: listD1Databases,
+  hyperdrive: listHyperdrives,
+  r2: listR2Buckets,
+  vectorize: listVectorizeIndexes,
+  ai: listAIModels
+};
+async function withServiceTimeout(operation) {
+  let timeoutId = null;
+  const timeoutPromise = new Promise((_, reject) => {
+    timeoutId = setTimeout(() => reject(new Error("timeout")), SERVICE_STATUS_TIMEOUT_MS);
+  });
+  try {
+    return await Promise.race([
+      operation,
+      timeoutPromise
+    ]);
+  } finally {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+  }
+}
+function createAvailableServiceStatus(service, count) {
+  return {
+    service,
+    available: service === "ai" ? count > 0 : true,
+    count
+  };
+}
+async function getServiceStatus(accountId, service) {
+  const fetchInventory = serviceInventoryFetchers[service];
+  if (!fetchInventory) {
+    return {
+      service,
+      available: false
+    };
+  }
+  try {
+    const inventory = await withServiceTimeout(fetchInventory(accountId));
+    return createAvailableServiceStatus(service, inventory.length);
+  } catch {
+    return {
+      service,
+      available: false
+    };
+  }
+}
+async function getAllServiceStatus(accountId) {
+  const services = [
+    "workers",
+    "kv",
+    "d1",
+    "hyperdrive",
+    "r2",
+    "vectorize",
+    "ai"
+  ];
+  return Promise.all(services.map((service) => getServiceStatus(accountId, service)));
+}
+async function hasService(accountId, service) {
+  const status = await getServiceStatus(accountId, service);
+  return status.available;
+}
+async function getAccountSummary(accountId) {
+  const account = await getAccountById(accountId);
+  if (!account) {
+    return null;
+  }
+  const services = await getAllServiceStatus(accountId);
+  return {
+    account,
+    services
+  };
+}
+// src/cloudflare/preferences.ts
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { existsSync, readFileSync, writeFileSync, mkdirSync, renameSync, unlinkSync } from "node:fs";
+
+// src/cloudflare/kv-namespace.ts
+var DEVFLARE_KV_NAMESPACE_TITLE = "devflare-usage";
+async function getOrCreateNamedKVNamespace(accountId, title = DEVFLARE_KV_NAMESPACE_TITLE, options) {
+  const namespaces = await apiGetAll(`/accounts/${accountId}/storage/kv/namespaces`, options);
+  const existing = namespaces.find((namespace) => namespace.title === title);
+  if (existing) {
+    return existing.id;
+  }
+  const created = await apiPost(`/accounts/${accountId}/storage/kv/namespaces`, { title }, options);
+  return created.id;
+}
+
+// src/cloudflare/preferences.ts
+var GLOBAL_ACCOUNT_KEY = "settings:defaultAccountId";
+var LOCAL_CACHE_DIR = ".devflare";
+var LOCAL_CACHE_FILE = "preferences.json";
+function writeFileAtomic(path, contents) {
+  const tmpPath = path + ".tmp-" + process.pid + "-" + Date.now();
+  writeFileSync(tmpPath, contents, "utf-8");
+  try {
+    renameSync(tmpPath, path);
+  } catch (error) {
+    try {
+      unlinkSync(tmpPath);
+    } catch {}
+    throw error;
+  }
+}
+function getLocalPreferencesPath() {
+  return join(homedir(), LOCAL_CACHE_DIR, LOCAL_CACHE_FILE);
+}
+function readLocalPreferences() {
+  const path = getLocalPreferencesPath();
+  if (!existsSync(path)) {
+    return {};
+  }
+  try {
+    const content = readFileSync(path, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return {};
+  }
+}
+function writeLocalPreferences(prefs) {
+  const path = getLocalPreferencesPath();
+  const dir = join(homedir(), LOCAL_CACHE_DIR);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileAtomic(path, JSON.stringify(prefs, null, "\t"));
+}
+function findPackageJsonPath(startDir) {
+  let dir = startDir ?? process.cwd();
+  while (dir !== join(dir, "..")) {
+    const pkgPath = join(dir, "package.json");
+    if (existsSync(pkgPath)) {
+      return pkgPath;
+    }
+    dir = join(dir, "..");
+  }
+  return null;
+}
+function readPackageJson(path) {
+  try {
+    const content = readFileSync(path, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function writePackageJson(path, pkg) {
+  writeFileAtomic(path, JSON.stringify(pkg, null, "\t") + `
+`);
+}
+function getWorkspaceAccountId() {
+  const pkgPath = findPackageJsonPath();
+  if (!pkgPath)
+    return null;
+  const pkg = readPackageJson(pkgPath);
+  return pkg?.devflare?.accountId ?? null;
+}
+function setWorkspaceAccountId(accountId) {
+  let pkgPath = findPackageJsonPath();
+  let pkg;
+  if (pkgPath) {
+    pkg = readPackageJson(pkgPath) ?? {};
+  } else {
+    pkgPath = join(process.cwd(), "package.json");
+    pkg = {
+      name: "workspace",
+      private: true
+    };
+  }
+  if (!pkg.devflare) {
+    pkg.devflare = {};
+  }
+  pkg.devflare.accountId = accountId;
+  writePackageJson(pkgPath, pkg);
+  return pkgPath;
+}
+async function getOrCreatePreferencesNamespace(accountId) {
+  return getOrCreateNamedKVNamespace(accountId, DEVFLARE_KV_NAMESPACE_TITLE);
+}
+async function getGlobalDefaultAccountId(fallbackAccountId) {
+  const local = readLocalPreferences();
+  if (local.defaultAccountId) {
+    return local.defaultAccountId;
+  }
+  try {
+    const namespaceId = await getOrCreatePreferencesNamespace(fallbackAccountId);
+    const value = await kvGet(fallbackAccountId, namespaceId, GLOBAL_ACCOUNT_KEY);
+    if (value) {
+      writeLocalPreferences({
+        ...local,
+        defaultAccountId: value,
+        lastUpdated: new Date().toISOString()
+      });
+      return value;
+    }
+  } catch (error) {
+    console.debug("[devflare preferences] cloud KV sync failed:", error instanceof Error ? error.message : String(error));
+  }
+  return null;
+}
+async function setGlobalDefaultAccountId(accountId, anyAccountId) {
+  const kvAccountId = anyAccountId ?? accountId;
+  const local = readLocalPreferences();
+  writeLocalPreferences({
+    ...local,
+    defaultAccountId: accountId,
+    lastUpdated: new Date().toISOString()
+  });
+  try {
+    const namespaceId = await getOrCreatePreferencesNamespace(kvAccountId);
+    await kvPut(kvAccountId, namespaceId, GLOBAL_ACCOUNT_KEY, accountId);
+  } catch (error) {
+    console.debug("[devflare preferences] cloud KV sync failed:", error instanceof Error ? error.message : String(error));
+  }
+}
+async function getEffectiveAccountId(primaryAccountId) {
+  const workspaceId = getWorkspaceAccountId();
+  if (workspaceId) {
+    return { accountId: workspaceId, source: "workspace" };
+  }
+  const globalId = await getGlobalDefaultAccountId(primaryAccountId);
+  if (globalId) {
+    return { accountId: globalId, source: "global" };
+  }
+  return { accountId: primaryAccountId, source: "primary" };
+}
+async function clearGlobalDefaultAccountId(anyAccountId) {
+  const local = readLocalPreferences();
+  delete local.defaultAccountId;
+  local.lastUpdated = new Date().toISOString();
+  writeLocalPreferences(local);
+  try {
+    const namespaceId = await getOrCreatePreferencesNamespace(anyAccountId);
+    await kvDelete(anyAccountId, namespaceId, GLOBAL_ACCOUNT_KEY);
+  } catch (error) {
+    console.debug("[devflare preferences] cloud KV sync failed:", error instanceof Error ? error.message : String(error));
+  }
+}
+
+export { getAccounts, getPrimaryAccount, getAccountById, listWorkers, renameWorker, deleteWorker, listWorkerVersions, getWorkerVersionDetail, listWorkerDeployments, getWorkersSubdomain, listKVNamespaces, createKVNamespace, deleteKVNamespace, listD1Databases, createD1Database, deleteD1Database, queryD1Database, rawD1DatabaseQuery, listQueues, createQueue, deleteQueue, listR2Buckets, createR2Bucket, deleteR2Bucket, listHyperdrives, deleteHyperdrive, listVectorizeIndexes, createVectorizeIndex, deleteVectorizeIndex, listAIModels, getServiceStatus, getAllServiceStatus, hasService, getAccountSummary, DEVFLARE_KV_NAMESPACE_TITLE, getOrCreateNamedKVNamespace, getWorkspaceAccountId, setWorkspaceAccountId, getGlobalDefaultAccountId, setGlobalDefaultAccountId, getEffectiveAccountId, clearGlobalDefaultAccountId };

package/dist/index-3edvz3hs.js

@@ -0,0 +1,124 @@
+import {
+  DEFAULT_ENTRYPOINT_PATTERN,
+  findFiles,
+  findFilesSync
+} from "./index-qwgr4q7s.js";
+import {
+  __require
+} from "./index-37x76zdn.js";
+
+// src/utils/entrypoint-discovery.ts
+import { readFileSync } from "fs";
+var ENTRYPOINT_CLASS_PATTERN = /export\s+class\s+(\w+)\s+extends\s+WorkerEntrypoint/g;
+function findEntrypointClasses(code) {
+  const classes = [];
+  ENTRYPOINT_CLASS_PATTERN.lastIndex = 0;
+  let match;
+  while ((match = ENTRYPOINT_CLASS_PATTERN.exec(code)) !== null) {
+    classes.push(match[1]);
+  }
+  return classes;
+}
+function discoverEntrypointsSync(cwd, pattern = DEFAULT_ENTRYPOINT_PATTERN) {
+  const discovered = [];
+  try {
+    const files = findFilesSync(pattern, { cwd });
+    for (const file of files) {
+      try {
+        const code = readFileSync(file, "utf-8");
+        const classNames = findEntrypointClasses(code);
+        for (const className of classNames) {
+          discovered.push({ className, filePath: file });
+        }
+      } catch {}
+    }
+  } catch {}
+  return discovered;
+}
+async function discoverEntrypointsAsync(cwd, pattern = DEFAULT_ENTRYPOINT_PATTERN) {
+  const fs = await import("node:fs/promises");
+  const discovered = [];
+  const files = await findFiles(pattern, { cwd });
+  for (const filePath of files) {
+    try {
+      const code = await fs.readFile(filePath, "utf-8");
+      const classNames = findEntrypointClasses(code);
+      for (const className of classNames) {
+        discovered.push({ className, filePath });
+      }
+    } catch {}
+  }
+  return discovered;
+}
+
+// src/utils/resolve-package.ts
+import { resolve, dirname } from "pathe";
+import { readFileSync as readFileSync2, existsSync } from "node:fs";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { createRequire } from "node:module";
+var NOT_FOUND_CODES = new Set(["MODULE_NOT_FOUND", "ERR_MODULE_NOT_FOUND"]);
+function isNotFoundError(error) {
+  if (!error || typeof error !== "object") {
+    return false;
+  }
+  const code = error.code;
+  return typeof code === "string" && NOT_FOUND_CODES.has(code);
+}
+function resolveSpecifier(specifier, fromDir) {
+  const fromFileUrl = pathToFileURL(resolve(fromDir, "package.json")).href;
+  const importMetaResolve = import.meta.resolve;
+  if (typeof importMetaResolve === "function") {
+    try {
+      const resolved = importMetaResolve(specifier, fromFileUrl);
+      if (typeof resolved === "string") {
+        return resolved.startsWith("file:") ? fileURLToPath(resolved) : resolved;
+      }
+    } catch (error) {
+      if (!isNotFoundError(error)) {
+        throw error;
+      }
+    }
+  }
+  try {
+    const require_ = createRequire(fromFileUrl);
+    return require_.resolve(specifier);
+  } catch (error) {
+    if (isNotFoundError(error)) {
+      return null;
+    }
+    throw error;
+  }
+}
+function resolvePackageSpecifier(specifier, fromDir) {
+  if (specifier.startsWith(".") || specifier.startsWith("/") || /^[A-Za-z]:/.test(specifier)) {
+    return resolve(fromDir, specifier);
+  }
+  const parts = specifier.startsWith("@") ? specifier.split("/").slice(0, 2).join("/") : specifier.split("/")[0];
+  const subpath = specifier.startsWith("@") ? specifier.split("/").slice(2).join("/") : specifier.split("/").slice(1).join("/");
+  const pkgJsonPath = resolveSpecifier(`${parts}/package.json`, fromDir);
+  if (!pkgJsonPath) {
+    return resolve(fromDir, specifier);
+  }
+  const pkgDir = dirname(pkgJsonPath);
+  if (subpath) {
+    const pkgJson = JSON.parse(readFileSync2(pkgJsonPath, "utf-8"));
+    const exportPath = pkgJson.exports?.[`./${subpath}`];
+    if (exportPath) {
+      const targetPath = typeof exportPath === "string" ? exportPath : exportPath.default || exportPath.import;
+      return resolve(pkgDir, targetPath);
+    }
+    const directPath = resolve(pkgDir, `${subpath}.ts`);
+    if (existsSync(directPath))
+      return directPath;
+    const withExt = resolve(pkgDir, subpath);
+    if (existsSync(withExt))
+      return withExt;
+    if (existsSync(`${withExt}.ts`))
+      return `${withExt}.ts`;
+    if (existsSync(`${withExt}.js`))
+      return `${withExt}.js`;
+  }
+  return pkgDir;
+}
+
+export { discoverEntrypointsSync, discoverEntrypointsAsync, resolvePackageSpecifier };