@prisma/composer 0.1.0

package/dist/rpc.mjs

@@ -0,0 +1,132 @@
+import { t as blindCast } from "./casts-Ci5rYYaR.mjs";
+import { i as dependency } from "./graph-BYdCQKya-BI0njTow.mjs";
+import { c as string } from "./dist-zBU8ASQW.mjs";
+//#region ../../0-framework/2-authoring/rpc/dist/index.mjs
+async function standardValidate(schema, value) {
+	const result = await schema["~standard"].validate(value);
+	if (result.issues !== void 0) throw new Error(`Schema validation failed: ${result.issues.map((issue) => issue.message).join("; ")}`);
+	return result.value;
+}
+/** `<base>/rpc/<method>`, preserving a base URL's own path (e.g. a mount point). */
+function methodUrl(base, method) {
+	const normalizedBase = base.endsWith("/") ? base : `${base}/`;
+	return new URL(`rpc/${method}`, normalizedBase).toString();
+}
+/** The server's `{ error }` body, if the response has one — undefined otherwise. */
+async function errorDetail(res) {
+	try {
+		const body = await res.json();
+		return typeof body === "object" && body !== null && "error" in body ? String(body.error) : void 0;
+	} catch {
+		return;
+	}
+}
+function makeClient(contract, url, opts) {
+	const send = opts?.fetch ?? fetch;
+	const client = {};
+	for (const [method, schemas] of Object.entries(blindCast(contract.__cmp))) client[method] = async (input) => {
+		const res = await send(new Request(methodUrl(url, method), {
+			method: "POST",
+			headers: { "content-type": "application/json" },
+			body: JSON.stringify(input)
+		}));
+		if (!res.ok) {
+			const detail = await errorDetail(res);
+			throw new Error(`RPC call "${method}" failed: ${res.status} ${res.statusText}` + (detail !== void 0 ? ` — ${detail}` : ""));
+		}
+		return standardValidate(schemas.output, await res.json());
+	};
+	return blindCast(client);
+}
+function contract(fns) {
+	const value = {
+		kind: "rpc",
+		__cmp: fns,
+		satisfies: (required) => value === required
+	};
+	return Object.freeze(value);
+}
+function rpc(arg) {
+	if (!isRpcContract(arg)) return arg;
+	return dependency({
+		type: "rpc",
+		connection: {
+			params: { url: string() },
+			hydrate: ({ url }) => makeClient(arg, url)
+		},
+		required: arg
+	});
+}
+function isRpcContract(value) {
+	return typeof value === "object" && value !== null && "kind" in value && value.kind === "rpc" && "__cmp" in value && "satisfies" in value;
+}
+function jsonResponse(body, status = 200) {
+	return new Response(JSON.stringify(body), {
+		status,
+		headers: { "content-type": "application/json" }
+	});
+}
+/**
+* Flattens every exposed port's methods into one method → {schemas, handler}
+* table. RPC dispatch is flat (`/rpc/<method>`), so a method name exposed by
+* more than one port is a construction-time error, as is a missing handler.
+*/
+function methodTable(expose, handlers) {
+	const table = /* @__PURE__ */ new Map();
+	for (const [port, contract] of Object.entries(expose)) {
+		const portHandlers = handlers[port] ?? {};
+		for (const [method, fn] of Object.entries(contract.__cmp)) {
+			if (table.has(method)) throw new Error(`serve(): method "${method}" is exposed by more than one port — RPC dispatch is flat (POST /rpc/<method>), so method names must be unique across a service's exposed ports.`);
+			const handler = portHandlers[method];
+			if (handler === void 0) throw new Error(`serve(): no handler supplied for exposed method "${port}.${method}".`);
+			const { input, output } = blindCast(fn);
+			table.set(method, {
+				input,
+				output,
+				handler
+			});
+		}
+	}
+	return table;
+}
+/**
+* Routes `POST /rpc/<method>`: parses JSON, validates input, calls the
+* handler with `service.load()`'s deps, validates the output, and responds
+* JSON. An unknown method or invalid input is a 4xx; a handler (or output
+* validation) failure is a 5xx — either way the process does not crash.
+* `load()` is called exactly once, here, before the handler ever runs.
+*/
+function serve(service, handlers) {
+	const table = methodTable(service.expose ?? {}, blindCast(handlers));
+	const deps = service.load();
+	return async (req) => {
+		const { pathname } = new URL(req.url);
+		const methodName = /^\/rpc\/([^/]+)$/.exec(pathname)?.[1];
+		if (methodName === void 0) return jsonResponse({ error: `Not found: ${pathname}` }, 404);
+		const method = table.get(methodName);
+		if (method === void 0) return jsonResponse({ error: `Unknown RPC method "${methodName}"` }, 404);
+		if (req.method !== "POST") return jsonResponse({ error: `Method "${methodName}" requires POST` }, 405);
+		let body;
+		try {
+			body = await req.json();
+		} catch {
+			return jsonResponse({ error: "Request body must be JSON" }, 400);
+		}
+		let input;
+		try {
+			input = await standardValidate(method.input, body);
+		} catch (err) {
+			return jsonResponse({ error: err instanceof Error ? err.message : String(err) }, 400);
+		}
+		try {
+			const result = await method.handler(input, deps);
+			return jsonResponse(await standardValidate(method.output, result));
+		} catch (err) {
+			return jsonResponse({ error: err instanceof Error ? err.message : String(err) }, 500);
+		}
+	};
+}
+//#endregion
+export { contract, makeClient, rpc, serve };
+
+//# sourceMappingURL=rpc.mjs.map

