devflare 1.0.0-next.39 → 1.0.0-next.40

package/dist/index-627srx16.js

@@ -1,45 +0,0 @@
-// src/cli/package-metadata.ts
-import { readFile } from "node:fs/promises";
-import { fileURLToPath } from "node:url";
-import { dirname, resolve } from "pathe";
-var packageMetadataPromise = null;
-async function loadPackageMetadata() {
-  let currentDir = dirname(fileURLToPath(import.meta.url));
-  while (true) {
-    const packageJsonPath = resolve(currentDir, "package.json");
-    try {
-      const packageJson = await readFile(packageJsonPath, "utf8");
-      const metadata = JSON.parse(packageJson);
-      if (metadata.name === "devflare") {
-        return metadata;
-      }
-    } catch {}
-    const parentDir = dirname(currentDir);
-    if (parentDir === currentDir) {
-      throw new Error("Could not resolve the devflare package.json file");
-    }
-    currentDir = parentDir;
-  }
-}
-async function getPackageMetadata() {
-  if (!packageMetadataPromise) {
-    packageMetadataPromise = loadPackageMetadata();
-  }
-  return packageMetadataPromise;
-}
-async function getPackageVersion() {
-  return (await getPackageMetadata()).version ?? "0.0.0";
-}
-async function getInitDependencyVersions() {
-  const metadata = await getPackageMetadata();
-  const dependencies = metadata.dependencies ?? {};
-  const devDependencies = metadata.devDependencies ?? {};
-  return {
-    devflare: `^${metadata.version ?? "0.0.0"}`,
-    typescript: devDependencies.typescript ?? "^5.7.0",
-    wrangler: dependencies.wrangler ?? devDependencies.wrangler ?? "^4.85.0",
-    workersTypes: devDependencies["@cloudflare/workers-types"] ?? "^4.20250109.0"
-  };
-}
-
-export { getPackageVersion, getInitDependencyVersions };

package/dist/index-7m557715.js

