@prisma/composer-prisma-cloud 0.2.0-dev.12 → 0.2.0-dev.14

package/dist/param-BTzY0ne5-CW6ojZ3E.mjs

@@ -0,0 +1,66 @@
+import { isParamSource, paramSource } from "@prisma/composer";
+import { blindCast } from "@prisma/composer/casts";
+//#region ../../1-prisma-cloud/1-extensions/target/dist/param-BTzY0ne5.mjs
+/**
+* Brands the payload `envParam` builds. Core's `paramSource()` is a public
+* SPI, so a user could bypass `envParam` and bind a raw `paramSource('x')`;
+* the brand lets `paramName` reject such a source (or another target's) with
+* a clear error instead of reading an absent `.name`.
+*/
+const PRISMA_CLOUD_PARAM_SOURCE = blindCast(Symbol.for("prisma:prisma-cloud-param-source"));
+const RESERVED_PARAM_PREFIX = "COMPOSER_";
+const POISONED_PARAM_NAMES = /* @__PURE__ */ new Set(["DATABASE_URL", "DATABASE_URL_POOLED"]);
+/**
+* Binds a param slot to a named Prisma Cloud platform env var — the non-secret
+* sibling of `envSecret` (spec: env-sourced config params). The platform
+* injects the value into the running instance per stage; the param's own
+* schema validates it at boot, unredacted. The name may not use the
+* framework's reserved `COMPOSER_` prefix or the poisoned
+* `DATABASE_URL(_POOLED)` keys — same parity as `envSecret`.
+*/
+function envParam(name) {
+	if (typeof name !== "string" || name.length === 0) throw new Error("envParam() requires a non-empty platform env-var name, e.g. envParam('APP_ORIGIN').");
+	if (name.startsWith(RESERVED_PARAM_PREFIX)) throw new Error(`envParam name "${name}" may not start with "${RESERVED_PARAM_PREFIX}" — that prefix is reserved for the framework's own generated config keys.`);
+	if (POISONED_PARAM_NAMES.has(name)) throw new Error(`envParam name "${name}" is reserved — ${[...POISONED_PARAM_NAMES].join(" and ")} are poisoned at project provision and cannot back a param.`);
+	return paramSource({
+		[PRISMA_CLOUD_PARAM_SOURCE]: true,
+		name
+	});
+}
+/** True only for a payload that `envParam` built — i.e. one carrying the brand. */
+function isEnvParamPayload(payload) {
+	return typeof payload === "object" && payload !== null && blindCast(payload)[PRISMA_CLOUD_PARAM_SOURCE] === true;
+}
+/** True iff a resolved param value is an env-sourced pointer this target built (as opposed to a literal, or a foreign/raw `ParamSource`). */
+function isEnvParamSource(value) {
+	return isParamSource(value) && isEnvParamPayload(value.payload);
+}
+/**
+* Reads the Prisma Cloud env-var name back out of a param binding's opaque
+* source. A source not built by `envParam` (a raw `paramSource(...)` or
+* another target's source) carries no name — reject it here. `paramName` runs
+* in preflight and at serialize before any value ever crosses the wire, so a
+* foreign source fails early and clearly rather than producing a broken
+* deploy with an undefined name.
+*/
+function paramName(binding) {
+	const { binding: bound } = binding;
+	if (!isEnvParamSource(bound)) throw new Error(`param slot "${binding.slot}" of service "${binding.serviceAddress}" is bound to a source not created by envParam() — bind env-sourced params with envParam('NAME') from @prisma/composer-prisma-cloud.`);
+	return bound.payload.name;
+}
+/**
+* Finds the manifest entry for one service param slot. `serialize` calls this
+* only after confirming `buildConfig` resolved the slot to a `ParamSource`
+* (`isParamSource(value)`), so a miss here means `graph.params` and the
+* resolved `Config` have drifted — a Load invariant violation, surfaced
+* loudly rather than producing a pointer row with an undefined name.
+*/
+function paramBindingFor(bindings, serviceAddress, slot) {
+	const binding = bindings.find((b) => b.serviceAddress === serviceAddress && b.slot === slot);
+	if (binding === void 0) throw new Error(`param slot "${slot}" of "${serviceAddress}" resolved to a source but has no bound entry in the manifest — Load should have recorded it.`);
+	return binding;
+}
+//#endregion
+export { paramName as i, isEnvParamSource as n, paramBindingFor as r, envParam as t };
+
+//# sourceMappingURL=param-BTzY0ne5-CW6ojZ3E.mjs.map