package/dist/rpc.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"rpc.mjs","names":[],"sources":["../../../0-framework/2-authoring/rpc/dist/index.mjs"],"sourcesContent":["import { blindCast } from \"@internal/foundation/casts\";\nimport { dependency, string } from \"@internal/core\";\n//#region src/standard-schema.ts\nasync function standardValidate(schema, value) {\n\tconst result = await schema[\"~standard\"].validate(value);\n\tif (result.issues !== void 0) throw new Error(`Schema validation failed: ${result.issues.map((issue) => issue.message).join(\"; \")}`);\n\treturn result.value;\n}\n//#endregion\n//#region src/client.ts\n/** `<base>/rpc/<method>`, preserving a base URL's own path (e.g. a mount point). */\nfunction methodUrl(base, method) {\n\tconst normalizedBase = base.endsWith(\"/\") ? base : `${base}/`;\n\treturn new URL(`rpc/${method}`, normalizedBase).toString();\n}\n/** The server's `{ error }` body, if the response has one — undefined otherwise. */\nasync function errorDetail(res) {\n\ttry {\n\t\tconst body = await res.json();\n\t\treturn typeof body === \"object\" && body !== null && \"error\" in body ? String(body.error) : void 0;\n\t} catch {\n\t\treturn;\n\t}\n}\nfunction makeClient(contract, url, opts) {\n\tconst send = opts?.fetch ?? fetch;\n\tconst client = {};\n\tfor (const [method, schemas] of Object.entries(blindCast(contract.__cmp))) client[method] = async (input) => {\n\t\tconst res = await send(new Request(methodUrl(url, method), {\n\t\t\tmethod: \"POST\",\n\t\t\theaders: { \"content-type\": \"application/json\" },\n\t\t\tbody: JSON.stringify(input)\n\t\t}));\n\t\tif (!res.ok) {\n\t\t\tconst detail = await errorDetail(res);\n\t\t\tthrow new Error(`RPC call \"${method}\" failed: ${res.status} ${res.statusText}` + (detail !== void 0 ? ` — ${detail}` : \"\"));\n\t\t}\n\t\treturn standardValidate(schemas.output, await res.json());\n\t};\n\treturn blindCast(client);\n}\n//#endregion\n//#region src/contract.ts\nfunction contract(fns) {\n\tconst value = {\n\t\tkind: \"rpc\",\n\t\t__cmp: fns,\n\t\tsatisfies: (required) => value === required\n\t};\n\treturn Object.freeze(value);\n}\n//#endregion\n//#region src/rpc.ts\nfunction rpc(arg) {\n\tif (!isRpcContract(arg)) return arg;\n\treturn dependency({\n\t\ttype: \"rpc\",\n\t\tconnection: {\n\t\t\tparams: { url: string() },\n\t\t\thydrate: ({ url }) => makeClient(arg, url)\n\t\t},\n\t\trequired: arg\n\t});\n}\nfunction isRpcContract(value) {\n\treturn typeof value === \"object\" && value !== null && \"kind\" in value && value.kind === \"rpc\" && \"__cmp\" in value && \"satisfies\" in value;\n}\n//#endregion\n//#region src/serve.ts\nfunction jsonResponse(body, status = 200) {\n\treturn new Response(JSON.stringify(body), {\n\t\tstatus,\n\t\theaders: { \"content-type\": \"application/json\" }\n\t});\n}\n/**\n* Flattens every exposed port's methods into one method → {schemas, handler}\n* table. RPC dispatch is flat (`/rpc/<method>`), so a method name exposed by\n* more than one port is a construction-time error, as is a missing handler.\n*/\nfunction methodTable(expose, handlers) {\n\tconst table = /* @__PURE__ */ new Map();\n\tfor (const [port, contract] of Object.entries(expose)) {\n\t\tconst portHandlers = handlers[port] ?? {};\n\t\tfor (const [method, fn] of Object.entries(contract.__cmp)) {\n\t\t\tif (table.has(method)) throw new Error(`serve(): method \"${method}\" is exposed by more than one port — RPC dispatch is flat (POST /rpc/<method>), so method names must be unique across a service's exposed ports.`);\n\t\t\tconst handler = portHandlers[method];\n\t\t\tif (handler === void 0) throw new Error(`serve(): no handler supplied for exposed method \"${port}.${method}\".`);\n\t\t\tconst { input, output } = blindCast(fn);\n\t\t\ttable.set(method, {\n\t\t\t\tinput,\n\t\t\t\toutput,\n\t\t\t\thandler\n\t\t\t});\n\t\t}\n\t}\n\treturn table;\n}\n/**\n* Routes `POST /rpc/<method>`: parses JSON, validates input, calls the\n* handler with `service.load()`'s deps, validates the output, and responds\n* JSON. An unknown method or invalid input is a 4xx; a handler (or output\n* validation) failure is a 5xx — either way the process does not crash.\n* `load()` is called exactly once, here, before the handler ever runs.\n*/\nfunction serve(service, handlers) {\n\tconst table = methodTable(service.expose ?? {}, blindCast(handlers));\n\tconst deps = service.load();\n\treturn async (req) => {\n\t\tconst { pathname } = new URL(req.url);\n\t\tconst methodName = /^\\/rpc\\/([^/]+)$/.exec(pathname)?.[1];\n\t\tif (methodName === void 0) return jsonResponse({ error: `Not found: ${pathname}` }, 404);\n\t\tconst method = table.get(methodName);\n\t\tif (method === void 0) return jsonResponse({ error: `Unknown RPC method \"${methodName}\"` }, 404);\n\t\tif (req.method !== \"POST\") return jsonResponse({ error: `Method \"${methodName}\" requires POST` }, 405);\n\t\tlet body;\n\t\ttry {\n\t\t\tbody = await req.json();\n\t\t} catch {\n\t\t\treturn jsonResponse({ error: \"Request body must be JSON\" }, 400);\n\t\t}\n\t\tlet input;\n\t\ttry {\n\t\t\tinput = await standardValidate(method.input, body);\n\t\t} catch (err) {\n\t\t\treturn jsonResponse({ error: err instanceof Error ? err.message : String(err) }, 400);\n\t\t}\n\t\ttry {\n\t\t\tconst result = await method.handler(input, deps);\n\t\t\treturn jsonResponse(await standardValidate(method.output, result));\n\t\t} catch (err) {\n\t\t\treturn jsonResponse({ error: err instanceof Error ? err.message : String(err) }, 500);\n\t\t}\n\t};\n}\n//#endregion\nexport { contract, makeClient, rpc, serve };\n\n//# sourceMappingURL=index.mjs.map"],"mappings":"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"}

