handoff-app 2.0.0-9 → 2.0.1

package/dist/registry/checkout/index.js

@@ -7,7 +7,8 @@
  * into the local workspace in standard authoring form. The local **declaration is synthesized
  * locally** in the configured `runtime.workspace.declarationFormat` — declarations are never read
  * from the registry (they are workspace-only). Identity is matched by stable `id`, so a checked-out
- * entity maps to the correct logical component/pattern and can be re-authored and re-published.
+ * entity maps to the correct logical component/pattern and can be re-authored and re-published. A
+ * new entity goes to the directory it was published from (`sourceDir`).
  *
  * Available only from a connected workspace (`runtime.mode: workspace` + a configured
  * `registryConnection`). Overwriting existing local files is explicit: a `--force` flag or an
@@ -69,12 +70,12 @@ const path_1 = __importDefault(require("path"));
 const previews_1 = require("../../catalog/previews");
 const define_1 = require("../../catalog/define");
 const renderers_1 = require("../../catalog/renderers");
-const catalog_include_1 = require("../../config/catalog-include");
 const runtime_1 = require("../../config/runtime");
 const logger_1 = require("../../utils/logger");
+const path_2 = require("../../utils/path");
 const client_1 = require("../client");
 const connection_1 = require("../connection");
-const path_2 = require("../path");
+const path_3 = require("../path");
 const selection_1 = require("../selection");
 /** A connected-workspace configuration or precondition failure surfaced to the CLI. */
 class CheckoutError extends Error {
@@ -86,12 +87,7 @@ class CheckoutError extends Error {
 exports.CheckoutError = CheckoutError;
 /** Default authoring format synthesized when no existing file or configured preference applies. */
 const DEFAULT_DECLARATION_FORMAT = 'ts';
-/** Default workspace subdirectory an entity is written into when none is configured. */
-const DEFAULT_ENTITY_DIR = {
-    component: 'components',
-    pattern: 'patterns',
-    page: 'pages',
-};
+const PAGES_DIR = 'pages';
 /** Source-file extensions stripped to form a module specifier for a React component import. */
 const COMPONENT_EXTENSION = /\.(tsx|jsx|ts|js|cjs|mjs)$/i;
 /**
@@ -133,78 +129,40 @@ const describeFetchFailure = (error, kind, id, registryUrl) => {
             return error.message;
     }
 };
-/**
- * Ask the user which collection directory a new entity should land in when the config is ambiguous.
- * Under `--force` (or any non-interactive run) there's no one to ask, so we fail with an actionable
- * message rather than guessing a root.
- */
-const promptForCollectionRoot = (handoff, kind, roots) => __awaiter(void 0, void 0, void 0, function* () {
-    const relative = (root) => path_1.default.relative(handoff.workingPath, root) || '.';
-    if (handoff.force) {
-        throw new CheckoutError(`Cannot determine where to checkout the ${kind}: catalog.include declares directories under different ` +
-            `parents (${roots.map(relative).join(', ')}), and none is named "${DEFAULT_ENTITY_DIR[kind]}". Declare a single ` +
-            `collection directory in handoff.config, or run checkout without --force to choose interactively.`);
-    }
-    const choice = yield p.select({
-        message: `Where should the new ${kind} be checked out?`,
-        options: roots.map((root) => ({ value: root, label: relative(root) })),
-        initialValue: roots[0],
+/** `dir` is a `catalog.include` entry, or a direct child of a collection entry. */
+const isInCatalog = (handoff, dir) => {
+    var _a, _b, _c;
+    return ((_c = (_b = (_a = handoff.config) === null || _a === void 0 ? void 0 : _a.catalog) === null || _b === void 0 ? void 0 : _b.include) !== null && _c !== void 0 ? _c : []).some((entry) => {
+        const included = path_1.default.resolve(handoff.workingPath, entry);
+        return (0, path_2.arePathsEqual)(included, dir) || (!(0, runtime_1.isComponentDirectory)(included) && (0, path_2.arePathsEqual)(included, path_1.default.dirname(dir)));
     });
-    if (p.isCancel(choice)) {
-        throw new CheckoutError('Checkout cancelled; no target directory chosen.');
-    }
-    return choice;
-});
-/**
- * Resolve the collection directory a new entity is cloned into from the configured
- * `catalog.include`. Each entry is either a collection directory (used as-is) or a
- * single declared entity directory, in which case its parent is the collection root so the new
- * entity lands as a sibling rather than nested inside. Different parents are settled by the
- * conventional directory name for the kind, and only then by asking the user. With nothing
- * configured we fall back to the default subdir.
- */
-const resolveCollectionRoot = (handoff, kind) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, _b;
-    const configuredRoots = (_b = (_a = handoff.config) === null || _a === void 0 ? void 0 : _a.catalog) === null || _b === void 0 ? void 0 : _b.include;
-    if (!(configuredRoots === null || configuredRoots === void 0 ? void 0 : configuredRoots.length)) {
-        return path_1.default.resolve(handoff.workingPath, DEFAULT_ENTITY_DIR[kind]);
-    }
-    const roots = [
-        ...new Set(configuredRoots.map((entry) => {
-            const resolved = path_1.default.resolve(handoff.workingPath, entry);
-            return (0, runtime_1.isComponentDirectory)(resolved) ? path_1.default.dirname(resolved) : resolved;
-        })),
-    ];
-    if (roots.length === 1) {
-        return roots[0];
-    }
-    // `catalog.include` is one list for both lanes, so a project that registers `components` and
-    // `patterns` offers two roots for every checkout. Without this, every such project prompts, and a
-    // non-interactive `--force` run fails.
-    const conventional = roots.filter((root) => path_1.default.basename(root) === DEFAULT_ENTITY_DIR[kind]);
-    if (conventional.length === 1) {
-        return conventional[0];
-    }
-    return promptForCollectionRoot(handoff, kind, roots);
-});
-/**
- * Resolve the local directory the entity is written into. An already-checked-out or locally-declared
- * entity keeps its existing source directory (matched by stable `id`); otherwise it lands as a
- * sibling under its configured collection root (see {@link resolveCollectionRoot}).
- */
-const resolveTargetDir = (handoff, kind, id) => __awaiter(void 0, void 0, void 0, function* () {
+};
+/** A locally declared entity keeps its directory. A new one goes to the directory it was published from. */
+const resolveTargetDir = (handoff, kind, id, sourceDir) => __awaiter(void 0, void 0, void 0, function* () {
     const store = kind === 'component' ? handoff.store.components : handoff.store.patterns;
     const existing = yield store.get(id);
     const existingDir = existing === null || existing === void 0 ? void 0 : existing.path;
     if (existingDir) {
-        return existingDir;
+        return { dir: existingDir, isInCatalog: true };
     }
-    const root = yield resolveCollectionRoot(handoff, kind);
-    const targetDir = (0, path_2.resolvePathWithin)(root, id);
-    if (!targetDir) {
-        throw new CheckoutError(`Cannot checkout ${kind} with unsafe id "${id}".`);
+    if (!(0, path_3.isWorkspaceRelativePath)(sourceDir)) {
+        throw new CheckoutError(`The registry has no valid source directory for ${kind} "${id}". Republish it, then checkout again.`);
     }
-    return targetDir;
+    const dir = path_1.default.resolve(handoff.workingPath, sourceDir);
+    return { dir, isInCatalog: isInCatalog(handoff, dir) };
+});
+/** `--force` fails here: it skips overwrite prompts, not approval of a location the registry chose. */
+const confirmLocation = (handoff, kind, id, dir) => __awaiter(void 0, void 0, void 0, function* () {
+    const relative = path_1.default.relative(handoff.workingPath, dir) || '.';
+    if (handoff.force) {
+        throw new CheckoutError(`The registry places ${kind} "${id}" at ${relative}, which is outside catalog.include. ` +
+            `Add "${relative}" or its parent directory to catalog.include, or run checkout without --force to accept the location.`);
+    }
+    const proceed = yield p.confirm({
+        message: `The registry places ${kind} "${id}" at ${relative}, which is outside catalog.include. Write it there?`,
+        initialValue: false,
+    });
+    return !p.isCancel(proceed) && proceed === true;
 });
 /** Read the extension of an existing local declaration in `dir`, if any maps to a known format. */
 const existingDeclarationFormat = (dir) => {
@@ -685,7 +643,7 @@ const confirmOverwrite = (handoff, conflicts) => __awaiter(void 0, void 0, void
 });
 /** Write a registry source file at its relative path under the target directory. */
 const writeSourceFile = (targetDir, file) => __awaiter(void 0, void 0, void 0, function* () {
-    const absolutePath = (0, path_2.resolvePathWithin)(targetDir, file.path);
+    const absolutePath = (0, path_3.resolvePathWithin)(targetDir, file.path);
     if (!absolutePath) {
         throw new CheckoutError(`Registry returned an unsafe source file path "${file.path}".`);
     }
@@ -714,9 +672,9 @@ exports.reportPlannedWrites = reportPlannedWrites;
  * markdown file is itself the authored source — so the page round-trips byte-for-byte.
  */
 const checkoutPage = (handoff, id, payload) => __awaiter(void 0, void 0, void 0, function* () {
-    const pagesRoot = path_1.default.resolve(handoff.workingPath, DEFAULT_ENTITY_DIR.page);
+    const pagesRoot = path_1.default.resolve(handoff.workingPath, PAGES_DIR);
     const targets = payload.files.map((file) => {
-        const target = (0, path_2.resolvePathWithin)(pagesRoot, file.path);
+        const target = (0, path_3.resolvePathWithin)(pagesRoot, file.path);
         if (!target) {
             throw new CheckoutError(`Registry returned an unsafe page source path "${file.path}".`);
         }
@@ -744,7 +702,7 @@ const checkoutPage = (handoff, id, payload) => __awaiter(void 0, void 0, void 0,
  * failure.
  */
 const checkoutSingle = (handoff, kind, id, client, registryUrl) => __awaiter(void 0, void 0, void 0, function* () {
-    const validId = kind === 'page' ? (0, path_2.isSafeRelativePath)(id) : (0, path_2.isSafePathSegment)(id);
+    const validId = kind === 'page' ? (0, path_3.isSafeRelativePath)(id) : (0, path_3.isSafePathSegment)(id);
     if (!validId) {
         throw new CheckoutError(`Cannot checkout ${kind} with unsafe id "${id}".`);
     }
@@ -759,19 +717,20 @@ const checkoutSingle = (handoff, kind, id, client, registryUrl) => __awaiter(voi
         }
         throw error;
     }
-    // Pages round-trip as a single verbatim `.md` with no declaration synthesis, and aren't
-    // listed in `catalog.include`, so there's nothing to register.
     if (kind === 'page') {
         yield checkoutPage(handoff, id, payload);
-        return null;
+        return;
     }
-    const targetDir = yield resolveTargetDir(handoff, kind, id);
+    const target = yield resolveTargetDir(handoff, kind, id, payload.sourceDir);
+    const targetDir = target.dir;
+    const relativeDir = path_1.default.relative(handoff.workingPath, targetDir) || '.';
+    const outsideCatalogWarning = `Add "${relativeDir}" to catalog.include, or the build will not load ${kind} "${id}".`;
     const format = resolveDeclarationFormat(handoff, targetDir);
     const declarationFileName = resolveDeclarationFileName(targetDir, id, format);
     const declarationPath = path_1.default.join(targetDir, declarationFileName);
     // Compute everything that would be written, then gate overwrite of any pre-existing file.
     const sourceTargets = payload.files.map((file) => {
-        const absolutePath = (0, path_2.resolvePathWithin)(targetDir, file.path);
+        const absolutePath = (0, path_3.resolvePathWithin)(targetDir, file.path);
         if (!absolutePath) {
             throw new CheckoutError(`Registry returned an unsafe source file path "${file.path}".`);
         }
@@ -781,13 +740,19 @@ const checkoutSingle = (handoff, kind, id, client, registryUrl) => __awaiter(voi
     const plannedWrites = [...sourceTargets.map((entry) => entry.absolutePath), declarationPath];
     const conflicts = plannedWrites.filter((file) => fs_extra_1.default.existsSync(file));
     if (handoff.dryRun) {
-        // Returning null also skips `registerCheckedOut`, so a dry run never edits handoff.config either.
         (0, exports.reportPlannedWrites)(handoff, `${kind} "${id}"`, plannedWrites, conflicts);
-        return null;
+        if (!target.isInCatalog) {
+            logger_1.Logger.warn(`${relativeDir} is outside catalog.include. ${outsideCatalogWarning}`);
+        }
+        return;
+    }
+    if (!target.isInCatalog && !(yield confirmLocation(handoff, kind, id, targetDir))) {
+        logger_1.Logger.warn(`Checkout of ${kind} "${id}" cancelled; no files were written.`);
+        return;
     }
     if (!(yield confirmOverwrite(handoff, conflicts))) {
         logger_1.Logger.warn(`Checkout of ${kind} "${id}" cancelled; no files were written.`);
-        return null;
+        return;
     }
     yield fs_extra_1.default.ensureDir(targetDir);
     const written = [];
@@ -796,36 +761,10 @@ const checkoutSingle = (handoff, kind, id, client, registryUrl) => __awaiter(voi
     }
     yield fs_extra_1.default.writeFile(declarationPath, declaration, 'utf8');
     written.push(declarationPath);
-    logger_1.Logger.success(`Checked out ${kind} "${id}" into ${path_1.default.relative(handoff.workingPath, targetDir) || '.'} ` +
-        `(${payload.files.length} source file(s) + ${declarationFileName}).`);
-    return targetDir;
-});
-/**
- * Declare freshly checked-out entities in `catalog.include` so the workspace build
- * picks them up. Ones already covered by a collection directory load on their own and are left
- * alone; the rest are added to the config automatically. If the config can't be edited (a computed
- * or unusual `include` array), we print the paths for the user to add so nothing is silently orphaned.
- */
-const registerCheckedOut = (handoff, kind, targetDirs) => __awaiter(void 0, void 0, void 0, function* () {
-    if (kind === 'page') {
-        return;
+    logger_1.Logger.success(`Checked out ${kind} "${id}" into ${relativeDir} (${payload.files.length} source file(s) + ${declarationFileName}).`);
+    if (!target.isInCatalog) {
+        logger_1.Logger.warn(outsideCatalogWarning);
     }
-    const kindLabel = kind === 'component' ? 'components' : 'patterns';
-    const unlisted = targetDirs.filter((dir) => !(0, catalog_include_1.isIncluded)(handoff, dir));
-    if (unlisted.length === 0) {
-        return;
-    }
-    const result = yield (0, catalog_include_1.addToCatalog)(handoff, unlisted);
-    if (result.status === 'added') {
-        const where = result.configPath
-            ? path_1.default.relative(handoff.workingPath, result.configPath) || path_1.default.basename(result.configPath)
-            : 'handoff.config';
-        logger_1.Logger.success(`Updated ${where} with ${result.added.length} ${kindLabel} path(s).`);
-        return;
-    }
-    const where = result.configPath ? path_1.default.relative(handoff.workingPath, result.configPath) : 'handoff.config';
-    logger_1.Logger.warn(`Could not update ${where} automatically. Add these to catalog.include manually:`);
-    result.pending.forEach((rel) => logger_1.Logger.warn(`  - ${rel}`));
 });
 /**
  * Checkout a single component, pattern, or page from the connected registry into this workspace.
@@ -834,10 +773,7 @@ const registerCheckedOut = (handoff, kind, targetDirs) => __awaiter(void 0, void
 const checkoutEntity = (handoff, kind, id) => __awaiter(void 0, void 0, void 0, function* () {
     const connection = yield (0, exports.resolveConnectionOrThrow)(handoff);
     const client = (0, client_1.createRegistryClient)({ baseUrl: connection.url, accessToken: connection.accessToken });
-    const targetDir = yield checkoutSingle(handoff, kind, id, client, connection.url);
-    if (targetDir) {
-        yield registerCheckedOut(handoff, kind, [targetDir]);
-    }
+    yield checkoutSingle(handoff, kind, id, client, connection.url);
 });
 exports.checkoutEntity = checkoutEntity;
 /** List the ids the registry publishes for one kind, naming the registry in a listing failure. */
@@ -854,7 +790,7 @@ const listPublishedIds = (kind, client, registryUrl) => __awaiter(void 0, void 0
     }
 });
 /**
- * Check out the given ids of one kind and register what landed. The caller selects the ids, because a
+ * Check out the given ids of one kind. The caller selects the ids, because a
  * catalog run resolves them across both entity lanes before any of them is written.
  *
  * A per-entity failure is collected and never aborts the rest. Failures are reported here, and the
@@ -863,21 +799,15 @@ const listPublishedIds = (kind, client, registryUrl) => __awaiter(void 0, void 0
 const checkoutSelected = (handoff, kind, targets, client, registryUrl) => __awaiter(void 0, void 0, void 0, function* () {
     let checkedOut = 0;
     const failed = [];
-    const targetDirs = [];
     for (const id of targets) {
         try {
-            const targetDir = yield checkoutSingle(handoff, kind, id, client, registryUrl);
-            if (targetDir) {
-                targetDirs.push(targetDir);
-            }
+            yield checkoutSingle(handoff, kind, id, client, registryUrl);
             checkedOut += 1;
         }
         catch (error) {
             failed.push({ id, message: error instanceof Error ? error.message : String(error) });
         }
     }
-    // Register everything checked out in one pass, so the config is edited (and confirmed) once.
-    yield registerCheckedOut(handoff, kind, targetDirs);
     logger_1.Logger.success(`${kind[0].toUpperCase()}${kind.slice(1)}s checkout complete — ${checkedOut} ${handoff.dryRun ? 'would be checked out' : 'checked out'}` +
         `${failed.length ? `, ${failed.length} failed` : ''}.`);
     for (const failure of failed) {

package/dist/registry/client.js

@@ -100,6 +100,27 @@ const createRegistryClient = ({ baseUrl, accessToken }) => {
         }
         return envelope;
     });
+    const uploadAssetBlobThroughRegistry = (blobPath, contentType, bytes) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a, _b;
+        const url = `${root}${blobPath}`;
+        // Send a Blob, not a Buffer/Uint8Array: under Next `trailingSlash: true` this PUT is
+        // 308-redirected and undici must re-send the body; a typed-array body's ArrayBuffer is detached
+        // after the first send ("slice on a detached ArrayBuffer"), but a Blob is re-readable.
+        const body = new Blob([new Uint8Array(bytes)]);
+        const response = yield fetchRegistry(url, {
+            method: 'PUT',
+            headers: Object.assign({ 'Content-Type': contentType || 'application/octet-stream' }, (accessToken ? { Authorization: `Bearer ${accessToken}` } : {})),
+            body,
+        });
+        if (!response.ok) {
+            let code;
+            let message = `Blob upload failed (${response.status} ${response.statusText}).`;
+            const envelope = yield readErrorEnvelope(response);
+            code = (_a = envelope === null || envelope === void 0 ? void 0 : envelope.error) === null || _a === void 0 ? void 0 : _a.code;
+            message = ((_b = envelope === null || envelope === void 0 ? void 0 : envelope.error) === null || _b === void 0 ? void 0 : _b.message) || message;
+            throw new RegistryClientError(message, { status: response.status, code });
+        }
+    });
     return {
         /** Publish (`PUT`) an entity's package to the registry transfer endpoint. */
         publish(kind, id, pkg) {
@@ -161,28 +182,43 @@ const createRegistryClient = ({ baseUrl, accessToken }) => {
                 return (_b = (_a = envelope.data) === null || _a === void 0 ? void 0 : _a.missing) !== null && _b !== void 0 ? _b : [];
             });
         },
-        /** Upload one content-addressed blob (binary-safe body). Idempotent: re-uploading an existing hash no-ops. */
+        /**
+         * Upload one content-addressed blob. Sends it directly to storage when the registry returns a
+         * signed URL, otherwise through the registry. Idempotent: re-uploading an existing hash no-ops.
+         */
         uploadAssetBlob(hash, contentType, bytes) {
             return __awaiter(this, void 0, void 0, function* () {
                 var _a, _b;
-                const url = `${root}/api/registry/transfer/assets/blobs/${encodeURIComponent(hash)}`;
-                // Send a Blob, not a Buffer/Uint8Array: under Next `trailingSlash: true` this PUT is
-                // 308-redirected and undici must re-send the body; a typed-array body's ArrayBuffer is detached
-                // after the first send ("slice on a detached ArrayBuffer"), but a Blob is re-readable.
-                const body = new Blob([new Uint8Array(bytes)]);
-                const response = yield fetchRegistry(url, {
-                    method: 'PUT',
-                    headers: Object.assign({ 'Content-Type': contentType || 'application/octet-stream' }, (accessToken ? { Authorization: `Bearer ${accessToken}` } : {})),
-                    body,
-                });
+                const blobPath = `/api/registry/transfer/assets/blobs/${encodeURIComponent(hash)}`;
+                const size = bytes.length;
+                const envelope = yield request('POST', `${blobPath}/upload`, { size, contentType });
+                if ((_a = envelope.data) === null || _a === void 0 ? void 0 : _a.stored) {
+                    return;
+                }
+                const upload = (_b = envelope.data) === null || _b === void 0 ? void 0 : _b.upload;
+                if (!upload) {
+                    yield uploadAssetBlobThroughRegistry(blobPath, contentType, bytes);
+                    return;
+                }
+                // Name only the origin in errors: the signed query string must not reach logs.
+                const storage = new URL(upload.url).origin;
+                let response;
+                try {
+                    response = yield fetch(upload.url, {
+                        method: 'PUT',
+                        headers: upload.headers,
+                        body: new Blob([new Uint8Array(bytes)]),
+                    });
+                }
+                catch (error) {
+                    const cause = error === null || error === void 0 ? void 0 : error.cause;
+                    throw new RegistryClientError(`Could not reach asset storage at ${storage}: ${(cause === null || cause === void 0 ? void 0 : cause.code) || (cause === null || cause === void 0 ? void 0 : cause.message) || 'network error'}.`);
+                }
                 if (!response.ok) {
-                    let code;
-                    let message = `Blob upload failed (${response.status} ${response.statusText}).`;
-                    const envelope = yield readErrorEnvelope(response);
-                    code = (_a = envelope === null || envelope === void 0 ? void 0 : envelope.error) === null || _a === void 0 ? void 0 : _a.code;
-                    message = ((_b = envelope === null || envelope === void 0 ? void 0 : envelope.error) === null || _b === void 0 ? void 0 : _b.message) || message;
-                    throw new RegistryClientError(message, { status: response.status, code });
+                    const detail = (yield response.text().catch(() => '')).slice(0, 300);
+                    throw new RegistryClientError(`Asset storage at ${storage} rejected the upload of blob "${hash}" (${response.status} ${response.statusText})${detail ? `: ${detail}` : ''}.`, { status: response.status });
                 }
+                yield request('POST', `${blobPath}/complete`, { storageRef: upload.storageRef, size, contentType });
             });
         },
         /** Download one blob's raw bytes by hash (follows any provider redirect). */

package/dist/registry/db/driver.js

@@ -20,8 +20,8 @@ exports.DEFAULT_REGISTRY_API_TOKEN_ENV = 'HANDOFF_REGISTRY_API_TOKEN';
 exports.DEFAULT_REGISTRY_DRIVER = 'pg';
 /** Resolve the env-var name holding the database URL (defaults to `DATABASE_URL`). */
 const resolveDatabaseUrlEnv = (config) => {
-    var _a, _b, _c, _d;
-    const configured = (_d = (_c = (_b = (_a = config === null || config === void 0 ? void 0 : config.runtime) === null || _a === void 0 ? void 0 : _a.registry) === null || _b === void 0 ? void 0 : _b.databaseUrl) === null || _c === void 0 ? void 0 : _c.$env) === null || _d === void 0 ? void 0 : _d.trim();
+    var _a, _b, _c, _d, _e;
+    const configured = (_e = (_d = (_c = (_b = (_a = config === null || config === void 0 ? void 0 : config.runtime) === null || _a === void 0 ? void 0 : _a.registry) === null || _b === void 0 ? void 0 : _b.database) === null || _c === void 0 ? void 0 : _c.url) === null || _d === void 0 ? void 0 : _d.$env) === null || _e === void 0 ? void 0 : _e.trim();
     return configured || exports.DEFAULT_DATABASE_URL_ENV;
 };
 exports.resolveDatabaseUrlEnv = resolveDatabaseUrlEnv;
@@ -43,7 +43,7 @@ const resolveRegistryDatabase = (config) => {
     const connectionString = (_a = process.env[databaseUrlEnv]) === null || _a === void 0 ? void 0 : _a.trim();
     if (!connectionString) {
         throw new Error(`Registry database URL is not configured. Set the "${databaseUrlEnv}" environment variable to a ` +
-            `PostgreSQL connection string (or change "runtime.registry.databaseUrl" to point at the env var you use).`);
+            `PostgreSQL connection string (or change "runtime.registry.database.url" to point at the env var you use).`);
     }
     return { driver, databaseUrlEnv, connectionString };
 };