package/dist/param-BTzY0ne5-CW6ojZ3E.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"param-BTzY0ne5-CW6ojZ3E.mjs","names":[],"sources":["../../../1-prisma-cloud/1-extensions/target/dist/param-BTzY0ne5.mjs"],"sourcesContent":["import { isParamSource, paramSource } from \"@internal/core\";\nimport { blindCast } from \"@internal/foundation/casts\";\n//#region src/param.ts\n/**\n* Brands the payload `envParam` builds. Core's `paramSource()` is a public\n* SPI, so a user could bypass `envParam` and bind a raw `paramSource('x')`;\n* the brand lets `paramName` reject such a source (or another target's) with\n* a clear error instead of reading an absent `.name`.\n*/\nconst PRISMA_CLOUD_PARAM_SOURCE = blindCast(Symbol.for(\"prisma:prisma-cloud-param-source\"));\nconst RESERVED_PARAM_PREFIX = \"COMPOSER_\";\nconst POISONED_PARAM_NAMES = /* @__PURE__ */ new Set([\"DATABASE_URL\", \"DATABASE_URL_POOLED\"]);\n/**\n* Binds a param slot to a named Prisma Cloud platform env var — the non-secret\n* sibling of `envSecret` (spec: env-sourced config params). The platform\n* injects the value into the running instance per stage; the param's own\n* schema validates it at boot, unredacted. The name may not use the\n* framework's reserved `COMPOSER_` prefix or the poisoned\n* `DATABASE_URL(_POOLED)` keys — same parity as `envSecret`.\n*/\nfunction envParam(name) {\n\tif (typeof name !== \"string\" || name.length === 0) throw new Error(\"envParam() requires a non-empty platform env-var name, e.g. envParam('APP_ORIGIN').\");\n\tif (name.startsWith(RESERVED_PARAM_PREFIX)) throw new Error(`envParam name \"${name}\" may not start with \"${RESERVED_PARAM_PREFIX}\" — that prefix is reserved for the framework's own generated config keys.`);\n\tif (POISONED_PARAM_NAMES.has(name)) throw new Error(`envParam name \"${name}\" is reserved — ${[...POISONED_PARAM_NAMES].join(\" and \")} are poisoned at project provision and cannot back a param.`);\n\treturn paramSource({\n\t\t[PRISMA_CLOUD_PARAM_SOURCE]: true,\n\t\tname\n\t});\n}\n/** True only for a payload that `envParam` built — i.e. one carrying the brand. */\nfunction isEnvParamPayload(payload) {\n\treturn typeof payload === \"object\" && payload !== null && blindCast(payload)[PRISMA_CLOUD_PARAM_SOURCE] === true;\n}\n/** True iff a resolved param value is an env-sourced pointer this target built (as opposed to a literal, or a foreign/raw `ParamSource`). */\nfunction isEnvParamSource(value) {\n\treturn isParamSource(value) && isEnvParamPayload(value.payload);\n}\n/**\n* Reads the Prisma Cloud env-var name back out of a param binding's opaque\n* source. A source not built by `envParam` (a raw `paramSource(...)` or\n* another target's source) carries no name — reject it here. `paramName` runs\n* in preflight and at serialize before any value ever crosses the wire, so a\n* foreign source fails early and clearly rather than producing a broken\n* deploy with an undefined name.\n*/\nfunction paramName(binding) {\n\tconst { binding: bound } = binding;\n\tif (!isEnvParamSource(bound)) throw new Error(`param slot \"${binding.slot}\" of service \"${binding.serviceAddress}\" is bound to a source not created by envParam() — bind env-sourced params with envParam('NAME') from @prisma/composer-prisma-cloud.`);\n\treturn bound.payload.name;\n}\n/**\n* Finds the manifest entry for one service param slot. `serialize` calls this\n* only after confirming `buildConfig` resolved the slot to a `ParamSource`\n* (`isParamSource(value)`), so a miss here means `graph.params` and the\n* resolved `Config` have drifted — a Load invariant violation, surfaced\n* loudly rather than producing a pointer row with an undefined name.\n*/\nfunction paramBindingFor(bindings, serviceAddress, slot) {\n\tconst binding = bindings.find((b) => b.serviceAddress === serviceAddress && b.slot === slot);\n\tif (binding === void 0) throw new Error(`param slot \"${slot}\" of \"${serviceAddress}\" resolved to a source but has no bound entry in the manifest — Load should have recorded it.`);\n\treturn binding;\n}\n//#endregion\nexport { paramName as i, isEnvParamSource as n, paramBindingFor as r, envParam as t };\n\n//# sourceMappingURL=param-BTzY0ne5.mjs.map"],"mappings":";;;;;;;;;AASA,MAAM,4BAA4B,UAAU,OAAO,IAAI,kCAAkC,CAAC;AAC1F,MAAM,wBAAwB;AAC9B,MAAM,uCAAuC,IAAI,IAAI,CAAC,gBAAgB,qBAAqB,CAAC;;;;;;;;;AAS5F,SAAS,SAAS,MAAM;CACvB,IAAI,OAAO,SAAS,YAAY,KAAK,WAAW,GAAG,MAAM,IAAI,MAAM,qFAAqF;CACxJ,IAAI,KAAK,WAAW,qBAAqB,GAAG,MAAM,IAAI,MAAM,kBAAkB,KAAK,wBAAwB,sBAAsB,2EAA2E;CAC5M,IAAI,qBAAqB,IAAI,IAAI,GAAG,MAAM,IAAI,MAAM,kBAAkB,KAAK,kBAAkB,CAAC,GAAG,oBAAoB,CAAC,CAAC,KAAK,OAAO,EAAE,4DAA4D;CACjM,OAAO,YAAY;GACjB,4BAA4B;EAC7B;CACD,CAAC;AACF;;AAEA,SAAS,kBAAkB,SAAS;CACnC,OAAO,OAAO,YAAY,YAAY,YAAY,QAAQ,UAAU,OAAO,CAAC,CAAC,+BAA+B;AAC7G;;AAEA,SAAS,iBAAiB,OAAO;CAChC,OAAO,cAAc,KAAK,KAAK,kBAAkB,MAAM,OAAO;AAC/D;;;;;;;;;AASA,SAAS,UAAU,SAAS;CAC3B,MAAM,EAAE,SAAS,UAAU;CAC3B,IAAI,CAAC,iBAAiB,KAAK,GAAG,MAAM,IAAI,MAAM,eAAe,QAAQ,KAAK,gBAAgB,QAAQ,eAAe,qIAAqI;CACtP,OAAO,MAAM,QAAQ;AACtB;;;;;;;;AAQA,SAAS,gBAAgB,UAAU,gBAAgB,MAAM;CACxD,MAAM,UAAU,SAAS,MAAM,MAAM,EAAE,mBAAmB,kBAAkB,EAAE,SAAS,IAAI;CAC3F,IAAI,YAAY,KAAK,GAAG,MAAM,IAAI,MAAM,eAAe,KAAK,QAAQ,eAAe,8FAA8F;CACjL,OAAO;AACR"}