package/dist/testing.d.mts

@@ -0,0 +1,24 @@
+import { D as RunnableServiceNode, F as Values, N as Secrets, S as Params, c as Deps, m as HydratedDeps, u as Expose } from "./config-ob5OhCSP-sP3GW3uu.mjs";
+
+//#region ../../0-framework/1-core/core/dist/testing.d.mts
+//#region src/testing.d.ts
+/**
+ * `mockService`'s override argument: every declared dependency, typed against
+ * its own hydrated shape (`Client<C>` for an RPC dep, the resource binding
+ * for a resource dep) — a double of the wrong shape is a compile error. The
+ * service's own params are optional; an omitted one falls back to its
+ * declared default, same as a real `load()`.
+ */
+type LoadOverrides<D extends Deps, P extends Params> = HydratedDeps<D> & Partial<Values<P>>;
+/**
+ * Returns a service node whose `load()` yields the dependency doubles and
+ * `config()` yields the service's params (defaults overlaid with any
+ * overrides) — everything else about the node (its deps, params, build,
+ * expose) is unchanged. `overrides` is one flat object: dependency keys route
+ * to `load()`, param keys to `config()`. `run()` is not meaningful on a mock
+ * (there is no boot, no environment) and throws if called.
+ */
+declare function mockService<D extends Deps, P extends Params, E extends Expose, S extends Secrets>(service: RunnableServiceNode<D, P, E, S>, overrides: LoadOverrides<D, P>): RunnableServiceNode<D, P, E, S>; //#endregion
+//#endregion
+export { LoadOverrides, mockService };
+//# sourceMappingURL=testing.d.mts.map

