neonctl 2.37.1 → 2.38.1

package/dist/utils/config_diff.js

@@ -1,185 +0,0 @@
-import chalk from "chalk";
-const UNSET = "(unset)";
-/**
- * Shared palette for the config diff, matching `neon diff`'s `git diff` styling
- * (bold headers, red "before", green "after", dim connective glyphs). When
- * `color` is false every entry is the identity function, so the identical layout
- * renders without ANSI codes for `--no-color`, non-TTY pipes, and test snapshots.
- */
-const palette = (color) => {
-    const id = (s) => s;
-    if (!color) {
-        return { title: id, group: id, added: id, removed: id, arrow: id };
-    }
-    return {
-        title: (s) => chalk.bold(s),
-        group: (s) => chalk.bold(s),
-        added: (s) => chalk.green(s),
-        removed: (s) => chalk.red(s),
-        arrow: (s) => chalk.dim(s),
-    };
-};
-const isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-const stringifyValue = (value) => {
-    if (value === undefined || value === null || value === "")
-        return UNSET;
-    if (typeof value === "string")
-        return value;
-    if (typeof value === "boolean" || typeof value === "number") {
-        return String(value);
-    }
-    return JSON.stringify(value);
-};
-/**
- * Expand one policy field into flat {@link FieldChange}s. When either side is a
- * plain object (compute settings, Data API settings) it splits into one
- * `field.key` entry per key across both sides, so the diff reads as sorted
- * scalar lines (`computeSettings.autoscalingLimitMaxCu  2 → 4`) rather than an
- * opaque JSON blob. Scalars produce a single entry.
- */
-const expandField = (field, current, desired) => {
-    if (isPlainObject(current) || isPlainObject(desired)) {
-        const cur = isPlainObject(current) ? current : {};
-        const des = isPlainObject(desired) ? desired : {};
-        const keys = Array.from(new Set([...Object.keys(cur), ...Object.keys(des)])).sort();
-        return keys.map((key) => ({
-            field: `${field}.${key}`,
-            ...(key in cur ? { current: stringifyValue(cur[key]) } : {}),
-            desired: stringifyValue(des[key]),
-        }));
-    }
-    return [
-        {
-            field,
-            ...(current !== undefined
-                ? { current: stringifyValue(current) }
-                : {}),
-            desired: stringifyValue(desired),
-        },
-    ];
-};
-/** Render the indented `field  current → desired` lines for one branch group. */
-const renderFieldLines = (fields, paint) => {
-    const width = fields.reduce((max, f) => Math.max(max, f.field.length), 0);
-    return fields.map((f) => {
-        const name = f.field.padEnd(width);
-        const arrow = paint.arrow("→");
-        return f.current !== undefined
-            ? `      ${name}  ${paint.removed(f.current)} ${arrow} ${paint.added(f.desired)}`
-            : `      ${name}  ${arrow} ${paint.added(f.desired)}`;
-    });
-};
-/** Group field changes by branch, each block sorted alphabetically by field. */
-const renderBranchGroups = (byBranch, paint) => {
-    const lines = [];
-    const groups = [...byBranch.entries()].sort((a, b) => a[0].localeCompare(b[0]));
-    for (const [branch, fields] of groups) {
-        const sorted = [...fields].sort((a, b) => a.field.localeCompare(b.field));
-        lines.push(`  ${paint.group(`~ ${branch}`)}`);
-        lines.push(...renderFieldLines(sorted, paint));
-    }
-    return lines;
-};
-/** Friendly label for a service change identifier (`bucket:x` → `bucket x`). */
-const serviceLabel = (identifier) => {
-    if (identifier === "auth")
-        return "Neon Auth";
-    if (identifier === "dataApi")
-        return "Data API";
-    if (identifier.startsWith("bucket:")) {
-        return `bucket ${identifier.slice("bucket:".length)}`;
-    }
-    if (identifier.startsWith("function:")) {
-        return `function ${identifier.slice("function:".length)}`;
-    }
-    return identifier;
-};
-/**
- * The desired-only field changes for an applied/planned **branch** update. The
- * synthesized `AppliedChange.details` carry the new value keyed by `field`
- * (`parent`→`parent`, `ttl`→`expiresAt`, `protected`→`protected`,
- * `computeSettings`→`settings`); the previous value isn't threaded through in
- * Phase 1, so these render as `field → desired` (no red "before"). Object
- * settings expand into sub-fields.
- *
- * `parent` only ever arrives from a branch creation (it cannot be changed
- * afterwards), where it reports the parent the policy named.
- */
-const appliedBranchFields = (change) => {
-    const details = change.details ?? {};
-    const field = typeof details.field === "string" ? details.field : "setting";
-    switch (field) {
-        case "parent":
-            return expandField("parent", undefined, details.parent);
-        case "ttl":
-            return expandField("ttl", undefined, details.expiresAt);
-        case "protected":
-            return expandField("protected", undefined, details.protected);
-        case "computeSettings":
-            return expandField("computeSettings", undefined, details.settings);
-        default:
-            return expandField(field, undefined, details.settings);
-    }
-};
-/**
- * Render the applied (or planned) changes as a `git diff`-style list:
- *
- * - **Service changes** (auth / Data API / buckets / functions) are additions
- *   with no meaningful "before", so they list as green `+ <label>` lines
- *   (`~ <label>` for the lone Data API settings *update*).
- * - **Branch setting changes** group per branch and render as sorted
- *   `field → value` lines under a `~ <branch>` header.
- *
- * Returns "" when there is nothing to show. Pure — callers own the heading
- * spacing and any surrounding summary.
- */
-export const renderAppliedChanges = (changes, title, opts) => {
-    if (changes.length === 0)
-        return "";
-    const paint = palette(opts.color);
-    const lines = [paint.title(title)];
-    const services = changes
-        .filter((c) => c.kind === "service")
-        .sort((a, b) => a.identifier.localeCompare(b.identifier));
-    for (const service of services) {
-        const label = serviceLabel(service.identifier);
-        lines.push(service.action === "create"
-            ? `  ${paint.added(`+ ${label}`)}`
-            : `  ${paint.arrow(`~ ${label}`)}`);
-    }
-    const byBranch = new Map();
-    for (const change of changes.filter((c) => c.kind === "branch")) {
-        const existing = byBranch.get(change.identifier) ?? [];
-        byBranch.set(change.identifier, [
-            ...existing,
-            ...appliedBranchFields(change),
-        ]);
-    }
-    lines.push(...renderBranchGroups(byBranch, paint));
-    return lines.join("\n");
-};
-/**
- * Render branch-setting **conflicts** (drift the policy wants to change but that
- * needs `--update-existing`) as a `git diff`-style before→after report: grouped
- * per branch, sorted by field, `current → desired` with the old value in red and
- * the new in green. Conflicts already carry both sides, so this is the fullest
- * form of the diff. Returns "" when there are no conflicts.
- */
-export const renderBranchSettingConflicts = (conflicts, opts) => {
-    if (conflicts.length === 0)
-        return "";
-    const paint = palette(opts.color);
-    const byBranch = new Map();
-    for (const conflict of conflicts) {
-        const existing = byBranch.get(conflict.identifier) ?? [];
-        byBranch.set(conflict.identifier, [
-            ...existing,
-            ...expandField(conflict.field, conflict.current, conflict.desired),
-        ]);
-    }
-    const lines = [
-        paint.title("Branch settings differ (re-run with --update-existing to apply)"),
-        ...renderBranchGroups(byBranch, paint),
-    ];
-    return lines.join("\n");
-};