package/dist/pg-connection-CadPZuEK-CF3FsSQu.mjs

@@ -0,0 +1,79 @@
+//#region ../../1-prisma-cloud/1-extensions/target/dist/pg-connection-CadPZuEK.mjs
+/** Connection resilience helpers for Prisma Postgres cold-starts (FT-5226); no heavy imports (no `effect`/`alchemy`/`pg`), so the deploy lowerings, the pnPostgres runtime client, and bun-runnable services (the storage store, via the pure `@internal/prisma-cloud/connection` subpath) all share one implementation. */
+/** Network-level socket failures node-postgres surfaces as `err.code`. */
+const TRANSIENT_CODES = /* @__PURE__ */ new Set([
+	"ECONNREFUSED",
+	"ECONNRESET",
+	"ETIMEDOUT",
+	"EPIPE",
+	"ENOTFOUND",
+	"EAI_AGAIN"
+]);
+/** Connection-establishment failure messages (no useful `err.code`). */
+const TRANSIENT_MESSAGE_FRAGMENTS = [
+	"upstream database",
+	"connection terminated",
+	"connection refused",
+	"terminating connection",
+	"server closed the connection",
+	"connection timeout",
+	"timeout expired"
+];
+/** Whether an error is a transient connection failure worth retrying, as opposed to a real query error that must surface at once. */
+function isTransientConnectionError(error) {
+	if (typeof error !== "object" || error === null) return false;
+	const code = "code" in error && typeof error.code === "string" ? error.code : void 0;
+	if (code !== void 0 && TRANSIENT_CODES.has(code)) return true;
+	const message = "message" in error && typeof error.message === "string" ? error.message.toLowerCase() : "";
+	return TRANSIENT_MESSAGE_FRAGMENTS.some((fragment) => message.includes(fragment));
+}
+/**
+* Rewrites a deprecating `sslmode` (`require`/`prefer`/`verify-ca`) to the
+* explicit `verify-full` these already mean, silencing node-postgres's
+* deprecation warning. `disable`/`no-verify`/unset are left untouched.
+*/
+function normalizeSslMode(url) {
+	let parsed;
+	try {
+		parsed = new URL(url);
+	} catch {
+		return url;
+	}
+	const sslmode = parsed.searchParams.get("sslmode");
+	if (sslmode === "require" || sslmode === "prefer" || sslmode === "verify-ca") {
+		parsed.searchParams.set("sslmode", "verify-full");
+		return parsed.toString();
+	}
+	return url;
+}
+/**
+* Retries an operation past a transient connection failure, bounded (default
+* ~1 min). `shouldRetry` decides what's transient — defaults to retrying
+* everything; the runtime client passes {@link isTransientConnectionError}.
+*/
+async function withConnectionRetry(operation, opts = {}) {
+	const attempts = opts.attempts ?? 12;
+	const delayMs = opts.delayMs ?? 5e3;
+	const sleep = opts.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+	const shouldRetry = opts.shouldRetry ?? (() => true);
+	let lastError;
+	for (let attempt = 1; attempt <= attempts; attempt++) try {
+		return await operation();
+	} catch (error) {
+		if (!shouldRetry(error)) throw error;
+		lastError = error;
+		if (attempt < attempts) await sleep(delayMs);
+	}
+	throw lastError;
+}
+/** Retries acquiring a connection past a transient cold-start; {@link withConnectionRetry} with {@link isTransientConnectionError} fixed as the predicate. */
+function retryTransientConnect(acquire, opts = {}) {
+	return withConnectionRetry(acquire, {
+		...opts,
+		shouldRetry: isTransientConnectionError
+	});
+}
+//#endregion
+export { retryTransientConnect as n, withConnectionRetry as r, normalizeSslMode as t };
+
+//# sourceMappingURL=pg-connection-CadPZuEK-CF3FsSQu.mjs.map