package/dist/testing.mjs

@@ -0,0 +1,45 @@
+import { t as blindCast } from "./casts-Ci5rYYaR.mjs";
+//#region ../../0-framework/1-core/core/dist/testing.mjs
+/**
+* The unit-test seam (testing.md § Unit): `mockService` replaces a service
+* node's `load()` and `config()` output so any code that pulls dependencies or
+* params through them — a page, a server action, a helper — runs against typed
+* doubles with no server and no environment. Target-agnostic: every service
+* node has `load()`/`config()`. It does no module mocking; wiring the
+* substitution into a test runner (`vi.mock`, `mock.module`) stays in the test.
+* The integration seam (`bootstrapService`) is target-specific and lives in the
+* target's own testing entry (e.g. `@prisma/composer-prisma-cloud/testing`).
+*/
+function paramDefaults(params) {
+	const defaults = {};
+	for (const [name, param] of Object.entries(params)) if (param.default !== void 0) defaults[name] = param.default;
+	return blindCast(defaults);
+}
+/**
+* Returns a service node whose `load()` yields the dependency doubles and
+* `config()` yields the service's params (defaults overlaid with any
+* overrides) — everything else about the node (its deps, params, build,
+* expose) is unchanged. `overrides` is one flat object: dependency keys route
+* to `load()`, param keys to `config()`. `run()` is not meaningful on a mock
+* (there is no boot, no environment) and throws if called.
+*/
+function mockService(service, overrides) {
+	const entries = Object.entries(overrides);
+	const deps = blindCast(Object.fromEntries(entries.filter(([name]) => name in service.inputs)));
+	const config = blindCast({
+		...paramDefaults(service.params),
+		...Object.fromEntries(entries.filter(([name]) => name in service.params))
+	});
+	return Object.freeze({
+		...service,
+		run() {
+			throw new Error(`mockService(): "${service.name}" is a load()/config()-only mock — it has no run() (no boot, no environment).`);
+		},
+		load: () => deps,
+		config: () => config
+	});
+}
+//#endregion
+export { mockService };
+
+//# sourceMappingURL=testing.mjs.map