package/dist/utils/enrichers.js

@@ -1,161 +0,0 @@
-import { isNeonApiError, messageFromBody } from "../api.js";
-import { isConfigInit, isCurrentBranchProbe } from "../context.js";
-import { looksLikeBranchId } from "./formats.js";
-export const branchIdResolve = async ({ branch, apiClient, projectId, }) => {
-    branch = branch.toString();
-    if (looksLikeBranchId(branch)) {
-        return branch;
-    }
-    const { data } = await apiClient.listProjectBranches({
-        projectId,
-    });
-    const branchData = data.branches.find((b) => b.name === branch);
-    if (!branchData) {
-        throw new Error(`Branch ${branch} not found.\nAvailable branches: ${data.branches
-            .map((b) => b.name)
-            .join(", ")}`);
-    }
-    return branchData.id;
-};
-const getBranchIdFromProps = async (props) => {
-    const branch = "branch" in props && typeof props.branch === "string"
-        ? props.branch
-        : props.id;
-    if (branch) {
-        return await branchIdResolve({
-            branch,
-            apiClient: props.apiClient,
-            projectId: props.projectId,
-        });
-    }
-    const { data } = await props.apiClient.listProjectBranches({
-        projectId: props.projectId,
-    });
-    const defaultBranch = data.branches.find((b) => b.default);
-    if (defaultBranch) {
-        return defaultBranch.id;
-    }
-    throw new Error("No default branch found");
-};
-export const branchIdFromProps = async (props) => {
-    props.branchId = await getBranchIdFromProps(props);
-    return props.branchId;
-};
-export const resolveBranchRef = async (props) => {
-    const branch = "branch" in props && typeof props.branch === "string"
-        ? props.branch
-        : props.id;
-    const { data } = await props.apiClient.listProjectBranches({
-        projectId: props.projectId,
-    });
-    const branches = data.branches;
-    if (branch) {
-        const ref = branch.toString();
-        const found = looksLikeBranchId(ref)
-            ? branches.find((b) => b.id === ref)
-            : branches.find((b) => b.name === ref);
-        if (found) {
-            return {
-                branchId: found.id,
-                branchName: found.name ?? found.id,
-                usedDefault: false,
-            };
-        }
-        // A `br-…` id absent from the listing is still usable as an id (trust it like
-        // branchIdResolve does); only an unresolved *name* is a genuine error.
-        if (looksLikeBranchId(ref)) {
-            return { branchId: ref, branchName: ref, usedDefault: false };
-        }
-        throw new Error(`Branch ${ref} not found.\nAvailable branches: ${branches
-            .map((b) => b.name)
-            .join(", ")}`);
-    }
-    const defaultBranch = branches.find((b) => b.default);
-    if (!defaultBranch) {
-        throw new Error("No default branch found");
-    }
-    return {
-        branchId: defaultBranch.id,
-        branchName: defaultBranch.name ?? defaultBranch.id,
-        usedDefault: true,
-    };
-};
-export const resolveSingleDatabase = async (props) => {
-    const { data } = await props.apiClient.listProjectBranchDatabases(props.projectId, props.branchId);
-    const databases = data.databases;
-    if (props.database !== undefined) {
-        if (!databases.find((d) => d.name === props.database)) {
-            throw new Error(`Database not found: ${props.database}. Available databases on branch ${props.branchId}: ${databases.map((d) => d.name).join(", ")}`);
-        }
-        return props.database;
-    }
-    if (databases.length === 0) {
-        throw new Error(`No databases found for the branch: ${props.branchId}`);
-    }
-    if (databases.length === 1) {
-        return databases[0].name;
-    }
-    throw new Error(`Multiple databases found for the branch, please provide one with the --database option: ${databases.map((d) => d.name).join(", ")}`);
-};
-export const fillSingleProject = async (props) => {
-    // The offline `--current-branch` probe needs no project at all and runs with no
-    // API client (auth was skipped), so resolving a single project here would both
-    // hit the network and dereference a null client. Skip it entirely.
-    if (isCurrentBranchProbe(props)) {
-        return props;
-    }
-    // `config init` is purely local (scaffold + npm install) and runs with no API
-    // client, so resolving a single project here would dereference a null client.
-    if (isConfigInit(props)) {
-        return props;
-    }
-    if (props.projectId) {
-        return { ...props, projectId: props.projectId };
-    }
-    // If no orgId is provided, try to auto-fill it if there's only one org
-    let orgId = props.orgId;
-    if (!orgId) {
-        const { data: orgsData } = await props.apiClient.getCurrentUserOrganizations();
-        if (orgsData.organizations.length === 1) {
-            orgId = orgsData.organizations[0].id;
-        }
-    }
-    try {
-        const { data } = await props.apiClient.listProjects({
-            limit: 2,
-            org_id: orgId,
-        });
-        if (data.projects.length === 0) {
-            throw new Error("No projects found");
-        }
-        if (data.projects.length > 1) {
-            throw new Error(`Multiple projects found, please provide one with the --project-id option`);
-        }
-        return {
-            ...props,
-            projectId: data.projects[0].id,
-        };
-    }
-    catch (error) {
-        // If the API error is about missing org_id, provide a user-friendly message
-        if (isNeonApiError(error) &&
-            error.status === 400 &&
-            messageFromBody(error.data)?.includes("org_id is required")) {
-            throw new Error("Multiple projects found, please provide one with the --project-id option");
-        }
-        throw error;
-    }
-};
-export const fillSingleOrg = async (props) => {
-    if (props.orgId) {
-        return props;
-    }
-    const { data } = await props.apiClient.getCurrentUserOrganizations();
-    if (data.organizations.length === 0) {
-        throw new Error("No organizations found");
-    }
-    if (data.organizations.length > 1) {
-        throw new Error(`Multiple organizations found, please provide one with the --org-id option`);
-    }
-    return { ...props, orgId: data.organizations[0].id };
-};

