neonctl 2.24.0 → 2.24.2

package/commands/link.js

@@ -3,6 +3,8 @@ import prompts from 'prompts';
 import { applyContext, readContextFile } from '../context.js';
 import { isCi } from '../env.js';
 import { log } from '../log.js';
+import { createBranch, pickBranchInteractively, } from '../utils/branch_picker.js';
+import { autoPullEnvAfterPin, renderAgentPullNote } from './env.js';
 import { REGIONS } from './projects.js';
 const PROJECTS_LIST_LIMIT = 100;
 const CREATE_NEW_SENTINEL = '__create_new__';
@@ -40,6 +42,13 @@ export const builder = (argv) => argv.usage('$0 link [options]').options({
         type: 'boolean',
         default: false,
     },
+    'env-pull': {
+        describe: "Pull the linked branch's Neon env vars (DATABASE_URL, …) into a local .env after " +
+            'linking. On by default; use --no-env-pull to skip (e.g. when injecting env at ' +
+            'runtime with `neon-env run` / `neon dev`).',
+        type: 'boolean',
+        default: true,
+    },
 });
 export const handler = async (props) => {
     if (props.agent) {
@@ -134,7 +143,7 @@ const runNonInteractive = async (props, inputs) => {
             projectId: inputs.projectId,
             branchId,
         });
-        printHumanSummary(props, {
+        await finalizeHumanLink(props, {
             contextFile: props.contextFile,
             orgId,
             projectId: inputs.projectId,
@@ -153,7 +162,7 @@ const runNonInteractive = async (props, inputs) => {
         projectId: created.project.id,
         branchId: created.branchId,
     });
-    printHumanSummary(props, {
+    await finalizeHumanLink(props, {
         contextFile: props.contextFile,
         orgId,
         projectId: created.project.id,
@@ -187,13 +196,13 @@ const runInteractive = async (props, inputs) => {
         orgId = await promptOrgFromList(orgResolution.orgs);
     }
     if (inputs.projectId) {
-        const branchId = await resolveDefaultBranchId(props, inputs.projectId);
+        const branchId = await resolveInteractiveBranchId(props, inputs.projectId);
         applyContext(props.contextFile, {
             orgId,
             projectId: inputs.projectId,
             branchId,
         });
-        printHumanSummary(props, {
+        await finalizeHumanLink(props, {
             contextFile: props.contextFile,
             orgId,
             projectId: inputs.projectId,
@@ -213,7 +222,7 @@ const runInteractive = async (props, inputs) => {
             projectId: created.project.id,
             branchId: created.branchId,
         });
-        printHumanSummary(props, {
+        await finalizeHumanLink(props, {
             contextFile: props.contextFile,
             orgId,
             projectId: created.project.id,
@@ -228,13 +237,13 @@ const runInteractive = async (props, inputs) => {
     const projects = await listAllProjects(props, orgId);
     const action = await promptProjectChoice(projects, inputs.projectName);
     if (action.type === 'existing') {
-        const branchId = await resolveDefaultBranchId(props, action.projectId);
+        const branchId = await resolveInteractiveBranchId(props, action.projectId);
         applyContext(props.contextFile, {
             orgId,
             projectId: action.projectId,
             branchId,
         });
-        printHumanSummary(props, {
+        await finalizeHumanLink(props, {
             contextFile: props.contextFile,
             orgId,
             projectId: action.projectId,
@@ -257,7 +266,7 @@ const runInteractive = async (props, inputs) => {
         projectId: created.project.id,
         branchId: created.branchId,
     });
-    printHumanSummary(props, {
+    await finalizeHumanLink(props, {
         contextFile: props.contextFile,
         orgId,
         projectId: created.project.id,
@@ -382,12 +391,18 @@ const runAgent = async (props, inputs) => {
     if (projectId) {
         const branchId = await resolveDefaultBranchId(props, projectId);
         applyContext(props.contextFile, { orgId, projectId, branchId });
+        const pullNote = renderAgentPullNote(await autoPullEnvAfterPin({
+            ...props,
+            projectId,
+            branch: branchId,
+            envPull: props.envPull,
+        }));
         emitAgent({
             status: 'linked',
             context_file: props.contextFile,
             context: { orgId, projectId, branchId },
             project: { id: projectId },
-            message: `Linked ${props.contextFile} to project ${projectId} (org ${orgId}) on branch ${branchId}.`,
+            message: `Linked ${props.contextFile} to project ${projectId} (org ${orgId}) on branch ${branchId}.${pullNote}`,
         });
         return;
     }
@@ -416,6 +431,12 @@ const runAgent = async (props, inputs) => {
             projectId: created.project.id,
             branchId: created.branchId,
         });
+        const pullNote = renderAgentPullNote(await autoPullEnvAfterPin({
+            ...props,
+            projectId: created.project.id,
+            branch: created.branchId,
+            envPull: props.envPull,
+        }));
         emitAgent({
             status: 'linked',
             context_file: props.contextFile,
@@ -429,7 +450,7 @@ const runAgent = async (props, inputs) => {
                 name: created.project.name,
                 region_id: created.project.region_id,
             },
-            message: `Created project ${created.project.id} ("${created.project.name ?? projectName}") in ${created.project.region_id ?? regionId} and linked ${props.contextFile}.`,
+            message: `Created project ${created.project.id} ("${created.project.name ?? projectName}") in ${created.project.region_id ?? regionId} and linked ${props.contextFile}.${pullNote}`,
         });
         return;
     }
@@ -591,6 +612,33 @@ const resolveDefaultBranchId = async (props, projectId) => {
     }
     return branch.id;
 };
+/**
+ * Resolve which branch to pin for an interactively-chosen project. When the project has a
+ * single branch there is nothing to choose, so we pin it silently. Otherwise we offer the
+ * shared branch picker (the same "＋ Create a new branch…" + list as `neonctl checkout`),
+ * creating the branch when the user opts to. This makes `link` a full org → project →
+ * branch flow instead of always pinning the default branch.
+ */
+const resolveInteractiveBranchId = async (props, projectId) => {
+    const { data } = await props.apiClient.listProjectBranches({ projectId });
+    const branches = data.branches;
+    if (branches.length <= 1) {
+        const only = branches.find((b) => b.default) ?? branches[0];
+        if (!only) {
+            throw new Error(`Could not find a default branch for project ${projectId}.`);
+        }
+        return only.id;
+    }
+    const picked = await pickBranchInteractively(branches, {
+        message: 'Which branch would you like to link?',
+        nonInteractiveMessage: 'No branch could be selected without an interactive terminal. ' +
+            'Re-run `neonctl link` interactively, or `neonctl checkout <branch>` to pin one.',
+    });
+    if (picked.kind === 'existing') {
+        return picked.branchId;
+    }
+    return createBranch(props.apiClient, projectId, picked.name, branches);
+};
 const fetchRegions = async (props) => {
     try {
         const { data } = await props.apiClient.getActiveRegions();
@@ -648,6 +696,20 @@ const printHumanSummary = (_props, summary) => {
     lines.push('');
     process.stdout.write(`${lines.join('\n')}\n`);
 };
+/**
+ * Print the link summary, then run the bundled `env pull` so a human `link` ends with the
+ * branch's connection string already on disk — the branch-first loop is just link + checkout.
+ * `--no-env-pull` opts out (env pull's own status / skip hint is logged to stderr).
+ */
+const finalizeHumanLink = async (props, summary) => {
+    printHumanSummary(props, summary);
+    await autoPullEnvAfterPin({
+        ...props,
+        projectId: summary.projectId,
+        branch: summary.branchId,
+        envPull: props.envPull,
+    });
+};
 const onPromptState = (state) => {
     if (state.aborted) {
         process.stdout.write('\x1B[?25h');

package/dev/env.js

@@ -2,6 +2,12 @@ import { loadConfigFromFile, } from '@neondatabase/config';
 import { plan, pullConfig, } from '@neondatabase/config-runtime';
 import { fetchEnv, toEntries } from '@neondatabase/env';
 import { log } from '../log.js';
+/** The API-targeting options every runtime call forwards from the context. */
+const apiOptions = (ctx) => ({
+    ...(ctx.apiKey ? { apiKey: ctx.apiKey } : {}),
+    ...(ctx.apiHost ? { apiHost: ctx.apiHost } : {}),
+    ...(ctx.api ? { api: ctx.api } : {}),
+});
 /**
  * Thrown when a `neon.ts` policy declares a branch-level resource (Neon Auth,
  * Data API, a bucket, the AI Gateway) that the linked remote branch does not
@@ -70,8 +76,7 @@ export const resolveNeonEnvVars = async (ctx) => {
         const pulled = await pullConfig({
             projectId: ctx.projectId,
             branchId: ctx.branchId,
-            ...(ctx.apiKey ? { apiKey: ctx.apiKey } : {}),
-            ...(ctx.api ? { api: ctx.api } : {}),
+            ...apiOptions(ctx),
         });
         // `pulled.config` is already a `Config` (static auth/dataApi toggles + a branch
         // tuning closure), so it feeds straight into fetchEnv — no wrapping needed.
@@ -82,24 +87,40 @@ export const resolveNeonEnvVars = async (ctx) => {
 };
 /**
  * `neon dev`'s env resolver: {@link resolveNeonEnvVars} with graceful degradation.
- * A missing branch context or any failure (no Neon account, no `.neon`, no network)
- * logs a warning and returns `{}` so the function still runs locally; only a
- * {@link DevEnvMismatchError} (policy declares a resource the branch lacks) is
- * re-thrown for the caller to surface.
+ *
+ * - Success → `{ vars }` (possibly just the always-present Postgres URLs).
+ * - No linked branch / project → `{ vars: {}, skipped }` with a "link a branch" hint; the
+ *   function still runs locally, just without Neon env.
+ * - Any other failure (offline, transient API error) → `{ vars: {}, skipped }` naming the
+ *   cause; again non-fatal.
+ * - {@link DevEnvMismatchError} (policy declares a secret-bearing service the branch lacks)
+ *   is the one hard stop and is re-thrown for the caller to surface.
  */
 export const resolveDevEnv = async (ctx) => {
     try {
-        return await resolveNeonEnvVars(ctx);
+        return { vars: await resolveNeonEnvVars(ctx) };
     }
     catch (err) {
         if (err instanceof DevEnvMismatchError)
             throw err;
         if (err instanceof MissingBranchContextError) {
             log.debug('dev: %s; skipping env injection', err.message);
-            return {};
+            return {
+                vars: {},
+                skipped: {
+                    reason: 'no linked Neon branch — run `neonctl link`, then ' +
+                        '`neonctl checkout <branch>`, to inject DATABASE_URL and friends',
+                },
+            };
         }
-        log.warning('Could not inject Neon env vars; the function will run without them: %s', err instanceof Error ? err.message : String(err));
-        return {};
+        const detail = err instanceof Error ? err.message : String(err);
+        log.debug('dev: env resolution failed: %s', detail);
+        return {
+            vars: {},
+            skipped: {
+                reason: `could not reach Neon (${detail}); running without Neon env`,
+            },
+        };
     }
 };
 /**
@@ -133,8 +154,7 @@ const assertPolicyMatchesBranch = async (config, ctx) => {
     const result = await plan(config, {
         projectId: ctx.projectId,
         branchId: ctx.branchId,
-        ...(ctx.apiKey ? { apiKey: ctx.apiKey } : {}),
-        ...(ctx.api ? { api: ctx.api } : {}),
+        ...apiOptions(ctx),
     });
     const missing = result.applied.filter(isMissingResource);
     if (missing.length === 0)
@@ -158,8 +178,7 @@ const fetchAndProject = async (config, ctx) => {
     const env = await fetchEnv(config, {
         projectId: ctx.projectId,
         branchId: ctx.branchId,
-        ...(ctx.apiKey ? { apiKey: ctx.apiKey } : {}),
-        ...(ctx.api ? { api: ctx.api } : {}),
+        ...apiOptions(ctx),
     });
     return toEntries(env);
 };

package/package.json

@@ -5,7 +5,7 @@
     "url": "git+ssh://git@github.com/neondatabase/neonctl.git"
   },
   "type": "module",
-  "version": "2.24.0",
+  "version": "2.24.2",
   "description": "CLI tool for NeonDB Cloud management",
   "main": "index.js",
   "author": "NeonDB",
@@ -59,9 +59,9 @@
   "dependencies": {
     "@hono/node-server": "2.0.4",
     "@neondatabase/api-client": "2.7.1",
-    "@neondatabase/config": "0.4.0",
-    "@neondatabase/config-runtime": "0.4.0",
-    "@neondatabase/env": "0.3.0",
+    "@neondatabase/config": "0.4.2",
+    "@neondatabase/config-runtime": "0.4.2",
+    "@neondatabase/env": "0.3.2",
     "@segment/analytics-node": "1.3.0",
     "axios": "1.7.2",
     "axios-debug-log": "1.0.0",

package/pkg.js

@@ -1,3 +1,25 @@
 import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
-export default JSON.parse(readFileSync(fileURLToPath(new URL('./package.json', import.meta.url)), 'utf-8'));
+/**
+ * Load the CLI's package.json for version metadata. In the built CLI it sits right next to
+ * this module (the build copies it into `dist`); when running from source (tests, `tsx`) it
+ * does not, so we walk up to the nearest `package.json`. Both layouts resolve to the same
+ * file, keeping `pkg.version` correct everywhere without a test-only shim.
+ */
+const loadPkg = () => {
+    let dir = dirname(fileURLToPath(import.meta.url));
+    for (;;) {
+        try {
+            return JSON.parse(readFileSync(join(dir, 'package.json'), 'utf-8'));
+        }
+        catch {
+            const parent = dirname(dir);
+            if (parent === dir) {
+                throw new Error('Could not locate package.json for version detection.');
+            }
+            dir = parent;
+        }
+    }
+};
+export default loadPkg();

package/storage_api.js

@@ -0,0 +1,114 @@
+// Typed client helpers for the branch object-storage (bucket/object) API.
+//
+// These endpoints are part of the Neon object-storage surface (the "Buckets"
+// tag in the public API). They are not yet exposed as typed methods on the
+// published `@neondatabase/api-client` package, so the request/response types
+// and the thin call helpers live here. They are implemented on top of the
+// api-client's public `request()` method, which means they reuse the exact
+// same authentication, base URL, headers and retry behaviour as every other
+// neonctl command. When the generated client gains these methods, the call
+// sites in `src/commands/bucket.ts` can switch over with no behavioural
+// change.
+const bucketsPath = (projectId, branchId) => `/projects/${encodeURIComponent(projectId)}/branches/${encodeURIComponent(branchId)}/buckets`;
+const bucketPath = (projectId, branchId, bucketName) => `${bucketsPath(projectId, branchId)}/${encodeURIComponent(bucketName)}`;
+/**
+ * Create a bucket on a branch.
+ *
+ * @request POST /projects/{project_id}/branches/{branch_id}/buckets
+ */
+export const createProjectBranchBucket = (apiClient, { projectId, branchId, name, accessLevel, }) => {
+    const body = { name };
+    // Omit access_level entirely so the server default (`private`) applies.
+    if (accessLevel !== undefined) {
+        body.access_level = accessLevel;
+    }
+    return apiClient.request({
+        path: bucketsPath(projectId, branchId),
+        method: 'POST',
+        body,
+        format: 'json',
+        secure: true,
+    });
+};
+/**
+ * List the buckets on a branch.
+ *
+ * @request GET /projects/{project_id}/branches/{branch_id}/buckets
+ */
+export const listProjectBranchBuckets = (apiClient, { projectId, branchId }) => apiClient.request({
+    path: bucketsPath(projectId, branchId),
+    method: 'GET',
+    format: 'json',
+    secure: true,
+});
+/**
+ * Delete a bucket from a branch.
+ *
+ * @request DELETE /projects/{project_id}/branches/{branch_id}/buckets/{bucket_name}
+ */
+export const deleteProjectBranchBucket = (apiClient, { projectId, branchId, bucketName, }) => apiClient.request({
+    path: bucketPath(projectId, branchId, bucketName),
+    method: 'DELETE',
+    secure: true,
+});
+/**
+ * List objects (and collapsed folders) in a bucket on a branch.
+ *
+ * @request GET /projects/{project_id}/branches/{branch_id}/buckets/{bucket_name}/objects
+ */
+export const listProjectBranchBucketObjects = (apiClient, { projectId, branchId, bucketName, ...query }) => apiClient.request({
+    path: `${bucketPath(projectId, branchId, bucketName)}/objects`,
+    method: 'GET',
+    query,
+    format: 'json',
+    secure: true,
+});
+/**
+ * Download an object's raw bytes from a bucket on a branch.
+ *
+ * The server returns the body as `application/octet-stream` with a
+ * `Content-Disposition: attachment` header; the helper requests the body as a
+ * stream (`responseType: 'stream'`), so `.data` is a Node `Readable` the caller
+ * can pipe straight to disk without buffering the whole object in memory. The
+ * response headers are returned alongside so the caller can derive a filename
+ * from `Content-Disposition`.
+ *
+ * The object key may contain `/`; it is percent-encoded into a single path
+ * segment so nested keys are routed to the `{object_key}` parameter.
+ *
+ * @request GET /projects/{project_id}/branches/{branch_id}/buckets/{bucket_name}/objects/{object_key}/download
+ */
+export const getProjectBranchBucketObject = (apiClient, { projectId, branchId, bucketName, objectKey, }) => apiClient.request({
+    path: `${bucketPath(projectId, branchId, bucketName)}/objects/${encodeURIComponent(objectKey)}/download`,
+    method: 'GET',
+    format: 'stream',
+    secure: true,
+});
+/**
+ * Delete an object from a bucket on a branch.
+ *
+ * The object key may contain `/`; it is percent-encoded into a single path
+ * segment so nested keys are routed to the `{object_key}` parameter.
+ *
+ * @request DELETE /projects/{project_id}/branches/{branch_id}/buckets/{bucket_name}/objects/{object_key}
+ */
+export const deleteProjectBranchBucketObject = (apiClient, { projectId, branchId, bucketName, objectKey, }) => apiClient.request({
+    path: `${bucketPath(projectId, branchId, bucketName)}/objects/${encodeURIComponent(objectKey)}`,
+    method: 'DELETE',
+    secure: true,
+});
+/**
+ * Delete every object under a key prefix (folder) in a bucket on a branch.
+ *
+ * `prefix` must be non-empty and end with `/`; every object on this branch
+ * whose key starts with the prefix is soft-deleted in a single call.
+ *
+ * @request DELETE /projects/{project_id}/branches/{branch_id}/buckets/{bucket_name}/objects-by-prefix
+ */
+export const deleteProjectBranchBucketObjectsByPrefix = (apiClient, { projectId, branchId, bucketName, prefix, }) => apiClient.request({
+    path: `${bucketPath(projectId, branchId, bucketName)}/objects-by-prefix`,
+    method: 'DELETE',
+    query: { prefix },
+    format: 'json',
+    secure: true,
+});

package/utils/branch_picker.js

@@ -0,0 +1,103 @@
+import { EndpointType } from '@neondatabase/api-client';
+import prompts from 'prompts';
+import { retryOnLock } from '../api.js';
+import { log } from '../log.js';
+import { isCi } from '../env.js';
+/** Sentinel `value` for the "create a new branch" choice (no branch id can collide). */
+const CREATE_BRANCH_CHOICE = Symbol('create-branch');
+/**
+ * Render a branch's display name with the same word labels as `neonctl branch list`
+ * (`[default]`, `[protected]`) instead of symbols, so the picker reads clearly.
+ */
+const branchLabel = (branch) => {
+    const labels = [];
+    if (branch.default) {
+        labels.push('[default]');
+    }
+    if (branch.protected) {
+        labels.push('[protected]');
+    }
+    labels.push(branch.name);
+    return labels.join(' ');
+};
+/**
+ * Prompt the user to pick a branch from `branches`, with a "＋ Create a new branch…" option
+ * pinned to the top (mirroring the project/org pickers). The default selection is the
+ * project's default branch (the create option sits at index 0, so the default index is
+ * offset by one).
+ *
+ * Throws `opts.nonInteractiveMessage` when there is no TTY (or in CI): the caller knows the
+ * right guidance for its command, so the message is supplied rather than hard-coded here.
+ */
+export const pickBranchInteractively = async (branches, opts) => {
+    if (isCi() || !process.stdout.isTTY) {
+        throw new Error(opts.nonInteractiveMessage);
+    }
+    const defaultBranchIndex = branches.findIndex((b) => b.default);
+    const initial = defaultBranchIndex >= 0 ? defaultBranchIndex + 1 : 0;
+    const { choice } = await prompts({
+        type: 'select',
+        name: 'choice',
+        message: opts.message,
+        choices: [
+            { title: '＋ Create a new branch…', value: CREATE_BRANCH_CHOICE },
+            ...branches.map((b) => ({
+                title: `${branchLabel(b)} (${b.id})`,
+                value: b.id,
+            })),
+        ],
+        initial,
+    });
+    if (choice === undefined) {
+        throw new Error('Aborted: no branch selected.');
+    }
+    if (choice === CREATE_BRANCH_CHOICE) {
+        return { kind: 'create', name: await promptNewBranchName(branches) };
+    }
+    return { kind: 'existing', branchId: choice };
+};
+/**
+ * Prompt for a new branch name, rejecting empty input and names already taken on the
+ * project (so we never silently select a different, pre-existing branch).
+ */
+export const promptNewBranchName = async (branches) => {
+    const existing = new Set(branches.map((b) => b.name));
+    const { name } = await prompts({
+        type: 'text',
+        name: 'name',
+        message: 'New branch name:',
+        validate: (value) => {
+            const trimmed = value.trim();
+            if (trimmed === '')
+                return 'Branch name cannot be empty.';
+            if (existing.has(trimmed))
+                return `A branch named "${trimmed}" already exists.`;
+            return true;
+        },
+    });
+    const trimmed = typeof name === 'string' ? name.trim() : '';
+    if (trimmed === '') {
+        throw new Error('Aborted: no branch name provided.');
+    }
+    return trimmed;
+};
+/**
+ * Create a branch with the same defaults as `neonctl branch create --name <name>`:
+ * branched from the project's default branch with a read-write compute endpoint. Returns
+ * the new branch id.
+ */
+export const createBranch = async (apiClient, projectId, name, branches) => {
+    const defaultBranch = branches.find((b) => b.default);
+    if (!defaultBranch) {
+        throw new Error('No default branch found');
+    }
+    const { data } = await retryOnLock(() => apiClient.createProjectBranch(projectId, {
+        branch: { name, parent_id: defaultBranch.id },
+        endpoints: [{ type: EndpointType.ReadWrite }],
+    }));
+    if (defaultBranch.protected) {
+        log.warning('The parent branch is protected; a unique role password has been generated for the new branch.');
+    }
+    log.info('Created branch %s (%s).', data.branch.name, data.branch.id);
+    return data.branch.id;
+};

package/utils/esbuild.js

@@ -48,7 +48,10 @@ const bundleViaModule = async (source, loadEsbuild) => {
         .build({
         entryPoints: [source],
         bundle: true,
-        outfile: 'out.js',
+        // Emit `index.mjs` (not `out.js`): the Functions runtime imports the archive's entry
+        // by the conventional `index.{js,mjs}` name, and `.mjs` makes Node treat the ESM
+        // output as a module without needing a `package.json` type marker alongside it.
+        outfile: 'index.mjs',
         write: false,
         sourcemap: true,
         minify: true,
@@ -61,7 +64,7 @@ const bundleViaModule = async (source, loadEsbuild) => {
         throw new Error(`Failed to bundle function from ${source}. ${message(err)}`.trim());
     });
     const files = result.outputFiles ?? [];
-    // write:false with one entry always yields out.js + out.js.map; an empty set
+    // write:false with one entry always yields index.mjs + index.mjs.map; an empty set
     // means the API contract changed under us — fail loud rather than ship an
     // empty archive.
     if (files.length === 0) {
@@ -105,7 +108,7 @@ const runEsbuild = (bin, args) => new Promise((resolve, reject) => {
 const bundleViaBinary = async (source) => {
     const bin = resolveEsbuild();
     const outDir = mkdtempSync(join(tmpdir(), 'neon-fn-bundle-'));
-    const outfile = join(outDir, 'out.js');
+    const outfile = join(outDir, 'index.mjs');
     try {
         const { code, stderr } = await runEsbuild(bin, [
             source,
@@ -122,8 +125,8 @@ const bundleViaBinary = async (source) => {
             throw new Error(`Failed to bundle function from ${source}. ${stderr.trim()}`.trim());
         }
         return {
-            'out.js': new Uint8Array(readFileSync(outfile)),
-            'out.js.map': new Uint8Array(readFileSync(`${outfile}.map`)),
+            'index.mjs': new Uint8Array(readFileSync(outfile)),
+            'index.mjs.map': new Uint8Array(readFileSync(`${outfile}.map`)),
         };
     }
     finally {

package/utils/zip.js

@@ -1,4 +1,4 @@
 import { zipSync } from 'fflate';
-// Zip the esbuild output (out.js + out.js.map) into the archive the Functions
+// Zip the esbuild output (index.mjs + index.mjs.map) into the archive the Functions
 // deploy endpoint expects. Compression level 6 matches the previous bundler.
 export const zipBundle = (entries) => zipSync(entries, { level: 6 });