package/dist/pg-connection-CadPZuEK-CF3FsSQu.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"pg-connection-CadPZuEK-CF3FsSQu.mjs","names":[],"sources":["../../../1-prisma-cloud/1-extensions/target/dist/pg-connection-CadPZuEK.mjs"],"sourcesContent":["//#region src/pg-connection.ts\n/** Connection resilience helpers for Prisma Postgres cold-starts (FT-5226); no heavy imports (no `effect`/`alchemy`/`pg`), so the deploy lowerings, the pnPostgres runtime client, and bun-runnable services (the storage store, via the pure `@internal/prisma-cloud/connection` subpath) all share one implementation. */\n/** Network-level socket failures node-postgres surfaces as `err.code`. */\nconst TRANSIENT_CODES = /* @__PURE__ */ new Set([\n\t\"ECONNREFUSED\",\n\t\"ECONNRESET\",\n\t\"ETIMEDOUT\",\n\t\"EPIPE\",\n\t\"ENOTFOUND\",\n\t\"EAI_AGAIN\"\n]);\n/** Connection-establishment failure messages (no useful `err.code`). */\nconst TRANSIENT_MESSAGE_FRAGMENTS = [\n\t\"upstream database\",\n\t\"connection terminated\",\n\t\"connection refused\",\n\t\"terminating connection\",\n\t\"server closed the connection\",\n\t\"connection timeout\",\n\t\"timeout expired\"\n];\n/** Whether an error is a transient connection failure worth retrying, as opposed to a real query error that must surface at once. */\nfunction isTransientConnectionError(error) {\n\tif (typeof error !== \"object\" || error === null) return false;\n\tconst code = \"code\" in error && typeof error.code === \"string\" ? error.code : void 0;\n\tif (code !== void 0 && TRANSIENT_CODES.has(code)) return true;\n\tconst message = \"message\" in error && typeof error.message === \"string\" ? error.message.toLowerCase() : \"\";\n\treturn TRANSIENT_MESSAGE_FRAGMENTS.some((fragment) => message.includes(fragment));\n}\n/**\n* Rewrites a deprecating `sslmode` (`require`/`prefer`/`verify-ca`) to the\n* explicit `verify-full` these already mean, silencing node-postgres's\n* deprecation warning. `disable`/`no-verify`/unset are left untouched.\n*/\nfunction normalizeSslMode(url) {\n\tlet parsed;\n\ttry {\n\t\tparsed = new URL(url);\n\t} catch {\n\t\treturn url;\n\t}\n\tconst sslmode = parsed.searchParams.get(\"sslmode\");\n\tif (sslmode === \"require\" || sslmode === \"prefer\" || sslmode === \"verify-ca\") {\n\t\tparsed.searchParams.set(\"sslmode\", \"verify-full\");\n\t\treturn parsed.toString();\n\t}\n\treturn url;\n}\n/**\n* Retries an operation past a transient connection failure, bounded (default\n* ~1 min). `shouldRetry` decides what's transient — defaults to retrying\n* everything; the runtime client passes {@link isTransientConnectionError}.\n*/\nasync function withConnectionRetry(operation, opts = {}) {\n\tconst attempts = opts.attempts ?? 12;\n\tconst delayMs = opts.delayMs ?? 5e3;\n\tconst sleep = opts.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));\n\tconst shouldRetry = opts.shouldRetry ?? (() => true);\n\tlet lastError;\n\tfor (let attempt = 1; attempt <= attempts; attempt++) try {\n\t\treturn await operation();\n\t} catch (error) {\n\t\tif (!shouldRetry(error)) throw error;\n\t\tlastError = error;\n\t\tif (attempt < attempts) await sleep(delayMs);\n\t}\n\tthrow lastError;\n}\n/** Retries acquiring a connection past a transient cold-start; {@link withConnectionRetry} with {@link isTransientConnectionError} fixed as the predicate. */\nfunction retryTransientConnect(acquire, opts = {}) {\n\treturn withConnectionRetry(acquire, {\n\t\t...opts,\n\t\tshouldRetry: isTransientConnectionError\n\t});\n}\n//#endregion\nexport { withConnectionRetry as i, normalizeSslMode as n, retryTransientConnect as r, isTransientConnectionError as t };\n\n//# sourceMappingURL=pg-connection-CadPZuEK.mjs.map"],"mappings":";;;AAGA,MAAM,kCAAkC,IAAI,IAAI;CAC/C;CACA;CACA;CACA;CACA;CACA;AACD,CAAC;;AAED,MAAM,8BAA8B;CACnC;CACA;CACA;CACA;CACA;CACA;CACA;AACD;;AAEA,SAAS,2BAA2B,OAAO;CAC1C,IAAI,OAAO,UAAU,YAAY,UAAU,MAAM,OAAO;CACxD,MAAM,OAAO,UAAU,SAAS,OAAO,MAAM,SAAS,WAAW,MAAM,OAAO,KAAK;CACnF,IAAI,SAAS,KAAK,KAAK,gBAAgB,IAAI,IAAI,GAAG,OAAO;CACzD,MAAM,UAAU,aAAa,SAAS,OAAO,MAAM,YAAY,WAAW,MAAM,QAAQ,YAAY,IAAI;CACxG,OAAO,4BAA4B,MAAM,aAAa,QAAQ,SAAS,QAAQ,CAAC;AACjF;;;;;;AAMA,SAAS,iBAAiB,KAAK;CAC9B,IAAI;CACJ,IAAI;EACH,SAAS,IAAI,IAAI,GAAG;CACrB,QAAQ;EACP,OAAO;CACR;CACA,MAAM,UAAU,OAAO,aAAa,IAAI,SAAS;CACjD,IAAI,YAAY,aAAa,YAAY,YAAY,YAAY,aAAa;EAC7E,OAAO,aAAa,IAAI,WAAW,aAAa;EAChD,OAAO,OAAO,SAAS;CACxB;CACA,OAAO;AACR;;;;;;AAMA,eAAe,oBAAoB,WAAW,OAAO,CAAC,GAAG;CACxD,MAAM,WAAW,KAAK,YAAY;CAClC,MAAM,UAAU,KAAK,WAAW;CAChC,MAAM,QAAQ,KAAK,WAAW,OAAO,IAAI,SAAS,YAAY,WAAW,SAAS,EAAE,CAAC;CACrF,MAAM,cAAc,KAAK,sBAAsB;CAC/C,IAAI;CACJ,KAAK,IAAI,UAAU,GAAG,WAAW,UAAU,WAAW,IAAI;EACzD,OAAO,MAAM,UAAU;CACxB,SAAS,OAAO;EACf,IAAI,CAAC,YAAY,KAAK,GAAG,MAAM;EAC/B,YAAY;EACZ,IAAI,UAAU,UAAU,MAAM,MAAM,OAAO;CAC5C;CACA,MAAM;AACP;;AAEA,SAAS,sBAAsB,SAAS,OAAO,CAAC,GAAG;CAClD,OAAO,oBAAoB,SAAS;EACnC,GAAG;EACH,aAAa;CACd,CAAC;AACF"}

package/dist/postgres-main.mjs