package/dist/utils/esbuild.js

@@ -1,158 +0,0 @@
-import { spawn } from "node:child_process";
-import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { basename, join } from "node:path";
-import which from "which";
-const NOT_FOUND = "esbuild not found. neonctl ships esbuild for most platforms; if you see " +
-    "this, install esbuild and ensure it is on your PATH (e.g. `npm i -g " +
-    "esbuild`), or set NEON_ESBUILD_PATH to an esbuild binary.";
-// Prepended to the ESM bundle. Bundled dependencies are frequently CommonJS, but an ESM
-// output (`--format=esm`) has no `require` / `__filename` / `__dirname` in scope — so any
-// bundled CJS code that calls `require(...)` would fail at load with
-// `Dynamic require of "x" is not supported`. Re-create those globals via `createRequire`
-// so CJS and ESM dependencies coexist in the single `index.mjs`.
-const ESM_CJS_INTEROP_BANNER = "import{createRequire as ___cr}from'module';import{fileURLToPath as ___f}from'url';import{dirname as ___d}from'path';const require=___cr(import.meta.url);const __filename=___f(import.meta.url);const __dirname=___d(__filename);";
-const defaultDeps = {
-    // @yao-pkg/pkg defines process.pkg inside the packaged binary.
-    isPackaged: () => process.pkg !== undefined,
-    loadEsbuild: (name) => import(name),
-};
-// Internal signal: the esbuild JS module could not be imported (exotic platform
-// or not installed). Tells bundleEntry to fall back to the binary; never shown
-// to the user.
-class ModuleNotAvailable extends Error {
-}
-const message = (err) => err instanceof Error ? err.message : String(err);
-const toFilesByBasename = (files) => {
-    const out = {};
-    for (const f of files)
-        out[basename(f.path)] = f.contents;
-    return out;
-};
-const bundleViaModule = async (source, loadEsbuild) => {
-    // esbuild is resolved by a COMPUTED specifier, never the literal string
-    // 'esbuild'. Both rollup (bundle step) and @yao-pkg/pkg (binary step)
-    // statically scan for literal import()/require() calls and would otherwise
-    // pull esbuild and its native Go binary into the bundle/snapshot — bloating
-    // the packaged CLI and emitting "cannot bundle native binary" warnings. The
-    // packaged binary never imports esbuild at all (the isPackaged guard sends it
-    // to the binary path), so keeping this specifier invisible to the scanners is
-    // what keeps esbuild out of the snapshot.
-    // Do NOT "simplify" this back to import('esbuild').
-    const name = ["es", "build"].join("");
-    let esbuild;
-    try {
-        esbuild = await loadEsbuild(name);
-    }
-    catch {
-        throw new ModuleNotAvailable();
-    }
-    // Mirrors the binary-path bundling flags; write:false keeps output in memory.
-    // logLevel:'silent' suppresses esbuild's own stderr — the rejected error
-    // still carries the diagnostic, matching the binary path's captured-stderr.
-    const result = await esbuild
-        .build({
-        entryPoints: [source],
-        bundle: true,
-        // 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,
-        minify: true,
-        format: "esm",
-        platform: "node",
-        // Bundle dependencies into the entry so the deployed archive is self-contained (the
-        // Functions runtime has no node_modules). Node built-ins stay external on
-        // platform:'node'. The banner re-creates require/__filename/__dirname for bundled CJS.
-        banner: { js: ESM_CJS_INTEROP_BANNER },
-        logLevel: "silent",
-    })
-        .catch((err) => {
-        throw new Error(`Failed to bundle function from ${source}. ${message(err)}`.trim());
-    });
-    const files = result.outputFiles ?? [];
-    // write:false with one entry always yields index.mjs (no source map — we don't emit one);
-    // an empty set means the API contract changed under us — fail loud rather than ship an
-    // empty archive.
-    if (files.length === 0) {
-        throw new Error(`Failed to bundle function from ${source}. esbuild produced no output.`);
-    }
-    return toFilesByBasename(files);
-};
-// Find the esbuild binary at deploy time. An explicit override is authoritative
-// (so it fails loudly if wrong); otherwise prefer the host PATH, then a locally
-// installed copy.
-const resolveEsbuild = () => {
-    const override = process.env.NEON_ESBUILD_PATH;
-    if (override) {
-        if (existsSync(override))
-            return override;
-        throw new Error(NOT_FOUND);
-    }
-    const onPath = which.sync("esbuild", { nothrow: true });
-    if (onPath)
-        return onPath;
-    // CWD-relative (not install-relative): helps the dev checkout where esbuild is
-    // a devDependency. In `npm i -g` and pkg installs the PATH branch above wins.
-    const local = join(process.cwd(), "node_modules", ".bin", "esbuild");
-    if (existsSync(local))
-        return local;
-    throw new Error(NOT_FOUND);
-};
-const runEsbuild = (bin, args) => new Promise((resolve, reject) => {
-    // stderr is captured (NOT inherited): with --log-level=error a success emits
-    // nothing, and a failure's diagnostic is read out below. Never use 'inherit'.
-    const child = spawn(bin, args, { stdio: ["ignore", "ignore", "pipe"] });
-    let stderr = "";
-    child.stderr.on("data", (chunk) => {
-        stderr += chunk.toString();
-    });
-    child.on("error", reject);
-    child.on("close", (code) => {
-        resolve({ code, stderr });
-    });
-});
-const bundleViaBinary = async (source) => {
-    const bin = resolveEsbuild();
-    const outDir = mkdtempSync(join(tmpdir(), "neon-fn-bundle-"));
-    const outfile = join(outDir, "index.mjs");
-    try {
-        const { code, stderr } = await runEsbuild(bin, [
-            source,
-            "--bundle",
-            `--outfile=${outfile}`,
-            "--minify",
-            "--format=esm",
-            "--platform=node",
-            `--banner:js=${ESM_CJS_INTEROP_BANNER}`,
-            "--log-level=error",
-        ]);
-        if (code !== 0) {
-            throw new Error(`Failed to bundle function from ${source}. ${stderr.trim()}`.trim());
-        }
-        // No `--sourcemap`: the Functions runtime has no source-map support, so an uploaded
-        // `index.mjs.map` is never consumed — emitting it only inflated the archive.
-        return {
-            "index.mjs": new Uint8Array(readFileSync(outfile)),
-        };
-    }
-    finally {
-        rmSync(outDir, { recursive: true, force: true });
-    }
-};
-// Bundle `source` into the files the Functions archive expects, keyed by
-// basename. npm installs bundle in-process via the esbuild module; the packaged
-// binary (and platforms esbuild can't run on) shell out to an esbuild binary.
-export const bundleEntry = async (source, deps = defaultDeps) => {
-    if (deps.isPackaged())
-        return bundleViaBinary(source);
-    try {
-        return await bundleViaModule(source, deps.loadEsbuild);
-    }
-    catch (err) {
-        if (err instanceof ModuleNotAvailable)
-            return bundleViaBinary(source);
-        throw err;
-    }
-};