@@ -1,283 +0,0 @@
-// src/transform/worker-entrypoint.ts
-import MagicString from "magic-string";
-import ts from "typescript";
-
-// src/worker-entry/extensions.ts
-var SUPPORTED_WORKER_EXTENSIONS = [
-  ".ts",
-  ".tsx",
-  ".mts",
-  ".mjs",
-  ".cts",
-  ".cjs",
-  ".js",
-  ".jsx"
-];
-var TS_WORKER_EXTENSIONS = [".ts", ".tsx", ".mts", ".cts"];
-
-// src/transform/worker-entrypoint.ts
-function findExportedFunctions(code) {
-  const functions = [];
-  const sourceFile = ts.createSourceFile("worker.ts", code, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
-  function visit(node) {
-    if (ts.isFunctionDeclaration(node) && node.name) {
-      const modifiers = ts.getModifiers(node);
-      const isExported = modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword);
-      const isDefault = modifiers?.some((m) => m.kind === ts.SyntaxKind.DefaultKeyword);
-      if (isExported) {
-        const isAsync = modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) ?? false;
-        const funcName = isDefault ? "fetch" : node.name.text;
-        const params = node.parameters.map((p) => code.substring(p.getStart(sourceFile), p.getEnd())).join(", ");
-        const returnType = node.type ? code.substring(node.type.getStart(sourceFile), node.type.getEnd()) : undefined;
-        functions.push({
-          name: funcName,
-          isAsync,
-          params,
-          returnType,
-          start: node.getStart(sourceFile),
-          end: node.getEnd(),
-          isDefault
-        });
-      }
-    }
-    if (ts.isFunctionDeclaration(node) && !node.name) {
-      const modifiers = ts.getModifiers(node);
-      const isExported = modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword);
-      const isDefault = modifiers?.some((m) => m.kind === ts.SyntaxKind.DefaultKeyword);
-      if (isExported && isDefault) {
-        const isAsync = modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) ?? false;
-        const params = node.parameters.map((p) => code.substring(p.getStart(sourceFile), p.getEnd())).join(", ");
-        const returnType = node.type ? code.substring(node.type.getStart(sourceFile), node.type.getEnd()) : undefined;
-        functions.push({
-          name: "fetch",
-          isAsync,
-          params,
-          returnType,
-          start: node.getStart(sourceFile),
-          end: node.getEnd(),
-          isDefault: true
-        });
-      }
-    }
-    if (ts.isVariableStatement(node)) {
-      const modifiers = ts.getModifiers(node);
-      const isExported = modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword);
-      if (isExported) {
-        for (const decl of node.declarationList.declarations) {
-          if (ts.isIdentifier(decl.name) && decl.initializer) {
-            let funcExpr;
-            if (ts.isFunctionExpression(decl.initializer)) {
-              funcExpr = decl.initializer;
-            } else if (ts.isArrowFunction(decl.initializer)) {
-              funcExpr = decl.initializer;
-            }
-            if (funcExpr) {
-              const modifiersArr = ts.getModifiers(funcExpr);
-              const isAsync = modifiersArr?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) ?? (ts.isArrowFunction(funcExpr) && funcExpr.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword)) ?? false;
-              const params = funcExpr.parameters.map((p) => code.substring(p.getStart(sourceFile), p.getEnd())).join(", ");
-              const returnType = funcExpr.type ? code.substring(funcExpr.type.getStart(sourceFile), funcExpr.type.getEnd()) : undefined;
-              functions.push({
-                name: decl.name.text,
-                isAsync,
-                params,
-                returnType,
-                start: node.getStart(sourceFile),
-                end: node.getEnd()
-              });
-            }
-          }
-        }
-      }
-    }
-    ts.forEachChild(node, visit);
-  }
-  visit(sourceFile);
-  return functions;
-}
-function shouldEmitTsSyntax(filename) {
-  const lower = filename.toLowerCase();
-  return TS_WORKER_EXTENSIONS.some((ext) => lower.endsWith(ext));
-}
-function shouldTransformWorker(code, filePath) {
-  const lower = filePath.toLowerCase();
-  const isWorkerFile = SUPPORTED_WORKER_EXTENSIONS.some((ext) => lower.endsWith(`worker${ext}`));
-  if (!isWorkerFile) {
-    return false;
-  }
-  const functions = findExportedFunctions(code);
-  return functions.length > 0;
-}
-function transformWorkerEntrypoint(code, id, options = {}) {
-  const className = options.className ?? "Worker";
-  const injectContext = options.injectContext ?? true;
-  const emitTs = shouldEmitTsSyntax(id);
-  const functions = findExportedFunctions(code);
-  if (functions.length === 0) {
-    return null;
-  }
-  const fetchFn = functions.find((f) => f.name === "fetch");
-  const rpcMethods = functions.filter((f) => f.name !== "fetch");
-  const needsFetchHelpers = Boolean(fetchFn);
-  const s = new MagicString(code);
-  const importStatement = `import { WorkerEntrypoint } from 'cloudflare:workers'
-`;
-  if (needsFetchHelpers) {
-    const runtimeImports = ["createFetchEvent", "invokeFetchHandler"];
-    if (injectContext) {
-      runtimeImports.push("runWithEventContext");
-    }
-    s.prepend(`import { ${runtimeImports.join(", ")} } from 'devflare/runtime'
-`);
-  }
-  s.prepend(importStatement);
-  const sourceFile = ts.createSourceFile("worker.ts", code, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
-  const internalNameFor = (name) => name === "fetch" ? "__originalFetch" : `__original_${name}`;
-  function visit(node) {
-    if (ts.isFunctionDeclaration(node)) {
-      const modifiers = ts.getModifiers(node);
-      const exportMod = modifiers?.find((m) => m.kind === ts.SyntaxKind.ExportKeyword);
-      const defaultMod = modifiers?.find((m) => m.kind === ts.SyntaxKind.DefaultKeyword);
-      const asyncMod = modifiers?.find((m) => m.kind === ts.SyntaxKind.AsyncKeyword);
-      if (exportMod) {
-        const isDefault = Boolean(defaultMod);
-        const logicalName = isDefault ? "fetch" : node.name?.text;
-        if (logicalName) {
-          const internal = internalNameFor(logicalName);
-          if (isDefault && !node.name) {
-            const funcKeyword = node.getChildren(sourceFile).find((c) => c.kind === ts.SyntaxKind.FunctionKeyword);
-            if (funcKeyword) {
-              const asyncKw = asyncMod ? "async " : "";
-              s.overwrite(node.getStart(sourceFile), funcKeyword.getStart(sourceFile), `const ${internal} = ${asyncKw}`);
-            }
-          } else if (node.name) {
-            s.remove(exportMod.getStart(sourceFile), exportMod.getEnd());
-            if (defaultMod) {
-              s.remove(defaultMod.getStart(sourceFile), defaultMod.getEnd());
-            }
-            s.overwrite(node.name.getStart(sourceFile), node.name.getEnd(), internal);
-          }
-        }
-      }
-    } else if (ts.isVariableStatement(node)) {
-      const modifiers = ts.getModifiers(node);
-      const exportMod = modifiers?.find((m) => m.kind === ts.SyntaxKind.ExportKeyword);
-      if (exportMod) {
-        let rewroteAny = false;
-        for (const decl of node.declarationList.declarations) {
-          if (ts.isIdentifier(decl.name) && decl.initializer && (ts.isFunctionExpression(decl.initializer) || ts.isArrowFunction(decl.initializer))) {
-            const internal = internalNameFor(decl.name.text);
-            s.overwrite(decl.name.getStart(sourceFile), decl.name.getEnd(), internal);
-            rewroteAny = true;
-          }
-        }
-        if (rewroteAny) {
-          s.remove(exportMod.getStart(sourceFile), exportMod.getEnd());
-        }
-      }
-    }
-    ts.forEachChild(node, visit);
-  }
-  visit(sourceFile);
-  let classBody = `
-
-// ============ Devflare WorkerEntrypoint ============
-class ${className} extends WorkerEntrypoint {
-`;
-  if (fetchFn) {
-    const fetchSig = emitTs ? "async fetch(request: Request): Promise<Response>" : "async fetch(request)";
-    classBody += `	${fetchSig} {
-`;
-    classBody += `		const __devflareEvent = createFetchEvent(request, this.env, this.ctx)
-`;
-    if (injectContext) {
-      classBody += `		return runWithEventContext(
-`;
-      classBody += `			__devflareEvent,
-`;
-      classBody += `			() => invokeFetchHandler(__originalFetch, __devflareEvent)
-`;
-      classBody += `		)
-`;
-      classBody += `	}
-`;
-    } else {
-      classBody += `		return invokeFetchHandler(__originalFetch, __devflareEvent)
-`;
-      classBody += `	}
-`;
-    }
-  }
-  for (const fn of rpcMethods) {
-    const asyncPrefix = fn.isAsync ? "async " : "";
-    const paramNames = extractParamNames(fn.params);
-    const signatureParams = emitTs ? fn.params : paramNames;
-    const returnType = emitTs && fn.returnType ? `: ${fn.returnType}` : "";
-    classBody += `
-	${asyncPrefix}${fn.name}(${signatureParams})${returnType} {
-`;
-    classBody += `		return __original_${fn.name}(${paramNames})
-`;
-    classBody += `	}
-`;
-  }
-  classBody += `}
-
-`;
-  classBody += `export { ${className} }
-`;
-  classBody += `export { ${className} as default }
-`;
-  classBody += `// ============ End Devflare WorkerEntrypoint ============
-`;
-  s.append(classBody);
-  return {
-    code: s.toString(),
-    map: s.generateMap({
-      source: id,
-      file: id + ".map",
-      includeContent: true
-    }),
-    rpcMethods: rpcMethods.map((fn) => fn.name),
-    className
-  };
-}
-function extractParamNames(params) {
-  if (!params.trim())
-    return "";
-  const tempCode = `function f(${params}) {}`;
-  const sourceFile = ts.createSourceFile("temp.ts", tempCode, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
-  const names = [];
-  function visit(node) {
-    if (ts.isFunctionDeclaration(node)) {
-      for (const param of node.parameters) {
-        if (ts.isIdentifier(param.name)) {
-          names.push(param.name.text);
-        } else if (ts.isObjectBindingPattern(param.name) || ts.isArrayBindingPattern(param.name)) {
-          names.push(tempCode.substring(param.name.getStart(sourceFile), param.name.getEnd()));
-        }
-      }
-    }
-    ts.forEachChild(node, visit);
-  }
-  visit(sourceFile);
-  return names.join(", ");
-}
-function generateRpcInterface(functions, interfaceName) {
-  const rpcMethods = functions.filter((f) => f.name !== "fetch");
-  if (rpcMethods.length === 0) {
-    return "";
-  }
-  let output = `export interface ${interfaceName} {
-`;
-  for (const fn of rpcMethods) {
-    const returnType = fn.returnType ?? "unknown";
-    const promiseReturn = returnType.startsWith("Promise<") ? returnType : `Promise<${returnType}>`;
-    output += `	${fn.name}(${fn.params}): ${promiseReturn}
-`;
-  }
-  output += `}
-`;
-  return output;
-}
-
-export { SUPPORTED_WORKER_EXTENSIONS, findExportedFunctions, shouldEmitTsSyntax, shouldTransformWorker, transformWorkerEntrypoint, generateRpcInterface };

package/dist/index-a8pnvg3r.js

@@ -1,52 +0,0 @@
-import {
-  findFiles
-} from "./index-5dkjffqz.js";
-import {
-  resolveConfigPath
-} from "./index-x8s9rwfh.js";
-
-// src/cli/config-path.ts
-import { stat } from "node:fs/promises";
-var CONFIG_FILE_EXTENSIONS = [".ts", ".mts", ".js", ".mjs"];
-var SUPPORTED_CONFIG_FILENAMES = CONFIG_FILE_EXTENSIONS.map((extension) => `devflare.config${extension}`);
-function hasKnownConfigExtension(filePath) {
-  return CONFIG_FILE_EXTENSIONS.some((extension) => filePath.endsWith(extension));
-}
-async function getExistingFilePath(filePath) {
-  try {
-    const fileStat = await stat(filePath);
-    return fileStat.isFile() ? filePath : null;
-  } catch {
-    return null;
-  }
-}
-async function resolveConfigCandidatePath(candidatePath) {
-  const candidates = [candidatePath];
-  if (!hasKnownConfigExtension(candidatePath)) {
-    for (const extension of CONFIG_FILE_EXTENSIONS) {
-      candidates.push(`${candidatePath}${extension}`);
-    }
-  }
-  for (const candidate of candidates) {
-    const existingFilePath = await getExistingFilePath(candidate);
-    if (existingFilePath) {
-      return existingFilePath;
-    }
-  }
-  return await resolveConfigPath(candidatePath) ?? null;
-}
-async function findConfigPathsUnderDirectory(rootDir) {
-  const matches = await findFiles([
-    ...SUPPORTED_CONFIG_FILENAMES,
-    ...SUPPORTED_CONFIG_FILENAMES.map((filename) => `**/${filename}`)
-  ], {
-    cwd: rootDir,
-    absolute: true
-  });
-  return [...new Set(matches)].sort((left, right) => left.localeCompare(right));
-}
-function formatSupportedConfigFilenames() {
-  return SUPPORTED_CONFIG_FILENAMES.join(", ");
-}
-
-export { resolveConfigCandidatePath, findConfigPathsUnderDirectory, formatSupportedConfigFilenames };

package/dist/index-aabgympv.js

@@ -1,39 +0,0 @@
-import {
-  __require
-} from "./index-37x76zdn.js";
-
-// src/cli/generated-artifacts.ts
-import { resolve } from "pathe";
-var DEVFLARE_DIR = [".devflare"];
-var DEVFLARE_BUILD_DIR = [".devflare", "build"];
-var WRANGLER_DEPLOY_DIR = [".wrangler", "deploy"];
-function getGeneratedArtifactPaths(cwd) {
-  const devflareDir = resolve(cwd, ...DEVFLARE_DIR);
-  const buildDir = resolve(cwd, ...DEVFLARE_BUILD_DIR);
-  const deployDir = resolve(cwd, ...WRANGLER_DEPLOY_DIR);
-  return {
-    devflareDir,
-    devWranglerConfigPath: resolve(devflareDir, "wrangler.jsonc"),
-    buildDir,
-    buildWorkerPath: resolve(buildDir, "worker.js"),
-    buildWranglerConfigPath: resolve(buildDir, "wrangler.jsonc"),
-    deployDir,
-    deployRedirectPath: resolve(deployDir, "config.json")
-  };
-}
-async function ensureGeneratedDirectory(dirPath, writeGitignore = false) {
-  const fs = await import("node:fs/promises");
-  await fs.mkdir(dirPath, { recursive: true });
-  if (!writeGitignore) {
-    return;
-  }
-  const gitignorePath = resolve(dirPath, ".gitignore");
-  try {
-    await fs.access(gitignorePath);
-  } catch {
-    await fs.writeFile(gitignorePath, `*
-`, "utf-8");
-  }
-}
-
-export { getGeneratedArtifactPaths, ensureGeneratedDirectory };

package/dist/index-atwc3csp.js

@@ -1,256 +0,0 @@
-import {
-  apiDelete,
-  apiGetAll,
-  apiPost,
-  apiPut
-} from "./index-04wh9bxx.js";
-
-// src/cloudflare/known-permission-group-ids.generated.ts
-var KNOWN_PERMISSION_GROUP_IDS_DATA = {
-  WORKERS_SCRIPTS_WRITE: null,
-  WORKERS_SCRIPTS_READ: null,
-  ACCOUNT_SETTINGS_READ: null,
-  WORKERS_KV_STORAGE_WRITE: null,
-  WORKERS_KV_STORAGE_READ: null,
-  ACCOUNT_API_TOKENS_WRITE: null,
-  ACCOUNT_API_TOKENS_READ: null
-};
-
-// src/cloudflare/tokens.ts
-var MAX_ACCOUNT_OWNED_TOKEN_PERMISSION_GROUPS = 300;
-var DEVFLARE_MANAGED_TOKEN_PREFIX = "devflare-";
-var ACCOUNT_OWNED_TOKEN_SCOPE = "com.cloudflare.api.account";
-var ACCOUNT_ZONE_OWNED_TOKEN_SCOPE = "com.cloudflare.api.account.zone";
-var ACCOUNT_API_TOKENS_PERMISSION_GROUP_NAME_PATTERN = /^Account API Tokens\b/i;
-var DEVFLARE_MANAGED_TOKEN_NAME_PATTERN = /^devflare-/i;
-var DEVFLARE_PERMISSION_GROUP_NAME_PATTERNS = [
-  /^Account Analytics /i,
-  /^Account Settings /i,
-  /^Account Filter Lists /i,
-  /^AI /i,
-  /^Analytics /i,
-  /^Browser Rendering /i,
-  /^Cache Purge\b/i,
-  /^D1 /i,
-  /^DNS /i,
-  /^Email /i,
-  /^Hyperdrive /i,
-  /^Images /i,
-  /^Logs /i,
-  /^Logpush /i,
-  /^Pages /i,
-  /^Queues /i,
-  /^R2 /i,
-  /^SSL and Certificates /i,
-  /^Stream /i,
-  /^Vectorize /i,
-  /^Workers /i,
-  /^Zone Settings /i,
-  /^Zone /i
-];
-function deriveKnownPermissionGroupIds(data) {
-  const result = {};
-  for (const key of Object.keys(data)) {
-    const value = data[key];
-    result[key] = value === null ? undefined : value;
-  }
-  return result;
-}
-var KNOWN_PERMISSION_GROUP_IDS = deriveKnownPermissionGroupIds(KNOWN_PERMISSION_GROUP_IDS_DATA);
-function dedupePermissionGroups(permissionGroups) {
-  const seenIds = new Set;
-  return permissionGroups.filter((permissionGroup) => {
-    if (seenIds.has(permissionGroup.id)) {
-      return false;
-    }
-    seenIds.add(permissionGroup.id);
-    return true;
-  });
-}
-function dedupePermissionGroupIds(permissionGroupIds) {
-  return Array.from(new Set(permissionGroupIds.map((id) => id.trim()).filter(Boolean)));
-}
-function dedupeScopedPermissionGroups(permissionGroups) {
-  const seenIds = new Set;
-  return permissionGroups.filter((permissionGroup) => {
-    const id = permissionGroup.id.trim();
-    if (!id || seenIds.has(id)) {
-      return false;
-    }
-    seenIds.add(id);
-    return true;
-  });
-}
-function permissionGroupHasScope(permissionGroup, scope) {
-  return permissionGroup.scopes.some((value) => value.trim() === scope);
-}
-function buildCreateTokenPoliciesFromPermissionGroups(accountId, permissionGroups) {
-  const dedupedPermissionGroups = dedupeScopedPermissionGroups(permissionGroups);
-  const accountPermissionGroupIds = dedupePermissionGroupIds(dedupedPermissionGroups.filter((permissionGroup) => permissionGroupHasScope(permissionGroup, ACCOUNT_OWNED_TOKEN_SCOPE)).map((permissionGroup) => permissionGroup.id));
-  const zonePermissionGroupIds = dedupePermissionGroupIds(dedupedPermissionGroups.filter((permissionGroup) => permissionGroupHasScope(permissionGroup, ACCOUNT_ZONE_OWNED_TOKEN_SCOPE)).map((permissionGroup) => permissionGroup.id));
-  const policies = [];
-  if (accountPermissionGroupIds.length > 0) {
-    policies.push({
-      effect: "allow",
-      resources: {
-        [`com.cloudflare.api.account.${accountId}`]: "*"
-      },
-      permission_groups: accountPermissionGroupIds.map((id) => ({ id }))
-    });
-  }
-  if (zonePermissionGroupIds.length > 0) {
-    policies.push({
-      effect: "allow",
-      resources: {
-        [`com.cloudflare.api.account.${accountId}`]: {
-          [`${ACCOUNT_ZONE_OWNED_TOKEN_SCOPE}.*`]: "*"
-        }
-      },
-      permission_groups: zonePermissionGroupIds.map((id) => ({ id }))
-    });
-  }
-  return policies;
-}
-function buildCreateTokenPoliciesFromPermissionGroupIds(accountId, permissionGroupIds) {
-  const dedupedPermissionGroupIds = dedupePermissionGroupIds(permissionGroupIds);
-  if (dedupedPermissionGroupIds.length === 0) {
-    return [];
-  }
-  return [
-    {
-      effect: "allow",
-      resources: {
-        [`com.cloudflare.api.account.${accountId}`]: "*"
-      },
-      permission_groups: dedupedPermissionGroupIds.map((id) => ({ id }))
-    }
-  ];
-}
-function excludeAccountApiTokensPermissionGroups(permissionGroups) {
-  return permissionGroups.filter((permissionGroup) => {
-    return !ACCOUNT_API_TOKENS_PERMISSION_GROUP_NAME_PATTERN.test(permissionGroup.name);
-  });
-}
-function keepAccountOwnedTokenCompatiblePermissionGroups(permissionGroups) {
-  return permissionGroups.filter((permissionGroup) => {
-    return permissionGroup.scopes.some((scope) => {
-      const normalizedScope = scope.trim();
-      return normalizedScope === ACCOUNT_OWNED_TOKEN_SCOPE || normalizedScope === ACCOUNT_ZONE_OWNED_TOKEN_SCOPE;
-    });
-  });
-}
-function selectReusableAccountOwnedTokenPermissionGroups(permissionGroups) {
-  return dedupePermissionGroups(excludeAccountApiTokensPermissionGroups(keepAccountOwnedTokenCompatiblePermissionGroups(permissionGroups)));
-}
-function parseOptionalDate(value) {
-  if (!value) {
-    return;
-  }
-  const parsed = new Date(value);
-  return Number.isNaN(parsed.getTime()) ? undefined : parsed;
-}
-function mapAccountOwnedAPITokenPolicy(policy) {
-  return {
-    id: policy.id,
-    effect: policy.effect,
-    permissionGroups: policy.permission_groups?.map((permissionGroup) => ({
-      id: permissionGroup.id,
-      name: permissionGroup.name
-    }))
-  };
-}
-function mapAccountOwnedAPIToken(token) {
-  return {
-    id: token.id,
-    name: token.name ?? token.id,
-    status: token.status,
-    value: token.value,
-    issuedOn: parseOptionalDate(token.issued_on),
-    modifiedOn: parseOptionalDate(token.modified_on),
-    lastUsedOn: parseOptionalDate(token.last_used_on),
-    policies: token.policies?.map(mapAccountOwnedAPITokenPolicy)
-  };
-}
-function isDevflareManagedTokenName(name) {
-  return DEVFLARE_MANAGED_TOKEN_NAME_PATTERN.test(name.trim());
-}
-function normalizeDevflareTokenName(name) {
-  const trimmedName = name.trim();
-  if (!trimmedName) {
-    throw new Error("Devflare token name cannot be empty");
-  }
-  const suffix = isDevflareManagedTokenName(trimmedName) ? trimmedName.replace(DEVFLARE_MANAGED_TOKEN_NAME_PATTERN, "") : trimmedName;
-  if (!suffix) {
-    throw new Error("Devflare token name cannot be empty");
-  }
-  return `${DEVFLARE_MANAGED_TOKEN_PREFIX}${suffix}`;
-}
-function stripDevflareTokenNamePrefix(name) {
-  const trimmedName = name.trim();
-  if (!trimmedName) {
-    return trimmedName;
-  }
-  const strippedName = trimmedName.replace(DEVFLARE_MANAGED_TOKEN_NAME_PATTERN, "");
-  return strippedName || trimmedName;
-}
-function filterDevflareManagedTokens(tokens) {
-  return tokens.filter((token) => isDevflareManagedTokenName(token.name));
-}
-function selectDevflarePermissionGroups(permissionGroups) {
-  const selectedPermissionGroups = dedupePermissionGroups(selectReusableAccountOwnedTokenPermissionGroups(permissionGroups).filter((permissionGroup) => {
-    return DEVFLARE_PERMISSION_GROUP_NAME_PATTERNS.some((pattern) => {
-      return pattern.test(permissionGroup.name);
-    });
-  }));
-  if (selectedPermissionGroups.length === 0) {
-    throw new Error("Could not map the available Cloudflare permission groups to a Devflare token policy.");
-  }
-  if (selectedPermissionGroups.length > MAX_ACCOUNT_OWNED_TOKEN_PERMISSION_GROUPS) {
-    throw new Error(`Devflare selected ${selectedPermissionGroups.length} permission groups, which exceeds Cloudflare's ${MAX_ACCOUNT_OWNED_TOKEN_PERMISSION_GROUPS}-group limit for account-owned tokens.`);
-  }
-  return selectedPermissionGroups;
-}
-function selectAllReusablePermissionGroups(permissionGroups) {
-  const selectedPermissionGroups = selectReusableAccountOwnedTokenPermissionGroups(permissionGroups);
-  if (selectedPermissionGroups.length === 0) {
-    throw new Error("Could not find any reusable account/zone-scoped Cloudflare permission groups for this Devflare token.");
-  }
-  if (selectedPermissionGroups.length > MAX_ACCOUNT_OWNED_TOKEN_PERMISSION_GROUPS) {
-    throw new Error(`Devflare selected ${selectedPermissionGroups.length} permission groups, which exceeds Cloudflare's ${MAX_ACCOUNT_OWNED_TOKEN_PERMISSION_GROUPS}-group limit for account-owned tokens.`);
-  }
-  return selectedPermissionGroups;
-}
-async function listAccountTokenPermissionGroups(accountId, options) {
-  const permissionGroups = await apiGetAll(`/accounts/${accountId}/tokens/permission_groups`, options);
-  return dedupePermissionGroups(permissionGroups);
-}
-async function listAccountOwnedAPITokens(accountId, options) {
-  const tokens = await apiGetAll(`/accounts/${accountId}/tokens`, options);
-  return tokens.map(mapAccountOwnedAPIToken);
-}
-async function deleteAccountOwnedAPIToken(accountId, tokenId, options) {
-  return apiDelete(`/accounts/${accountId}/tokens/${tokenId}`, options);
-}
-async function rollAccountOwnedAPITokenValue(accountId, tokenId, options) {
-  return apiPut(`/accounts/${accountId}/tokens/${tokenId}/value`, {}, options);
-}
-async function createAccountOwnedAPIToken(accountId, options, clientOptions) {
-  const permissionGroupIds = dedupePermissionGroupIds(options.permissionGroups?.map((permissionGroup) => permissionGroup.id) ?? options.permissionGroupIds ?? []);
-  if (permissionGroupIds.length === 0) {
-    throw new Error("Cannot create a Devflare token without any permission groups");
-  }
-  if (permissionGroupIds.length > MAX_ACCOUNT_OWNED_TOKEN_PERMISSION_GROUPS) {
-    throw new Error(`Cannot create a Devflare token with more than ${MAX_ACCOUNT_OWNED_TOKEN_PERMISSION_GROUPS} permission groups.`);
-  }
-  const policies = options.permissionGroups ? buildCreateTokenPoliciesFromPermissionGroups(accountId, options.permissionGroups) : buildCreateTokenPoliciesFromPermissionGroupIds(accountId, permissionGroupIds);
-  if (policies.length === 0) {
-    throw new Error("Cannot create a Devflare token without any account- or zone-scoped permission groups");
-  }
-  const createdToken = await apiPost(`/accounts/${accountId}/tokens`, {
-    name: options.name,
-    policies
-  }, clientOptions);
-  return mapAccountOwnedAPIToken(createdToken);
-}
-
-export { normalizeDevflareTokenName, stripDevflareTokenNamePrefix, filterDevflareManagedTokens, selectDevflarePermissionGroups, selectAllReusablePermissionGroups, listAccountTokenPermissionGroups, listAccountOwnedAPITokens, deleteAccountOwnedAPIToken, rollAccountOwnedAPITokenValue, createAccountOwnedAPIToken };