package/dist/testing.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"testing.mjs","names":[],"sources":["../../../0-framework/1-core/core/dist/testing.mjs"],"sourcesContent":["import { blindCast } from \"@internal/foundation/casts\";\n//#region src/testing.ts\n/**\n* The unit-test seam (testing.md § Unit): `mockService` replaces a service\n* node's `load()` and `config()` output so any code that pulls dependencies or\n* params through them — a page, a server action, a helper — runs against typed\n* doubles with no server and no environment. Target-agnostic: every service\n* node has `load()`/`config()`. It does no module mocking; wiring the\n* substitution into a test runner (`vi.mock`, `mock.module`) stays in the test.\n* The integration seam (`bootstrapService`) is target-specific and lives in the\n* target's own testing entry (e.g. `@prisma/composer-prisma-cloud/testing`).\n*/\nfunction paramDefaults(params) {\n\tconst defaults = {};\n\tfor (const [name, param] of Object.entries(params)) if (param.default !== void 0) defaults[name] = param.default;\n\treturn blindCast(defaults);\n}\n/**\n* Returns a service node whose `load()` yields the dependency doubles and\n* `config()` yields the service's params (defaults overlaid with any\n* overrides) — everything else about the node (its deps, params, build,\n* expose) is unchanged. `overrides` is one flat object: dependency keys route\n* to `load()`, param keys to `config()`. `run()` is not meaningful on a mock\n* (there is no boot, no environment) and throws if called.\n*/\nfunction mockService(service, overrides) {\n\tconst entries = Object.entries(overrides);\n\tconst deps = blindCast(Object.fromEntries(entries.filter(([name]) => name in service.inputs)));\n\tconst config = blindCast({\n\t\t...paramDefaults(service.params),\n\t\t...Object.fromEntries(entries.filter(([name]) => name in service.params))\n\t});\n\treturn Object.freeze({\n\t\t...service,\n\t\trun() {\n\t\t\tthrow new Error(`mockService(): \"${service.name}\" is a load()/config()-only mock — it has no run() (no boot, no environment).`);\n\t\t},\n\t\tload: () => deps,\n\t\tconfig: () => config\n\t});\n}\n//#endregion\nexport { mockService };\n\n//# sourceMappingURL=testing.mjs.map"],"mappings":";;;;;;;;;;;;AAYA,SAAS,cAAc,QAAQ;CAC9B,MAAM,WAAW,CAAC;CAClB,KAAK,MAAM,CAAC,MAAM,UAAU,OAAO,QAAQ,MAAM,GAAG,IAAI,MAAM,YAAY,KAAK,GAAG,SAAS,QAAQ,MAAM;CACzG,OAAO,UAAU,QAAQ;AAC1B;;;;;;;;;AASA,SAAS,YAAY,SAAS,WAAW;CACxC,MAAM,UAAU,OAAO,QAAQ,SAAS;CACxC,MAAM,OAAO,UAAU,OAAO,YAAY,QAAQ,QAAQ,CAAC,UAAU,QAAQ,QAAQ,MAAM,CAAC,CAAC;CAC7F,MAAM,SAAS,UAAU;EACxB,GAAG,cAAc,QAAQ,MAAM;EAC/B,GAAG,OAAO,YAAY,QAAQ,QAAQ,CAAC,UAAU,QAAQ,QAAQ,MAAM,CAAC;CACzE,CAAC;CACD,OAAO,OAAO,OAAO;EACpB,GAAG;EACH,MAAM;GACL,MAAM,IAAI,MAAM,mBAAmB,QAAQ,KAAK,8EAA8E;EAC/H;EACA,YAAY;EACZ,cAAc;CACf,CAAC;AACF"}

package/dist/tsdown.d.mts

@@ -0,0 +1,9 @@
+import { UserConfig } from "tsdown";
+
+//#region src/tsdown.d.ts
+declare function prismaTsDownConfig(config: UserConfig & {
+  entry: NonNullable<UserConfig['entry']>;
+}): UserConfig;
+//#endregion
+export { prismaTsDownConfig };
+//# sourceMappingURL=tsdown.d.mts.map

package/dist/tsdown.mjs

@@ -0,0 +1,35 @@
+//#region src/tsdown.ts
+/**
+* `tsdown` config for a Prisma App's own runnable — the build ADR-0005 expects
+* an app to produce before deploy. Its one job is a **self-contained** ESM
+* bundle: `node_modules` is never shipped, so everything the entry touches at
+* runtime must be inlined, and the artifact must not lean on bun's runtime
+* auto-install to fill gaps. So it inlines EVERYTHING except the runtime's own
+* built-ins (`bun`, `bun:*`, `node:*`) — a denylist, not a per-package
+* allowlist. Allowlists are the trap: `noExternal: [/^pg$/]` inlines `pg` but
+* misses its subpath imports (`pg/lib/*`), which then vanish from the bundle and
+* crash the service at boot. This mirrors the deploy wrapper's own inline
+* policy, so app and wrapper are self-contained the same way.
+*
+* Pass your `entry` (and any override); everything else is dictated.
+*/
+const appBaseConfig = {
+	outDir: "dist",
+	format: "esm",
+	platform: "node",
+	external: ["bun"],
+	noExternal: [/^(?!bun$)(?!bun:)(?!node:).+/],
+	dts: false,
+	sourcemap: false,
+	clean: true
+};
+function prismaTsDownConfig(config) {
+	return {
+		...appBaseConfig,
+		...config
+	};
+}
+//#endregion
+export { prismaTsDownConfig };
+
+//# sourceMappingURL=tsdown.mjs.map