@@ -0,0 +1,492 @@
+import { i as readOwnVersion, n as isValidSegment, r as readJsonFile, t as StateFile } from "./segments-NpKN-46R-B01DmCqy.mjs";
+import { n as portNumbers, t as getPorts } from "./get-port-BYnpbW5H.mjs";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { pathToFileURL } from "node:url";
+import * as http from "node:http";
+//#region ../../1-prisma-cloud/0-lowering/dev-emulators/dist/instance-name-BF6J_weL.mjs
+/**
+* `pcdev-<app>-<database-id>` instance-name derivation (local-dev spec § 2
+* `postgres-main.ts`): each half lowercased, every char outside `[a-z0-9]`
+* replaced by `-`, runs collapsed, the combined name trimmed to 63 chars.
+*
+* A separate, side-effect-free module (not defined inline in
+* `postgres-main.ts`) so it can be imported directly by tests without also
+* running that file's own `main()` — `postgres-main.ts` is a daemon
+* entrypoint script, always invoked as a subprocess, and calls `main()`
+* unconditionally at module load.
+*/
+/**
+* Deliberately linear, no ambiguous quantifiers: a per-character replace
+* (no `+`, so no run-length backtracking surface), a bounded-quantifier
+* collapse (`{2,}`, not alternation-with-quantifiers), and plain
+* index-walking for the leading/trailing trim instead of a regex — a
+* combined `+`-plus-alternation trim (`/^-+|-+$/g`) is exactly the shape
+* CodeQL's polynomial-ReDoS check flags, whether or not this particular
+* instance is provably safe.
+*/
+function slug(segment) {
+	const collapsed = segment.toLowerCase().replace(/[^a-z0-9]/g, "-").replace(/-{2,}/g, "-");
+	let start = 0;
+	let end = collapsed.length;
+	while (start < end && collapsed[start] === "-") start++;
+	while (end > start && collapsed[end - 1] === "-") end--;
+	return collapsed.slice(start, end);
+}
+function instanceNameFor(app, id) {
+	return `pcdev-${slug(app)}-${slug(id)}`.slice(0, 63);
+}
+//#endregion
+//#region ../../1-prisma-cloud/0-lowering/dev-emulators/dist/postgres-main.mjs
+/**
+* The Postgres emulator daemon (local-dev spec § 2 `postgres-main.ts`): a
+* small local counterpart of hosted Postgres, hosting `@prisma/dev`'s
+* `startPrismaDevServer()` — one named, persistent server per `Database`
+* resource, several servers in this one daemon process. Loopback
+* `node:http` JSON admin API; state under its `--state-dir`.
+*
+* `@prisma/dev` is imported dynamically from a CALLER-RESOLVED path (each
+* admin request that needs it carries `prismaDevModulePath`) so the app
+* owns its own Prisma version — this daemon has no `@prisma/dev` dependency
+* of its own.
+*
+* Runs as its own OS process, started by `daemon.ts`'s `ensureDaemon` via
+* `process.execPath <this file> --port <n> --state-dir <dir>`.
+*/
+const MIN_DATABASE_PORT = 51300;
+const MAX_DATABASE_PORT = 65535;
+const APPS_STATE_MODE = 384;
+/** Spec § 2 step 5's pattern, applied to a fresh database-port allocation. */
+const MAX_FRESH_PORT_CANDIDATES = 5;
+const NOT_INSTALLED_MESSAGE = "local dev needs @prisma/dev for its local Postgres emulator — add \"prisma\" to your app's devDependencies.";
+function maskCredentials(text) {
+	return text.replace(/:\/\/([^:@/\s]+):[^@/\s]+@/g, "://$1:***@");
+}
+function firstLine(text) {
+	return (text.split("\n")[0] ?? text).trim();
+}
+function isDatabaseRecord(value) {
+	return typeof value === "object" && value !== null && "id" in value && typeof value.id === "string" && "instanceName" in value && typeof value.instanceName === "string" && "databasePort" in value && typeof value.databasePort === "number" && "url" in value && typeof value.url === "string";
+}
+function isAppRecord(value) {
+	return typeof value === "object" && value !== null && "databases" in value && typeof value.databases === "object" && value.databases !== null && Object.values(value.databases).every(isDatabaseRecord);
+}
+function isAppsState(value) {
+	return typeof value === "object" && value !== null && Object.values(value).every(isAppRecord);
+}
+function isDatabaseBody(value) {
+	return typeof value === "object" && value !== null && "prismaDevModulePath" in value && typeof value.prismaDevModulePath === "string";
+}
+function isPrismaDevModule(value) {
+	return typeof value === "object" && value !== null && "startPrismaDevServer" in value && typeof value.startPrismaDevServer === "function";
+}
+/**
+* `@prisma/dev` exports a `PortNotAvailableError` class with a `readonly
+* port: number`, but the daemon dynamically imports the module from a
+* caller-given path while the class identity checked here would come from
+* whatever module graph THIS file's own bundle produced — two separate
+* instantiations of the same logical class, so `instanceof` doesn't match
+* across them (confirmed empirically: a real port conflict's `err
+* instanceof mod.PortNotAvailableError` is `false` even though the error IS
+* the port-conflict one). Duck-typing the documented shape — a `port`
+* number matching the candidate we just tried — is what actually survives
+* that boundary.
+*/
+/**
+* The port a start refusal is about, when it is one of THIS attempt's ports.
+* Duck-typed (`instanceof` fails across the dynamic-import boundary): every
+* `@prisma/dev` port refusal — not-available, requested-twice, and
+* belongs-to-another-server (its registry can claim a port no bind probe
+* sees) — carries the offending port as `.port`, and any of the four ports
+* we requested (database + the three aux listeners) can be the one refused.
+*/
+function portConflictOf(err, ports) {
+	if (typeof err !== "object" || err === null || !("port" in err)) return void 0;
+	const port = err.port;
+	return typeof port === "number" && ports.includes(port) ? port : void 0;
+}
+function isPrismaDevServer(value) {
+	if (!isStringKeyedRecord(value) || typeof value["close"] !== "function") return false;
+	const database = value["database"];
+	return isStringKeyedRecord(database) && typeof database["connectionString"] === "string";
+}
+/**
+* The live server behind a "name is already running" refusal, when there is
+* one. A start that fails mid-boot (e.g. on a port another server's
+* registry claims) can leave its state entry behind, so OUR OWN next
+* attempt for the same name is refused. `@prisma/dev`'s
+* `ServerAlreadyRunningError` carries the running server as a `.server`
+* getter (duck-typed — `instanceof` fails across the dynamic-import
+* boundary); its parent class (state entry exists but nothing actually
+* runs) has no such getter, and a dead ghost resolves to null — both mean
+* "nothing to adopt".
+*/
+async function adoptableServerOf(err) {
+	if (!isStringKeyedRecord(err) || !("server" in err)) return void 0;
+	if (err["name"] !== "ServerAlreadyRunningError") return void 0;
+	try {
+		const server = await err["server"];
+		return isPrismaDevServer(server) ? server : void 0;
+	} catch {
+		return;
+	}
+}
+function isNameAlreadyTaken(err) {
+	return isStringKeyedRecord(err) && (err["name"] === "ServerAlreadyRunningError" || err["name"] === "ServerStateAlreadyExistsError");
+}
+/** The port of a postgres connection URL, when it parses as one. */
+function databasePortOf(connectionString) {
+	try {
+		const port = Number(new URL(connectionString).port);
+		return Number.isInteger(port) && port > 0 ? port : void 0;
+	} catch {
+		return;
+	}
+}
+/**
+* A dynamic `import()` failure's own message routinely names a SECOND path
+* (e.g. bun's "Cannot find module '<target>' from '<importer>'") — the
+* importer half is this daemon's own internal location, not anything the
+* caller gave us, and has no business in a response body. Rather than try
+* to scrub an arbitrary underlying message for every runtime's own error
+* phrasing, the resolution-failure case names only what the caller
+* supplied — the pinned message plus the given `prismaDevModulePath`, and
+* nothing else. (A DIFFERENT case — a module that resolves fine but whose
+* `startPrismaDevServer()` call itself fails — still surfaces its
+* underlying text verbatim, credential-masked, per spec § 2.)
+*/
+async function importPrismaDev(prismaDevModulePath) {
+	let mod;
+	try {
+		mod = await import(pathToFileURL(prismaDevModulePath).href);
+	} catch {
+		throw new Error(`${NOT_INSTALLED_MESSAGE} (could not resolve "${prismaDevModulePath}")`);
+	}
+	if (!isPrismaDevModule(mod)) throw new Error(`${NOT_INSTALLED_MESSAGE} ("${prismaDevModulePath}" is not a @prisma/dev module)`);
+	return mod;
+}
+function isStringKeyedRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+function isPrismaDevInternalStateModule(value) {
+	return isStringKeyedRecord(value) && typeof value["deleteServer"] === "function";
+}
+/**
+* `@prisma/dev`'s own package.json declares `./internal/state`, whose
+* `deleteServer(name)` actually removes a stateful server's persisted PGlite
+* data — `startPrismaDevServer`'s public surface only starts/closes a live
+* server, never deletes what a closed one left on disk. Resolved by reading
+* the SAME package's own `exports` map (walked up from the caller-given
+* entry path to find `@prisma/dev`'s `package.json`), never by guessing at
+* `dist/` file layout.
+*/
+async function importPrismaDevInternalState(prismaDevModulePath) {
+	let dir = path.dirname(prismaDevModulePath);
+	for (;;) {
+		const pkgPath = path.join(dir, "package.json");
+		if (fs.existsSync(pkgPath)) {
+			const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+			if (isStringKeyedRecord(pkg) && pkg["name"] === "@prisma/dev" && isStringKeyedRecord(pkg["exports"])) {
+				const entry = pkg["exports"]["./internal/state"];
+				const target = resolveExportTarget(entry);
+				if (target === void 0) throw new Error(`"@prisma/dev" at "${dir}" does not declare an "./internal/state" export — cannot delete its persisted database data.`);
+				const mod = await import(pathToFileURL(path.join(dir, target)).href);
+				if (isPrismaDevInternalStateModule(mod)) return mod;
+				throw new Error(`"@prisma/dev"'s "./internal/state" export at "${dir}" has no deleteServer.`);
+			}
+		}
+		const parent = path.dirname(dir);
+		if (parent === dir) throw new Error(`could not find "@prisma/dev"'s package.json above "${prismaDevModulePath}".`);
+		dir = parent;
+	}
+}
+function resolveExportTarget(entry) {
+	if (typeof entry === "string") return entry;
+	if (!isStringKeyedRecord(entry)) return void 0;
+	const nested = entry["import"] ?? entry["require"] ?? entry["default"];
+	if (typeof nested === "string") return nested;
+	if (isStringKeyedRecord(nested)) {
+		const def = nested["default"];
+		if (typeof def === "string") return def;
+	}
+}
+function parseArgs(argv) {
+	let port;
+	let stateDir;
+	for (let i = 0; i < argv.length; i++) if (argv[i] === "--port") port = Number(argv[i + 1]);
+	else if (argv[i] === "--state-dir") stateDir = argv[i + 1];
+	if (port === void 0 || Number.isNaN(port)) throw new Error("postgres-main: --port <n> is required");
+	if (stateDir === void 0) throw new Error("postgres-main: --state-dir <dir> is required");
+	return {
+		port,
+		stateDir
+	};
+}
+function readBody(req) {
+	return new Promise((resolve, reject) => {
+		const chunks = [];
+		req.on("data", (chunk) => chunks.push(chunk));
+		req.on("end", () => resolve(Buffer.concat(chunks)));
+		req.on("error", reject);
+	});
+}
+function main() {
+	const { port, stateDir } = parseArgs(process.argv.slice(2));
+	const ownVersion = readOwnVersion();
+	const appsJsonPath = path.join(stateDir, "apps.json");
+	const stateFile = new StateFile(appsJsonPath, APPS_STATE_MODE);
+	let state = {};
+	const runtimes = /* @__PURE__ */ new Map();
+	const liveAuxPorts = /* @__PURE__ */ new Set();
+	const auxPortsByInstance = /* @__PURE__ */ new Map();
+	function releaseAuxPorts(instanceName) {
+		for (const p of auxPortsByInstance.get(instanceName) ?? []) liveAuxPorts.delete(p);
+		auxPortsByInstance.delete(instanceName);
+	}
+	function schedulePersist() {
+		stateFile.write(state);
+	}
+	function getOrCreateApp(app) {
+		let appRec = state[app];
+		if (!appRec) {
+			appRec = { databases: {} };
+			state[app] = appRec;
+		}
+		return appRec;
+	}
+	function usedDatabasePorts() {
+		const ports = /* @__PURE__ */ new Set();
+		for (const appRec of Object.values(state)) for (const db of Object.values(appRec.databases)) ports.add(db.databasePort);
+		return ports;
+	}
+	async function smallestUnusedDatabasePort(min, alsoExclude = /* @__PURE__ */ new Set()) {
+		return getPorts({
+			port: portNumbers(min, MAX_DATABASE_PORT),
+			exclude: [...usedDatabasePorts(), ...alsoExclude]
+		});
+	}
+	/** Three fresh, mutually distinct ports for a server's own HTTP/shadow-database/streams listeners — never persisted, only unique right now. */
+	async function allocateAuxPorts(excluding) {
+		const taken = /* @__PURE__ */ new Set([
+			...usedDatabasePorts(),
+			...liveAuxPorts,
+			...excluding
+		]);
+		const httpPort = await getPorts({
+			port: portNumbers(MIN_DATABASE_PORT, MAX_DATABASE_PORT),
+			exclude: taken
+		});
+		taken.add(httpPort);
+		const shadowDatabasePort = await getPorts({
+			port: portNumbers(MIN_DATABASE_PORT, MAX_DATABASE_PORT),
+			exclude: taken
+		});
+		taken.add(shadowDatabasePort);
+		return {
+			httpPort,
+			shadowDatabasePort,
+			streamsPort: await getPorts({
+				port: portNumbers(MIN_DATABASE_PORT, MAX_DATABASE_PORT),
+				exclude: taken
+			})
+		};
+	}
+	const inflightEnsures = /* @__PURE__ */ new Map();
+	/** Concurrent PUTs for the same database coalesce onto one start — a second `startPrismaDevServer` for a name whose first start is still booting fails as "already running". */
+	function ensureDatabase(app, id, prismaDevModulePath) {
+		const instanceName = instanceNameFor(app, id);
+		const inflight = inflightEnsures.get(instanceName);
+		if (inflight) return inflight;
+		const run = ensureDatabaseSerialized(app, id, prismaDevModulePath, instanceName).finally(() => {
+			inflightEnsures.delete(instanceName);
+		});
+		inflightEnsures.set(instanceName, run);
+		return run;
+	}
+	async function ensureDatabaseSerialized(app, id, prismaDevModulePath, instanceName) {
+		const appRec = getOrCreateApp(app);
+		const existingRecord = appRec.databases[id];
+		const runningServer = runtimes.get(instanceName);
+		if (existingRecord && runningServer) return { url: existingRecord.url };
+		const prismaDev = await importPrismaDev(prismaDevModulePath);
+		const isFreshAllocation = existingRecord === void 0;
+		let dbPort = existingRecord?.databasePort ?? await smallestUnusedDatabasePort(MIN_DATABASE_PORT);
+		const conflicted = /* @__PURE__ */ new Set();
+		for (let attempt = 1;; attempt++) {
+			const aux = await allocateAuxPorts(/* @__PURE__ */ new Set([dbPort, ...conflicted]));
+			try {
+				const server = await prismaDev.startPrismaDevServer({
+					name: instanceName,
+					databasePort: dbPort,
+					port: aux.httpPort,
+					shadowDatabasePort: aux.shadowDatabasePort,
+					streamsPort: aux.streamsPort,
+					persistenceMode: "stateful"
+				});
+				const url = server.database.connectionString;
+				runtimes.set(instanceName, server);
+				liveAuxPorts.add(aux.httpPort);
+				liveAuxPorts.add(aux.shadowDatabasePort);
+				liveAuxPorts.add(aux.streamsPort);
+				auxPortsByInstance.set(instanceName, [
+					aux.httpPort,
+					aux.shadowDatabasePort,
+					aux.streamsPort
+				]);
+				appRec.databases[id] = {
+					id,
+					instanceName,
+					databasePort: dbPort,
+					url
+				};
+				schedulePersist();
+				return { url };
+			} catch (err) {
+				if (isNameAlreadyTaken(err)) {
+					const ghost = await adoptableServerOf(err);
+					if (ghost !== void 0) {
+						const url = ghost.database.connectionString;
+						runtimes.set(instanceName, ghost);
+						appRec.databases[id] = {
+							id,
+							instanceName,
+							databasePort: databasePortOf(url) ?? dbPort,
+							url
+						};
+						schedulePersist();
+						return { url };
+					}
+					if (attempt < MAX_FRESH_PORT_CANDIDATES) {
+						await (await importPrismaDevInternalState(prismaDevModulePath)).deleteServer(instanceName);
+						continue;
+					}
+				}
+				const conflictPort = portConflictOf(err, [
+					dbPort,
+					aux.httpPort,
+					aux.shadowDatabasePort,
+					aux.streamsPort
+				]);
+				if (!(conflictPort !== void 0 && attempt < MAX_FRESH_PORT_CANDIDATES && (conflictPort !== dbPort || isFreshAllocation))) {
+					const reason = err instanceof Error ? err.message : String(err);
+					throw new Error(`postgres emulator failed to start database "${instanceName}" on port ${String(dbPort)}: ${maskCredentials(firstLine(reason))}`);
+				}
+				conflicted.add(conflictPort);
+				if (conflictPort === dbPort) dbPort = await smallestUnusedDatabasePort(dbPort + 1, conflicted);
+			}
+		}
+	}
+	async function deleteApp(app, prismaDevModulePathHint) {
+		const appRec = state[app];
+		if (!appRec) return;
+		const entries = Object.values(appRec.databases);
+		for (const db of entries) {
+			const server = runtimes.get(db.instanceName);
+			if (server) {
+				await server.close().catch(() => void 0);
+				runtimes.delete(db.instanceName);
+				releaseAuxPorts(db.instanceName);
+			}
+		}
+		if (entries.length > 0 && prismaDevModulePathHint) {
+			const { deleteServer } = await importPrismaDevInternalState(prismaDevModulePathHint);
+			for (const db of entries) await deleteServer(db.instanceName);
+		}
+		delete state[app];
+		schedulePersist();
+	}
+	function json(res, status, body) {
+		res.writeHead(status, { "content-type": "application/json" });
+		res.end(JSON.stringify(body));
+	}
+	function text(res, status, body) {
+		res.writeHead(status, { "content-type": "text/plain; charset=utf-8" });
+		res.end(body);
+	}
+	function badSegment(res, segment) {
+		text(res, 400, `invalid path segment "${segment}": must match /^[a-z0-9][a-z0-9-]*$/ and be at most 63 characters`);
+	}
+	function databaseView(db) {
+		return {
+			id: db.id,
+			url: db.url,
+			instanceName: db.instanceName,
+			databasePort: db.databasePort
+		};
+	}
+	/** The most recently observed `prismaDevModulePath` for any database of `app` — DELETE has no body of its own to carry one. */
+	const recentPrismaDevModulePath = /* @__PURE__ */ new Map();
+	function lastKnownPrismaDevModulePath(app) {
+		return recentPrismaDevModulePath.get(app);
+	}
+	async function handleRequest(req, res) {
+		const url = new URL(req.url ?? "/", `http://127.0.0.1:${String(port)}`);
+		const method = req.method ?? "GET";
+		const segments = url.pathname.split("/").filter((s) => s.length > 0).map((s) => decodeURIComponent(s));
+		if (method === "GET" && segments.length === 1 && segments[0] === "health") return json(res, 200, { version: ownVersion });
+		if (segments[0] === "apps" && segments.length >= 2) {
+			const app = segments[1];
+			if (app === void 0 || !isValidSegment(app)) return badSegment(res, app ?? "");
+			if (method === "PUT" && segments.length === 4 && segments[2] === "databases") {
+				const id = segments[3];
+				if (id === void 0 || !isValidSegment(id)) return badSegment(res, id ?? "");
+				const raw = await readBody(req);
+				let parsed;
+				try {
+					parsed = JSON.parse(raw.toString("utf8"));
+				} catch {
+					return text(res, 400, "malformed JSON body");
+				}
+				if (!isDatabaseBody(parsed)) return text(res, 400, "malformed database body: expected { \"prismaDevModulePath\": string }");
+				recentPrismaDevModulePath.set(app, parsed.prismaDevModulePath);
+				return json(res, 200, await ensureDatabase(app, id, parsed.prismaDevModulePath));
+			}
+			if (method === "GET" && segments.length === 3 && segments[2] === "databases") {
+				const appRec = state[app];
+				return json(res, 200, appRec ? Object.values(appRec.databases).map(databaseView) : []);
+			}
+			if (method === "DELETE" && segments.length === 2) {
+				await deleteApp(app, lastKnownPrismaDevModulePath(app));
+				res.writeHead(204);
+				res.end();
+				return;
+			}
+		}
+		res.writeHead(404);
+		res.end();
+	}
+	const server = http.createServer((req, res) => {
+		handleRequest(req, res).catch((err) => {
+			if (!res.headersSent) res.writeHead(500, { "content-type": "text/plain" });
+			res.end(err instanceof Error ? maskCredentials(err.message) : String(err));
+		});
+	});
+	async function shutdown() {
+		for (const server of runtimes.values()) await server.close().catch(() => void 0);
+		await stateFile.flush();
+		server.close();
+		process.exit(0);
+	}
+	process.on("SIGTERM", () => void shutdown());
+	process.on("SIGINT", () => void shutdown());
+	process.on("unhandledRejection", (reason) => {
+		console.error("postgres-main: unhandled rejection from background work:", reason instanceof Error ? maskCredentials(reason.stack ?? reason.message) : reason);
+	});
+	process.on("uncaughtException", (err) => {
+		console.error("postgres-main: uncaught exception from background work:", err instanceof Error ? maskCredentials(err.stack ?? err.message) : err);
+	});
+	readJsonFile(appsJsonPath, isAppsState).then((loaded) => {
+		if (loaded) state = loaded;
+		server.listen(port, "127.0.0.1", () => {
+			console.log(`[dev-emulators] postgres-main listening on 127.0.0.1:${String(port)}`);
+		});
+	}).catch((err) => {
+		console.error("postgres-main: failed to load state", err);
+		process.exit(1);
+	});
+}
+main();
+//#endregion
+export {};
+
+//# sourceMappingURL=postgres-main.mjs.map