package/dist/utils/formats.js

@@ -1,18 +0,0 @@
-const HAIKU_REGEX = /^[a-z0-9]+-[a-z0-9]+-[a-z0-9]+$/;
-export const looksLikeBranchId = (branch) => branch.startsWith("br-") && HAIKU_REGEX.test(branch.substring(3));
-const LSN_REGEX = /^[a-fA-F0-9]{1,8}\/[a-fA-F0-9]{1,8}$/;
-export const looksLikeLSN = (lsn) => LSN_REGEX.test(lsn);
-export const looksLikeTimestamp = (timestamp) => {
-    if (isNaN(Date.parse(timestamp)))
-        return false;
-    /**
-     * @info
-     * Check for ISO 8601/RFC 3339 format patterns
-     * Must contain 'T' separator and end with 'Z' or timezone offset
-     *
-     * `Date.parse` aggressive parsing will attempt a date out of any string.
-     * so if a branch name has a number, `Date.parse` will return a valid timestamp.
-     */
-    const iso8601Regex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?([+-]\d{2}:\d{2}|Z)$/;
-    return iso8601Regex.test(timestamp);
-};

package/dist/utils/git_diff.js

@@ -1,90 +0,0 @@
-import chalk from "chalk";
-import { structuredPatch } from "diff";
-/**
- * Color palette for the rendered diff. When `color` is false every entry is the
- * identity function, so the exact same layout is emitted without ANSI codes
- * (for `--no-color`, non-TTY pipes, and stable test snapshots).
- */
-const palette = (color) => {
-    const id = (s) => s;
-    if (!color) {
-        return {
-            header: id,
-            removedFile: id,
-            addedFile: id,
-            hunk: id,
-            added: id,
-            removed: id,
-            noNewline: id,
-        };
-    }
-    return {
-        header: (s) => chalk.bold(s),
-        removedFile: (s) => chalk.bold.red(s),
-        addedFile: (s) => chalk.bold.green(s),
-        hunk: (s) => chalk.cyan(s),
-        added: (s) => chalk.green(s),
-        removed: (s) => chalk.red(s),
-        noNewline: (s) => chalk.dim(s),
-    };
-};
-const branchLabel = (schema) => `${schema.branchName} (${schema.branchId})`;
-/**
- * Render a single database's schema comparison as a git-style unified diff.
- *
- * Pure: given the two schemas it computes hunks with `diff`'s `structuredPatch`
- * and lays them out like `git diff` — a bold header, red `---` / green `+++`
- * branch lines, cyan `@@` hunk headers, and green/red line bodies. Returns
- * `hasChanges: false` with empty text when the two schemas are identical.
- */
-export const renderDatabaseSchemaDiff = (diff, opts) => {
-    const patch = structuredPatch(diff.database, diff.database, diff.before.sql, diff.after.sql, "", "", { context: 3 });
-    if (patch.hunks.length === 0) {
-        return { database: diff.database, hasChanges: false, text: "" };
-    }
-    const paint = palette(opts.color);
-    const lines = [
-        paint.header(`diff --neon database ${diff.database}`),
-        paint.removedFile(`--- ${branchLabel(diff.before)}`),
-        paint.addedFile(`+++ ${branchLabel(diff.after)}`),
-    ];
-    for (const hunk of patch.hunks) {
-        lines.push(paint.hunk(`@@ -${hunk.oldStart},${hunk.oldLines} +${hunk.newStart},${hunk.newLines} @@`));
-        for (const line of hunk.lines) {
-            // `structuredPatch` prefixes every line: '+' added, '-' removed,
-            // ' ' unchanged context, and '\' for the "No newline at end of file"
-            // marker. Color the first three; dim the marker; leave context plain.
-            if (line.startsWith("+")) {
-                lines.push(paint.added(line));
-            }
-            else if (line.startsWith("-")) {
-                lines.push(paint.removed(line));
-            }
-            else if (line.startsWith("\\")) {
-                lines.push(paint.noNewline(line));
-            }
-            else {
-                lines.push(line);
-            }
-        }
-    }
-    return {
-        database: diff.database,
-        hasChanges: true,
-        text: lines.join("\n"),
-    };
-};
-/**
- * Render every database's diff into one report, keeping only databases whose
- * schema actually changed. `hasChanges` is false when nothing changed across
- * all databases, letting the caller print a single "no differences" note.
- */
-export const renderSchemaDiffReport = (diffs, opts) => {
-    const rendered = diffs.map((diff) => renderDatabaseSchemaDiff(diff, opts));
-    const changed = rendered.filter((r) => r.hasChanges);
-    return {
-        hasChanges: changed.length > 0,
-        text: changed.map((r) => r.text).join("\n\n"),
-        changedDatabases: changed.map((r) => r.database),
-    };
-};