package/dist/tsdown.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"tsdown.mjs","names":[],"sources":["../src/tsdown.ts"],"sourcesContent":["import type { UserConfig } from 'tsdown';\n\n/**\n * `tsdown` config for a Prisma App's own runnable — the build ADR-0005 expects\n * an app to produce before deploy. Its one job is a **self-contained** ESM\n * bundle: `node_modules` is never shipped, so everything the entry touches at\n * runtime must be inlined, and the artifact must not lean on bun's runtime\n * auto-install to fill gaps. So it inlines EVERYTHING except the runtime's own\n * built-ins (`bun`, `bun:*`, `node:*`) — a denylist, not a per-package\n * allowlist. Allowlists are the trap: `noExternal: [/^pg$/]` inlines `pg` but\n * misses its subpath imports (`pg/lib/*`), which then vanish from the bundle and\n * crash the service at boot. This mirrors the deploy wrapper's own inline\n * policy, so app and wrapper are self-contained the same way.\n *\n * Pass your `entry` (and any override); everything else is dictated.\n */\nconst appBaseConfig: UserConfig = {\n  outDir: 'dist',\n  format: 'esm',\n  platform: 'node',\n  external: ['bun'],\n  // Inline everything except runtime built-ins (bun/bun:/node:).\n  noExternal: [/^(?!bun$)(?!bun:)(?!node:).+/],\n  dts: false,\n  sourcemap: false,\n  clean: true,\n};\n\nexport function prismaTsDownConfig(\n  config: UserConfig & { entry: NonNullable<UserConfig['entry']> },\n): UserConfig {\n  return {\n    ...appBaseConfig,\n    ...config,\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;AAgBA,MAAM,gBAA4B;CAChC,QAAQ;CACR,QAAQ;CACR,UAAU;CACV,UAAU,CAAC,KAAK;CAEhB,YAAY,CAAC,8BAA8B;CAC3C,KAAK;CACL,WAAW;CACX,OAAO;AACT;AAEA,SAAgB,mBACd,QACY;CACZ,OAAO;EACL,GAAG;EACH,GAAG;CACL;AACF"}

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@prisma/composer",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Prisma Composer — build a Prisma App by composing Modules. Core authoring, deploy pipeline, the prisma-composer CLI, and the rpc/node/nextjs authoring surfaces.",
+  "bin": {
+    "prisma-composer": "./dist/bin.mjs"
+  },
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./config": "./dist/config.mjs",
+    "./deploy": "./dist/deploy.mjs",
+    "./testing": "./dist/testing.mjs",
+    "./casts": "./dist/casts.mjs",
+    "./assertions": "./dist/assertions.mjs",
+    "./rpc": "./dist/rpc.mjs",
+    "./node": "./dist/node.mjs",
+    "./node/control": "./dist/node-control.mjs",
+    "./nextjs": "./dist/nextjs.mjs",
+    "./nextjs/control": "./dist/nextjs-control.mjs",
+    "./tsdown": "./dist/tsdown.mjs",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@standard-schema/spec": "^1.1.0",
+    "alchemy": "2.0.0-beta.59",
+    "arktype": "^2.2.3",
+    "c12": "^3.3.4",
+    "clipanion": "^3.2.1",
+    "effect": "4.0.0-beta.92",
+    "postgres": "^3.4.9",
+    "@prisma/management-api-sdk": "^1.47.0",
+    "tsdown": "^0.22.3"
+  },
+  "devDependencies": {
+    "@internal/assemble": "0.1.0",
+    "@internal/cli": "0.1.0",
+    "@internal/core": "0.1.0",
+    "@internal/foundation": "0.1.0",
+    "@internal/lowering": "0.1.0",
+    "@internal/nextjs": "0.1.0",
+    "@internal/node": "0.1.0",
+    "@internal/rpc": "0.1.0",
+    "@internal/tsdown-config": "0.1.0",
+    "@types/node": "^25.9.3",
+    "typescript": "^6.0.3"
+  },
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/prisma/compose.git",
+    "directory": "packages/9-public/composer"
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "clean": "rm -rf dist",
+    "typecheck": "tsc --noEmit"
+  }
+}