@prisma/composer 0.35.0 → 0.36.0-dev.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (83) hide show
  1. package/dist/app-config-CErnR6NK-D9NgSBH4.mjs +36 -0
  2. package/dist/app-config-CErnR6NK-D9NgSBH4.mjs.map +1 -0
  3. package/dist/{app-config-B_gQYj3K-DpMi9a4K.d.mts → app-config-CWm3wlNA-BVGreP8x.d.mts} +55 -31
  4. package/dist/app-config-CWm3wlNA-BVGreP8x.d.mts.map +1 -0
  5. package/dist/{config-CdxvLFzg.mjs → config-BFuriECI.mjs} +8 -5
  6. package/dist/config-BFuriECI.mjs.map +1 -0
  7. package/dist/config-BSdGEsYV.d.mts +1 -0
  8. package/dist/config.d.mts +3 -3
  9. package/dist/config.mjs +3 -3
  10. package/dist/control.d.mts +39 -26
  11. package/dist/control.d.mts.map +1 -1
  12. package/dist/control.mjs +20 -4
  13. package/dist/control.mjs.map +1 -1
  14. package/dist/deploy-BSdGEsYV.d.mts +1 -0
  15. package/dist/deploy.d.mts +3 -3
  16. package/dist/deploy.mjs +30 -15
  17. package/dist/deploy.mjs.map +1 -1
  18. package/dist/{deployment-summary-p88NV5m5-DTkPLzTp.d.mts → deployment-summary-p88NV5m5-C2gLUQ8l.d.mts} +3 -3
  19. package/dist/{deployment-summary-p88NV5m5-DTkPLzTp.d.mts.map → deployment-summary-p88NV5m5-C2gLUQ8l.d.mts.map} +1 -1
  20. package/dist/{dev-current-BB02pfSh-D-dYHs1q.mjs → dev-current-BNoPkDRU-CtQMfn60.mjs} +42 -8
  21. package/dist/dev-current-BNoPkDRU-CtQMfn60.mjs.map +1 -0
  22. package/dist/dev-environment-name-6eEr5PW8-CGk1ijP7.mjs +43 -0
  23. package/dist/dev-environment-name-6eEr5PW8-CGk1ijP7.mjs.map +1 -0
  24. package/dist/{dist-Xd2Pp_-u.mjs → dist-CZ_yEZ7F.mjs} +2 -2
  25. package/dist/dist-CZ_yEZ7F.mjs.map +1 -0
  26. package/dist/{execute-deploy-destroy-DwcoZIks-Cl-tWvo0.mjs → execute-deploy-destroy-BIqwt1RF-CP2mVGW_.mjs} +30 -35
  27. package/dist/execute-deploy-destroy-BIqwt1RF-CP2mVGW_.mjs.map +1 -0
  28. package/dist/{execute-dev-BHRWoEnd-D-YNpuEN.mjs → execute-dev-DIEyloWn-C0jgWe-M.mjs} +64 -33
  29. package/dist/execute-dev-DIEyloWn-C0jgWe-M.mjs.map +1 -0
  30. package/dist/{execute-dev-current-D4RkOtPA-CDBtbQUq.mjs → execute-dev-current-CeKI-tiC-DVTy30tU.mjs} +71 -35
  31. package/dist/execute-dev-current-CeKI-tiC-DVTy30tU.mjs.map +1 -0
  32. package/dist/{execute-log-DxjUaSwN-nVFDjZqy.mjs → execute-log-DA5AAQAA-ByUrxpMJ.mjs} +12 -8
  33. package/dist/execute-log-DA5AAQAA-ByUrxpMJ.mjs.map +1 -0
  34. package/dist/{graph-BmTgCiFm-qR5hnhOZ.d.mts → graph-BzTSXnoQ-BvGVq0bm.d.mts} +6 -7
  35. package/dist/graph-BzTSXnoQ-BvGVq0bm.d.mts.map +1 -0
  36. package/dist/{graph-D0ICjejE-CeQtHY5B.mjs → graph-MGOZJdDt-CyI8-9r7.mjs} +377 -58
  37. package/dist/graph-MGOZJdDt-CyI8-9r7.mjs.map +1 -0
  38. package/dist/{graph-types-Cegbwb_X-BU-H2pnt.d.mts → graph-types-DfsG9Rkg-D_ARjMo7.d.mts} +111 -25
  39. package/dist/graph-types-DfsG9Rkg-D_ARjMo7.d.mts.map +1 -0
  40. package/dist/http.d.mts +2 -2
  41. package/dist/http.mjs +2 -2
  42. package/dist/{index-B-9Dc0J7.d.mts → index-D89ftK2z.d.mts} +3 -3
  43. package/dist/{index-B-9Dc0J7.d.mts.map → index-D89ftK2z.d.mts.map} +1 -1
  44. package/dist/index.d.mts +4 -4
  45. package/dist/index.mjs +3 -3
  46. package/dist/{local-target-BUZG9uLx.mjs → local-target-DySKw61w.mjs} +2 -2
  47. package/dist/local-target-DySKw61w.mjs.map +1 -0
  48. package/dist/local-target.d.mts +2 -2
  49. package/dist/local-target.mjs +3 -3
  50. package/dist/{nextjs-DLyeRR7M-kVartQq-.d.mts → nextjs-DLyeRR7M-BeiYsLuZ.d.mts} +3 -3
  51. package/dist/{nextjs-DLyeRR7M-kVartQq-.d.mts.map → nextjs-DLyeRR7M-BeiYsLuZ.d.mts.map} +1 -1
  52. package/dist/nextjs-control.d.mts +4 -4
  53. package/dist/nextjs.d.mts +1 -1
  54. package/dist/node-control.d.mts +3 -3
  55. package/dist/node.d.mts +2 -2
  56. package/dist/report.d.mts +3 -3
  57. package/dist/{run-report-C2o98uD--AX8kpz4Q.mjs → run-report-CmBz2-xc-S50d4g5V.mjs} +5 -5
  58. package/dist/run-report-CmBz2-xc-S50d4g5V.mjs.map +1 -0
  59. package/dist/service-rpc.d.mts +2 -2
  60. package/dist/service-rpc.mjs +2 -2
  61. package/dist/testing.d.mts +1 -1
  62. package/dist/{pipeline-BmWt-Nhb-D9Eg14Sx.mjs → validate-environment-CEhUSEg2-DmAtiQhe.mjs} +20 -7
  63. package/dist/validate-environment-CEhUSEg2-DmAtiQhe.mjs.map +1 -0
  64. package/package.json +11 -11
  65. package/skills/prisma-composer-core-concepts/SKILL.md +108 -56
  66. package/dist/app-config-B_gQYj3K-DpMi9a4K.d.mts.map +0 -1
  67. package/dist/app-config-CGJHcFb--CIEFCG4V.mjs +0 -22
  68. package/dist/app-config-CGJHcFb--CIEFCG4V.mjs.map +0 -1
  69. package/dist/config-Bq3JlQ9_.d.mts +0 -1
  70. package/dist/config-CdxvLFzg.mjs.map +0 -1
  71. package/dist/deploy-Bq3JlQ9_.d.mts +0 -1
  72. package/dist/dev-current-BB02pfSh-D-dYHs1q.mjs.map +0 -1
  73. package/dist/dist-Xd2Pp_-u.mjs.map +0 -1
  74. package/dist/execute-deploy-destroy-DwcoZIks-Cl-tWvo0.mjs.map +0 -1
  75. package/dist/execute-dev-BHRWoEnd-D-YNpuEN.mjs.map +0 -1
  76. package/dist/execute-dev-current-D4RkOtPA-CDBtbQUq.mjs.map +0 -1
  77. package/dist/execute-log-DxjUaSwN-nVFDjZqy.mjs.map +0 -1
  78. package/dist/graph-BmTgCiFm-qR5hnhOZ.d.mts.map +0 -1
  79. package/dist/graph-D0ICjejE-CeQtHY5B.mjs.map +0 -1
  80. package/dist/graph-types-Cegbwb_X-BU-H2pnt.d.mts.map +0 -1
  81. package/dist/local-target-BUZG9uLx.mjs.map +0 -1
  82. package/dist/pipeline-BmWt-Nhb-D9Eg14Sx.mjs.map +0 -1
  83. package/dist/run-report-C2o98uD--AX8kpz4Q.mjs.map +0 -1
@@ -2,7 +2,7 @@
2
2
  name: prisma-composer-core-concepts
3
3
  metadata:
4
4
  library: "@prisma/composer"
5
- library_version: "0.35.0"
5
+ library_version: "0.36.0-dev.2"
6
6
  version: 2026.9.1
7
7
  description: >-
8
8
  Use when deploying or managing an app that uses Prisma Composer
@@ -18,7 +18,7 @@ description: >-
18
18
  A **Prisma App** is a tree of typed declarations composed in TypeScript and
19
19
  handed to the `prisma` CLI, whose two main Composer commands are `prisma deploy`
20
20
  and `prisma dev`. Removing a whole app is `prisma project delete`. Removing
21
- one stage and reading logs are not commands; they are the `destroy` and `log`
21
+ one environment and reading logs are not commands; they are the `destroy` and `log`
22
22
  operations of `@prisma/composer/control`, called from a script.
23
23
  This file covers structures, hierarchies, relationships, and workflows: the
24
24
  concepts you cannot observe from the code or the CLI's help output. It is not
@@ -31,7 +31,7 @@ prisma/composer repo.
31
31
  Two principles govern everything and are binding
32
32
  (`docs/design/01-principles/`):
33
33
 
34
- 1. **Your code never reads its environment.** Dependencies, configuration,
34
+ 1. **Your code never reads environment variables.** Dependencies, configuration,
35
35
  credentials, and the port all arrive through the service node, typed.
36
36
  `process.env` is never the answer.
37
37
  2. **Composer never bundles or transforms your code.** You build with your own
@@ -45,12 +45,13 @@ app, executing nothing when imported. Three node kinds exist:
45
45
 
46
46
  | Kind | Declared with | Purpose |
47
47
  | --- | --- | --- |
48
- | Service | `compute()` | A running unit of your code; atomic, Composer sees only its ports |
48
+ | Service | `compute()` | A running unit of your code; atomic, Composer sees only its boundary |
49
49
  | Resource | `rawPostgres()`, `bucket()` | A stateful managed dependency |
50
- | Module | `module()` | A grouping boundary; runs no code of its own, exposes typed ports |
50
+ | Resource: public URL | `publicUrl()` | Makes one service reachable from the internet at one hostname; depends on the service's exposed HTTP interface and exposes nothing |
51
+ | Module | `module()` | A grouping boundary; runs no code of its own, depends on and exposes typed interfaces; its builder receives `deps`, `secrets`, `params`, `environment` and `provision` |
51
52
 
52
- Nodes connect through **ports**: `deps` declares what a node requires,
53
- `expose` declares what it offers. Wiring happens in a Module's builder via
53
+ Nodes connect through typed **interfaces**: `deps` declares what a node depends on,
54
+ `expose` declares what it exposes. Wiring happens in a Module's builder via
54
55
  `provision()`, and the root Module, handed to the CLI, is the App:
55
56
 
56
57
  ```ts
@@ -63,7 +64,7 @@ export default module('store', ({ provision }) => {
63
64
  });
64
65
  ```
65
66
 
66
- Because ports are typed, **the compiler verifies every wire**. A dependency
67
+ Because interfaces are typed, **the compiler verifies every wire**. A dependency
67
68
  wired to the wrong producer, a missing RPC handler, a literal input value of
68
69
  the wrong shape: all of it fails `tsc`, not the deploy. Env-bound input is
69
70
  the exception: those values exist only at deploy, so secret-binding
@@ -75,8 +76,8 @@ Composer itself is target-agnostic: `@prisma/composer` carries authoring,
75
76
  testing, and the CLI, coupled to no platform. A deploy target is an extension
76
77
  registered in the deploy config; `@prisma/composer-prisma-cloud` is the
77
78
  Prisma Cloud target and the one this skill's deploy sections assume. Its
78
- root exports `compute`, `rawPostgres`, `bucket`, `envSecret`, and
79
- `envParam`; the ORM vocabulary (`postgres`, `dataContract`) lives under the
79
+ root exports `compute`, `rawPostgres`, `bucket`, `publicUrl`, `envSecret`,
80
+ and `envParam`; the ORM vocabulary (`postgres`, `dataContract`) lives under the
80
81
  `/orm` subpath, alongside the shared `/cron`, `/storage`, `/streams`,
81
82
  `/auth`, and `/email` modules. These are the only two Composer packages a
82
83
  basic Prisma Cloud app needs, and nothing installs them for you: a fresh
@@ -129,7 +130,7 @@ client back from `load()`.
129
130
  | The value is… | Declare | Provide | Read |
130
131
  | --- | --- | --- | --- |
131
132
  | produced by another node | `deps: { db: rawPostgres() }` | wire at `provision()` | `load()` |
132
- | anything else (config or credential) | one field of the `input` schema | bind at `provision()`: literal, `envParam()`, or `envSecret()` | `input()` |
133
+ | anything else (config or credential) | one field of the `input` schema | bind at `provision()`: literal, `envParam()`, `envSecret()`, or a `resolve()` value | `input()` |
133
134
 
134
135
  The service declares its whole incoming configuration, plain values and
135
136
  credentials together, as **one [Standard Schema](https://standardschema.dev)**
@@ -145,7 +146,7 @@ Rules that bite:
145
146
  expects `SecretString` fails the deploy; `envSecret` bound to a plain
146
147
  string field fails the same way.
147
148
  2. **`envParam` values arrive as raw strings**; bind them to string fields.
148
- The stage's platform variable is the store; the deploying shell only seeds
149
+ The environment's platform variable is the store; the deploying shell only seeds
149
150
  a missing name (and the deploy fails early, naming the variable, when both
150
151
  lack it). Changing the platform value needs a redeploy.
151
152
  3. **Absence is the schema's call.** An env-bound field whose variable is
@@ -163,6 +164,17 @@ Rules that bite:
163
164
  6. `input.apiKey.expose()` is the only way to a secret's value; the box
164
165
  redacts everywhere else (logs, JSON, errors).
165
166
 
167
+ ### Values that differ per environment
168
+
169
+ The graph is the same in every environment; only configuration may differ.
170
+
171
+ - The module body receives `environment`; `environment.name` is a value standing for the name `--environment` gave (`production` for `prisma deploy`, `dev` for `prisma dev` by default).
172
+ - `resolve([deps], ([values]) => …)` from `@prisma/composer` returns a computed value; `fn` receives the dependencies' real values as one tuple.
173
+ - A value is accepted as a leaf of a service's `input` binding, at any depth, as a service param, or as a public URL's `url`. Never as a provision id, a `deps` entry, or a module's `secrets` or `params` binding.
174
+ - A value is opaque in the body: you cannot read, compare or branch on it. List it as a `resolve()` dependency instead.
175
+ - Calling `provision()` inside `fn` fails the load: `fn` computes configuration, never graph structure.
176
+ - `fn` is pure and synchronous and returns plain data (no `undefined`, Promise, value, `envParam()` or `envSecret()`); a deploy and `destroy` both run it, in two processes. To retire an environment, keep its case in every `fn` until `destroy` for it has finished.
177
+
166
178
  ## Contracts and RPC
167
179
 
168
180
  An RPC contract is the typed interface through which services communicate. It
@@ -217,6 +229,27 @@ through module boundaries; a URL passed as `input` (`serviceOrigin()`)
217
229
  does not, so declare a dependency for every service you call. The auth
218
230
  module's `api` port is a raw HTTP port: wire it with `rawHttp()`.
219
231
 
232
+ **Public URLs.** A service is reachable from the internet only through a
233
+ public URL the app declares:
234
+ `provision(publicUrl({ name: 'site', url, target: web.http }))`, where
235
+ `web` exposes `http: rawHttpContract` (an RPC interface as `target` fails
236
+ `tsc`; a module's forwarded HTTP interface lands on the service inside it).
237
+ `url` is required and is one of two strategies: `publicUrl.prismaBuild()`
238
+ serves at the service's `prisma.build` hostname and creates nothing;
239
+ `publicUrl.hostname('shop.com')`, or the bare string `'shop.com'`, attaches
240
+ that hostname to the service as a custom domain. One hostname per public URL.
241
+ A per-environment `url` is a `resolve()` value returning either strategy or a
242
+ string; anything else fails deploy and dev before any of the app's resources
243
+ are created or changed. Before
244
+ a deploy names a hostname, the TXT record `_prisma-verification.<hostname>`
245
+ and a CNAME to the platform must be published, or the deploy fails with the
246
+ platform's error (`domain-ownership-required` for the TXT record); don't
247
+ work around it, publish the records or use `publicUrl.prismaBuild()` there. A
248
+ change from a serving hostname to one that is not ready fails the deploy and
249
+ the old hostname keeps serving. `prisma dev` ignores a named hostname and
250
+ warns once per public URL that names a hostname. A service with no public URL is still reachable at
251
+ its `prisma.build` hostname today.
252
+
220
253
  ## Builds are yours
221
254
 
222
255
  You build, the framework assembles. For a plain server process, `entry`
@@ -244,7 +277,7 @@ bite:
244
277
  4. **Next.js**: `next build` with `output: 'standalone'` is the whole build;
245
278
  `nextjs({ module, appDir })` names the app root. Any page or action that
246
279
  calls `load()` needs `export const dynamic = 'force-dynamic'`, because
247
- the runtime environment doesn't exist at build time and Next ignores
280
+ the runtime environment variables don't exist at build time and Next ignores
248
281
  runtime env for prerendered routes. `prisma dev` needs no build for it: it
249
282
  runs `next dev` instead (see Local development).
250
283
  5. **Always build before `deploy`, and before `dev` for a service without a
@@ -358,7 +391,7 @@ removing a node removes its deployed resource. `prisma deploy` needs a signed-in
358
391
  identity: `prisma auth login` stores a session on a developer machine, and
359
392
  `PRISMA_SERVICE_TOKEN` overrides it in CI. The `/control` operations, and so
360
393
  a destroy script, never use that session: `deploy` and `destroy` read
361
- `PRISMA_SERVICE_TOKEN` and `PRISMA_WORKSPACE_ID` from the environment (both
394
+ `PRISMA_SERVICE_TOKEN` and `PRISMA_WORKSPACE_ID` from environment variables (both
362
395
  in the workspace's Console settings); `dev` and `log` read neither. The
363
396
  `prisma` bin starts under Node; use `pnpm prisma …` or `npx prisma …` by
364
397
  default. Composer starts Alchemy with Node, but Alchemy's launcher moves to
@@ -382,7 +415,7 @@ deletes the old rows, and a database's or bucket's data with them.
382
415
 
383
416
  **Progress.** `prisma deploy` prints each step as it starts and finishes, with
384
417
  its duration (`✔ assemble web (3m 42s)`), and ends with the real total
385
- (`Deployed <app> to <stage> in 5m 25s.`). Steps: load config and app, one
418
+ (`Deployed <app> to <environment> in 5m 25s.`). Steps: load config and app, one
386
419
  assemble per service, connect to project and branch, check environment
387
420
  variables, plan and apply (one step: alchemy does both in one process), record
388
421
  result. A slow assemble is usually a Node service with
@@ -392,41 +425,64 @@ those extra fields vary, so don't parse them as a stable format. The
392
425
  `deploy` operation's `onEvent` receives the same steps, and its result's
393
426
  `durationMs` is the total.
394
427
 
395
- **Stages.** A stage is an environment name chosen on the command line at
396
- deploy time, never written in the topology. The identical graph deploys
397
- everywhere. On the Prisma Cloud target, a Prisma App is one Project and a
398
- stage is a Branch of it, with its own running services, its own empty
399
- database, its own configuration. A stage name must be a valid git ref name;
400
- an invalid name is a hard error.
401
-
402
- **Seeing what is deployed.** `prisma deploy list [--stage <name>]` lists every
428
+ **Environments.** An environment is a named place the app runs, chosen with
429
+ `--environment` at deploy time, never written in the topology. The identical
430
+ graph deploys everywhere. `prisma deploy` without the flag deploys
431
+ `production`; `prisma dev` runs as `dev` and takes no flag. On the Prisma Cloud
432
+ target, a Prisma App is one Project and an environment is a Branch of it, with
433
+ its own running services, its own empty database, its own configuration:
434
+ `production` is the Project's default Branch, any other name is the Branch
435
+ with that `gitName`, created if absent. The default Branch's own name (such as
436
+ `main`) is refused, since it would be production under a second name. A name
437
+ must be a valid git ref name, or the deploy fails with
438
+ `DEPLOY.ENVIRONMENT_INVALID`.
439
+
440
+ **Seeing what is deployed.** `prisma deploy list [--environment <name>]` lists every
403
441
  node of the topology the last deploy recorded, with its kind, platform ID and,
404
442
  for a service, its URL; the root's ID is the Project's, and a module has none.
405
443
  It finds the app as `deploy` does (`--name`, `--entry`) and fails with
406
- `DEPLOY.TARGET_NOT_FOUND` when the stage has nothing deployed. Piped:
444
+ `DEPLOY.TARGET_NOT_FOUND` when the environment has nothing deployed. Piped:
407
445
  address, kind, platform ID, URL per line; `--json`: `[{ address, kind, platformId, url }]`. It needs
408
446
  a `prisma` CLI release that includes it; 8.0.0-rc.26 does not.
409
447
 
410
- **Removing an app** with every stage is a platform command: find the Project
448
+ **Using an address with platform commands.** A `prisma project|service|postgres|bucket`
449
+ command takes `@<environment>:<address>` in place of the platform ID
450
+ (`prisma service logs @pr-42:shop.api`); no environment means production. It
451
+ acts on that one row. Deleting a service, database or bucket this way leaves
452
+ the deploy state alone, so the next deploy recreates it; deleting the Project
453
+ removes its deploy state too. It needs a `prisma` CLI release newer than
454
+ 8.0.0-rc.28.
455
+
456
+ **Removing an app** with every environment is a platform command: find the Project
411
457
  id with `prisma project list`, then `prisma project delete <id> --confirm <id>`,
412
458
  and check `prisma project list` again to confirm it is gone. It works while the
413
459
  app's services are running. Don't write a script for this.
414
460
 
415
- **Destroying one stage** is the `destroy` operation, and its `target` is required:
416
- `{ kind: 'stage', stage }` or `{ kind: 'production' }`, never a default:
461
+ **Destroying one environment** is the `destroy` operation, and its
462
+ `environment` is required, even for production; it has no default and a call
463
+ without it fails with `DEPLOY.ENVIRONMENT_REQUIRED`:
417
464
 
418
465
  ```ts
419
- await destroy({ entry: 'module.ts', target: { kind: 'stage', stage: 'pr-42' }, config });
466
+ await destroy({ entry: 'module.ts', environment: 'pr-42', config });
467
+ await destroy({ entry: 'module.ts', environment: 'production', config });
420
468
  ```
421
469
 
422
- Destroying a stage
470
+ Destroying any environment other than production
423
471
  deletes its Branch after removing its resources. Destroying production
424
472
  removes only the resources inside the production Branch, never the Branch
425
473
  itself directly; once the Project is empty it is deleted too, and that
426
474
  deletion takes the production Branch with it. A Project still holding
427
- another stage's resources is kept. Destroy never creates anything:
475
+ another environment's resources is kept. Destroy never creates anything:
428
476
  destroying a
429
- never-deployed stage fails rather than standing one up.
477
+ never-deployed environment fails rather than standing one up.
478
+
479
+ **Upgrading from stages.** `--stage <name>` is now `--environment <name>`;
480
+ `destroy({ target })` is now `destroy({ environment })`, with production as
481
+ `'production'`; the `--report` file's `stage` field is now `environment`, at
482
+ `version` 2. Keep `@prisma/composer-prisma-cloud` on the same Composer version
483
+ as the Composer that runs the deploy. An older extension would read every
484
+ environment as production, so deploy and destroy refuse it with
485
+ `DEPS.EXTENSION_INCOMPATIBLE`.
430
486
 
431
487
  **The engine underneath is alchemy.** Convergence is executed by [alchemy](https://alchemy.run), a third-party infrastructure-as-code engine that arrives as an ordinary, exactly-pinned npm dependency of `@prisma/composer` (2.0.0-beta.83 at this library version). Your code never imports or configures it; consult alchemy's own docs for the engine itself. What matters operationally:
432
488
 
@@ -439,14 +495,15 @@ needed.
439
495
  1. The deploy and destroy operations write the pipeline's results to a generated, gitignored
440
496
  stack file at `.prisma-composer/alchemy.run.ts`, then run the alchemy CLI
441
497
  against it as a child process; `dev` does the same at
442
- `.prisma-composer/dev/alchemy.run.ts` with local providers. The file
498
+ `.prisma-composer/dev/<environment>/alchemy.run.ts` with local providers. The file
443
499
  carries the computed values as literals but reads credentials via
444
500
  `fromEnv()`, so nothing sensitive lands on disk, and it is regenerated
445
501
  every run: output, not configuration, never edited.
446
502
  2. Failures are bisectable through that file. A failing deploy names its
447
503
  path and prints a reproduce command: Node running the bin of the `alchemy`
448
504
  Composer depends on, with `deploy .prisma-composer/alchemy.run.ts --yes
449
- --stage <stage>`. Running it directly separates "the framework computed the wrong thing" from "the engine or
505
+ --stage <stage>` (Alchemy's own flag; on Prisma Cloud its value is the
506
+ environment's Branch id). Running it directly separates "the framework computed the wrong thing" from "the engine or
450
507
  platform rejected the right thing". An engine failure surfaces as
451
508
  `DEPLOY.ENGINE_FAILED` carrying the exit code, the engine's own error
452
509
  lines (credentials redacted, capped at 1000 characters) and that reproduce
@@ -511,15 +568,15 @@ that surprise:
511
568
  place of its artifact, with no flag: every `nextjs()` service runs
512
569
  `next dev` (the app's own `next`, resolved from `appDir`), and a `node()`
513
570
  service runs its `dev` argv when it has one. It runs on the service's
514
- instance and URL, with the deployment's environment: `service.load()`,
571
+ instance and URL, with the deployment's environment variables: `service.load()`,
515
572
  `service.input()` and `service.port()` work exactly as deployed, so never add a
516
573
  `process.env` fallback for plain `next dev`. It also keeps the shell's
517
- environment; Composer's values win. `dev` prints ``<address>: runs
574
+ environment variables; Composer's values win. `dev` prints ``<address>: runs
518
575
  `<command>` in <dir>`` before the app comes up and streams the dev
519
576
  server's output prefixed `[<address>]` (other services' logs are not
520
577
  streamed). Source edits are the dev server's own hot reload; `dev` watches
521
578
  the entry and every service's authoring module, reconverges on a topology
522
- edit, and restarts a dev server only when its environment changed
579
+ edit, and restarts a dev server only when its environment variables changed
523
580
  (``<address>: its environment changed; `<command>` restarted``). It has no
524
581
  terminal (no colours or key shortcuts). The standalone build is not run
525
582
  locally, so a standalone-only bug surfaces at `prisma deploy`. Next.js
@@ -531,8 +588,8 @@ that surprise:
531
588
  installed in `appDir`); `DEV.DEV_SERVER_UNSUPPORTED` (the service's package
532
589
  is too old; the message names it).
533
590
  `ready` prints only once every service accepts connections on its port, except a service declared `compute({ ..., listens: false })` (one that never listens, like the cron scheduler), which counts as running once its process starts. A service that exits before it listens, or does not listen within 30 seconds, fails `dev` (and stops the app's other services) with a message naming the service, its port, and its log file: on a first start it is in the deploy engine's output, before the error that the deploy engine exited (`DEV.CONVERGE_FAILED` from the `dev` operation); on a warm start it is the `DEV.SERVICE_START_FAILED` message. `PRISMA_COMPOSER_SERVICE_READY_TIMEOUT_MS` raises the 30-second limit (milliseconds); the compute emulator reads it when it starts, so a running emulator keeps its old value until its process ends. An emulator that does not accept connections fails `dev` and `log` with `DEV.EMULATOR_UNREACHABLE` after a few seconds of retries; nothing else is retried.
534
- 2. Ctrl-C (or `dev` ending on SIGTERM or a failure) stops the app's service processes and its local Postgres servers and keeps their data and ports: the next `dev` is a warm start. Starting clean, wiping this app's local instances and data first, is an explicit opt-in flag. On a fresh start, each service gets the lowest free port from 3000 up, in dependency order: a service before the services that call it, otherwise provision order. A warm start keeps the ports services already have.
535
- Services, databases and buckets belong to the directory `dev` runs in: two checkouts of one app (two git worktrees) run separate processes on separate ports, with separate databases and buckets, and never restart or write into each other's. `.prisma-composer/dev/emulator-instances.json` records which local instance backs each node. A service or database keeps its port in its directory across runs, even while stopped. If a local instance is gone (a Composer upgrade discarded an emulator's state), the next `dev` re-creates it, empty, and asks for the old port, and a Prisma ORM database's (`postgres()`) committed migrations run again (a `rawPostgres()` database stays empty); when another directory has taken the port, the instance gets the lowest free one and `dev` prints `[dev] service "<address>" now uses port <new>: its previous port <old> is in use` (`database "<address>"` for a database). A directory keeps the local state of every app run from it: running a different app there (another entry, another `--name`) stops the previous app's services and databases, keeps their data and ports, and prints `[dev] stopped the local services of "<app>", the app run here before; its data is kept`; running it again resumes them. `--fresh` wipes only the app it starts. A stopped instance keeps its port reserved and a database its data, so a deleted checkout's instances keep theirs; there is no command to remove them yet.
591
+ 2. Ctrl-C (or `dev` ending on SIGTERM or a failure) stops the app's service processes and its local Postgres servers and keeps their data and ports: the next `dev` is a warm start. Starting clean, wiping this app's local instances and data in this environment first, is an explicit opt-in flag (`--fresh`). On a fresh start, each service gets the lowest free port from 3000 up, in dependency order: a service before the services that call it, otherwise provision order. A warm start keeps the ports services already have.
592
+ Services, databases and buckets belong to the directory `dev` runs in: two checkouts of one app (two git worktrees) run separate processes on separate ports, with separate databases and buckets, and never restart or write into each other's. `.prisma-composer/dev/<environment>/emulator-instances.json` records which local instance backs each node. A service or database keeps its port in its directory across runs, even while stopped. If a local instance is gone (a Composer upgrade discarded an emulator's state), the next `dev` re-creates it, empty, and asks for the old port, and a Prisma ORM database's (`postgres()`) committed migrations run again (a `rawPostgres()` database stays empty); when another directory has taken the port, the instance gets the lowest free one and `dev` prints `[dev] service "<address>" now uses port <new>: its previous port <old> is in use` (`database "<address>"` for a database). `dev` runs as the environment `dev`; `--environment <name>` runs a complete, separate local copy with its own services, databases, buckets and ports, beside any other. Running a different app or environment stops nothing. For tests that must not touch working data, use `prisma dev --environment test --fresh --detach`, and pass the same `--environment` to `dev url` and `dev stop`. `--fresh` wipes only the app it starts, in its environment. Names that differ only in case share one folder on a case-insensitive filesystem (macOS), so a name that differs from the one the folder records is refused with `DEV.ENVIRONMENT_NAME_MISMATCH`. Everything local to one copy lives in `.prisma-composer/dev/<environment>/`; the first `dev`, `dev url`, `dev stop` or `log` after upgrading from a version with one copy per directory moves the existing local state into `dev`, keeping its data. An older `@prisma/composer-prisma-cloud` is refused with `DEPS.EXTENSION_INCOMPATIBLE`. A stopped instance keeps its port reserved and a database its data, so a deleted checkout's instances keep theirs; there is no command to remove them yet.
536
593
  3. `dev` does not print the logs of services that run their artifact. The
537
594
  `log` operation follows the already-running app's merged logs; it never
538
595
  builds, provisions, starts, or stops anything:
@@ -542,25 +599,26 @@ that surprise:
542
599
  if (attached.ok) for await (const { service, line } of attached.value.lines) console.log(service, line);
543
600
  ```
544
601
  Don't hard-code a local port; ports differ per directory. `prisma dev url
545
- <address>` (run in the same directory as `dev`) prints where a running node
602
+ <address>` (run in the same directory as `dev`; `--environment`, default `dev`, picks the copy; the address's first segment names the app, and no entry is loaded) prints where a running node
546
603
  answers: a service's `http://localhost:<port>`, a database's connection
547
604
  string, a bucket's S3 endpoint plus `/<bucket>`. The URL alone goes to
548
605
  stdout, piped or not, so scripts use `url=$(prisma dev url shop.gateway) && curl "$url"`
549
606
  (`dev url`, `dev stop` and `emulator list` first ship in the `prisma`
550
607
  release after 8.0.0-rc.23).
551
608
  `--json` gives the full result or the error with its code. It fails with
552
- `DEV.NOT_STARTED_HERE` (no `dev` ran here), `DEV.ADDRESS_UNKNOWN` (lists
609
+ `DEV.NOT_STARTED_HERE` (that app never ran in that environment here), `DEV.ADDRESS_UNKNOWN` (lists
553
610
  the known addresses), `DEV.EMULATOR_UNREACHABLE`, or `DEV.NOT_RUNNING` (the
554
611
  node is stopped, a service is crash-looping and its log is named, or the
555
612
  emulator lost the node and the next `dev` creates it again).
556
- `prisma dev stop` stops the app's services and database servers when `dev`
557
- was killed without doing it; data and ports stay. It lists what it
613
+ `prisma dev stop` stops the app's services and database servers in one
614
+ environment (`--environment`, default `dev`; the app comes from the entry
615
+ or `--name`) when `dev` was killed without doing it; data and ports stay. It lists what it
558
616
  stopped, and says so and still succeeds when nothing was running.
559
617
  `prisma emulator list`
560
618
  shows every local emulator and its instances, from any directory; one that
561
619
  runs but cannot be listed carries an `error` in its own entry. Piped, it
562
620
  writes one tab-separated line per instance: emulator kind, instance id,
563
- URL, state, node address, directory.
621
+ URL, state, node address, directory, environment.
564
622
  `prisma emulator start` and `stop` are planned.
565
623
  For agents, scripts and CI, `prisma dev --detach` runs the app in
566
624
  the background: it exits 0 once every service answers and prints the URLs,
@@ -572,13 +630,7 @@ that surprise:
572
630
  build and run `prisma dev --detach` again.
573
631
  4. `dev` reads `prisma.config.ts` once, at start, and watches it: after an
574
632
  edit it says so and pauses rebuilds until you restart `dev`.
575
- 5. An unset secret doesn't block a local run: it becomes a placeholder plus a
576
- warning, and only the code path that spends it fails, at the external
577
- service it calls. A secret's value comes from the shell `prisma` runs in.
578
- A `.env` loaded only by the framework (Next.js) does **not** fill it:
579
- Composer has already set the variable, to the placeholder, and Next never
580
- overrides a set variable. Load `.env` at the top of `prisma.config.ts`
581
- (`if (existsSync('.env')) process.loadEnvFile('.env');`) or export it.
633
+ 5. `dev` reads secrets only from its environment variables: export them in the shell, or load a `.env`: install the `dotenv` package, then make `import 'dotenv/config'` the first line of `prisma.config.ts` (`process.loadEnvFile('.env')` works only under Node, not Bun). A required secret that is unset or empty stops `dev` with an error naming it; an optional one reaches the service as absent. A changed value takes effect on the next `prisma dev`. A `.env` that only the framework loads (Next.js) does not count: Composer reads secrets before the dev server starts.
582
634
  6. The emulators are machine-wide daemons shared by every `dev`, registered
583
635
  under `~/.prisma-composer/emulators`. Set `PRISMA_COMPOSER_EMULATORS_DIR`
584
636
  to an absolute directory to give a checkout or CI job its own compute,
@@ -598,10 +650,10 @@ ignored. If the emulator reports that `@prisma/dev` did not resolve, the install
598
650
  is broken: reinstall dependencies rather than adding `@prisma/dev` or `prisma`.
599
651
  Cloud deployment and local apps without Postgres never load this runtime.
600
652
 
601
- ## Testing is an environment seam
653
+ ## Testing is a dependency-injection seam
602
654
 
603
- A test is just another environment: one where you decide what `load()` and
604
- `input()` return, never by editing the code under test.
655
+ A test decides what `load()` and `input()` return, never by editing the code
656
+ under test.
605
657
 
606
658
  | You want to… | Use | From |
607
659
  | --- | --- | --- |
@@ -721,12 +773,12 @@ today the blocks above plus your own Modules are the whole set, so verify a
721
773
 
722
774
  Name the gap instead of inventing an API:
723
775
 
724
- 1. **No `prisma` command for removing one stage, or for logs.** Remove a whole
725
- app with `prisma project delete <id> --confirm <id>`. For one stage and for
776
+ 1. **No `prisma` command for removing one environment, or for logs.** Remove a whole
777
+ app with `prisma project delete <id> --confirm <id>`. For one environment and for
726
778
  logs, use the `destroy` and `log` operations of `@prisma/composer/control`
727
779
  from a script. A destroy script
728
780
  cannot use the `prisma auth login` session; it needs `PRISMA_SERVICE_TOKEN`
729
- and `PRISMA_WORKSPACE_ID` in the environment.
781
+ and `PRISMA_WORKSPACE_ID` as environment variables.
730
782
  2. **No in-memory contract bindings.** A dependency can't yet be wired to a
731
783
  co-located handler without HTTP; use `bootstrapService` with a loopback
732
784
  fake.
@@ -1 +0,0 @@
1
- {"version":3,"file":"app-config-B_gQYj3K-DpMi9a4K.d.mts","names":[],"sources":["../../../0-framework/1-core/core/dist/app-config-B_gQYj3K.d.mts"],"mappings":"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"}
@@ -1,22 +0,0 @@
1
- //#region ../../0-framework/1-core/core/dist/app-config-CGJHcFb-.mjs
2
- /** `<cwd>/.prisma-composer/dev` — the dev instance's app-scoped state directory (ADR-0041, ADR-0004's tool-state rule). "dev" names the user-facing feature/dir (naming, operator 2026-07-23) — this constant's name and value are unchanged by the localTarget rename. */
3
- const DEV_DIR = ".prisma-composer/dev";
4
- /**
5
- * True when an extension only participates in assembly (every `nodes` entry
6
- * is `kind: 'build'`, and it declares none of `providers`/`application`/
7
- * `provisions`/`container`) — it owns no resources or services, so it has
8
- * nothing to emulate and is exempt from local-target-capability requirements
9
- * (ADR-0041). Shared by `localTargetProviders` and every local-target hook
10
- * iteration.
11
- */
12
- function isBuildOnlyExtension(extension) {
13
- return Object.values(extension.nodes).every((node) => node.kind === "build") && extension.providers === void 0 && extension.application === void 0 && extension.provisions === void 0 && extension.container === void 0;
14
- }
15
- /** Typed identity — exists so the `composer` section of `prisma.config.ts` gets checked against PrismaAppConfig where it is written. */
16
- function defineConfig(config) {
17
- return config;
18
- }
19
- //#endregion
20
- export { defineConfig as n, isBuildOnlyExtension as r, DEV_DIR as t };
21
-
22
- //# sourceMappingURL=app-config-CGJHcFb--CIEFCG4V.mjs.map
@@ -1 +0,0 @@
1
- {"version":3,"file":"app-config-CGJHcFb--CIEFCG4V.mjs","names":[],"sources":["../../../0-framework/1-core/core/dist/app-config-CGJHcFb-.mjs"],"sourcesContent":["//#region src/control/app-config.ts\n/** `<cwd>/.prisma-composer/dev` — the dev instance's app-scoped state directory (ADR-0041, ADR-0004's tool-state rule). \"dev\" names the user-facing feature/dir (naming, operator 2026-07-23) — this constant's name and value are unchanged by the localTarget rename. */\nconst DEV_DIR = \".prisma-composer/dev\";\n/**\n* True when an extension only participates in assembly (every `nodes` entry\n* is `kind: 'build'`, and it declares none of `providers`/`application`/\n* `provisions`/`container`) — it owns no resources or services, so it has\n* nothing to emulate and is exempt from local-target-capability requirements\n* (ADR-0041). Shared by `localTargetProviders` and every local-target hook\n* iteration.\n*/\nfunction isBuildOnlyExtension(extension) {\n\treturn Object.values(extension.nodes).every((node) => node.kind === \"build\") && extension.providers === void 0 && extension.application === void 0 && extension.provisions === void 0 && extension.container === void 0;\n}\n/** Typed identity — exists so the `composer` section of `prisma.config.ts` gets checked against PrismaAppConfig where it is written. */\nfunction defineConfig(config) {\n\treturn config;\n}\n//#endregion\nexport { defineConfig as n, isBuildOnlyExtension as r, DEV_DIR as t };\n\n//# sourceMappingURL=app-config-CGJHcFb-.mjs.map"],"mappings":";;AAEA,MAAM,UAAU;;;;;;;;;AAShB,SAAS,qBAAqB,WAAW;CACxC,OAAO,OAAO,OAAO,UAAU,KAAK,CAAC,CAAC,OAAO,SAAS,KAAK,SAAS,OAAO,KAAK,UAAU,cAAc,KAAK,KAAK,UAAU,gBAAgB,KAAK,KAAK,UAAU,eAAe,KAAK,KAAK,UAAU,cAAc,KAAK;AACvN;;AAEA,SAAS,aAAa,QAAQ;CAC7B,OAAO;AACR"}
@@ -1 +0,0 @@
1
- import "./app-config-B_gQYj3K-DpMi9a4K.mjs";
@@ -1 +0,0 @@
1
- {"version":3,"file":"config-CdxvLFzg.mjs","names":[],"sources":["../../../0-framework/1-core/core/dist/config.mjs"],"sourcesContent":["import { i as envVarSafeExtensionId, n as containerEnvVarName, r as deserializeContainers, t as containerEnv } from \"./container-transport-HcvNOGZL.mjs\";\nimport { n as defineConfig, r as isBuildOnlyExtension, t as DEV_DIR } from \"./app-config-CGJHcFb-.mjs\";\n//#region src/preflight-transport.ts\n/**\n* Carries an extension's deploy-preflight payload from the CLI process to the\n* alchemy child (which re-imports the config from scratch) — one env var per\n* extension, same channel as containers (container-transport.ts). The\n* framework never reads the contents. Payloads carry metadata only, never\n* secret values: the child's environment is not a secret store.\n*/\n/** '@prisma/composer-prisma-cloud' → 'PRISMA_COMPOSER_PREFLIGHT_PRISMA_COMPOSER_PRISMA_CLOUD' */\nfunction preflightEnvVarName(extensionId) {\n\treturn `PRISMA_COMPOSER_PREFLIGHT_${envVarSafeExtensionId(extensionId)}`;\n}\n/** The env entries the CLI sets on the alchemy process: `{ [preflightEnvVarName(id)]: payload }` for every extension whose preflight returned one. */\nfunction preflightEnv(payloads) {\n\tconst env = {};\n\tconst ownerByVarName = /* @__PURE__ */ new Map();\n\tfor (const [extensionId, payload] of payloads) {\n\t\tif (payload.length === 0) continue;\n\t\tconst varName = preflightEnvVarName(extensionId);\n\t\tconst owner = ownerByVarName.get(varName);\n\t\tif (owner !== void 0) throw new Error(`Extension ids \"${owner}\" and \"${extensionId}\" both map to the preflight transport variable \"${varName}\" — rename one of the extensions.`);\n\t\townerByVarName.set(varName, extensionId);\n\t\tenv[varName] = payload;\n\t}\n\treturn env;\n}\n/** The alchemy-process side: the payload this extension's own preflight wrote, or `undefined` when it wrote none (or when nothing ran a preflight at all). */\nfunction readPreflightPayload(extensionId, env) {\n\tconst payload = env[preflightEnvVarName(extensionId)];\n\treturn payload === void 0 || payload.length === 0 ? void 0 : payload;\n}\n//#endregion\nexport { DEV_DIR, containerEnv, containerEnvVarName, defineConfig, deserializeContainers, isBuildOnlyExtension, preflightEnv, preflightEnvVarName, readPreflightPayload };\n\n//# sourceMappingURL=config.mjs.map"],"mappings":";;;;;;;;;;AAWA,SAAS,oBAAoB,aAAa;CACzC,OAAO,6BAA6B,sBAAsB,WAAW;AACtE;;AAEA,SAAS,aAAa,UAAU;CAC/B,MAAM,MAAM,CAAC;CACb,MAAM,iCAAiC,IAAI,IAAI;CAC/C,KAAK,MAAM,CAAC,aAAa,YAAY,UAAU;EAC9C,IAAI,QAAQ,WAAW,GAAG;EAC1B,MAAM,UAAU,oBAAoB,WAAW;EAC/C,MAAM,QAAQ,eAAe,IAAI,OAAO;EACxC,IAAI,UAAU,KAAK,GAAG,MAAM,IAAI,MAAM,kBAAkB,MAAM,SAAS,YAAY,kDAAkD,QAAQ,kCAAkC;EAC/K,eAAe,IAAI,SAAS,WAAW;EACvC,IAAI,WAAW;CAChB;CACA,OAAO;AACR;;AAEA,SAAS,qBAAqB,aAAa,KAAK;CAC/C,MAAM,UAAU,IAAI,oBAAoB,WAAW;CACnD,OAAO,YAAY,KAAK,KAAK,QAAQ,WAAW,IAAI,KAAK,IAAI;AAC9D"}
@@ -1 +0,0 @@
1
- import "./app-config-B_gQYj3K-DpMi9a4K.mjs";
@@ -1 +0,0 @@
1
- {"version":3,"file":"dev-current-BB02pfSh-D-dYHs1q.mjs","names":[],"sources":["../../../0-framework/0-foundation/foundation/dist/result.mjs","../../../0-framework/3-tooling/cli/dist/dev-current-BB02pfSh.mjs"],"sourcesContent":["import { t as blindCast } from \"./casts-DpaahrlC.mjs\";\nimport { t as InternalError } from \"./internal-error-Dfur7Zqt.mjs\";\n//#region src/result.ts\n/**\n* Generic Result type for representing success or failure outcomes.\n*\n* This is the standard way to return \"expected failures\" as values rather than\n* throwing exceptions. See docs/Error Handling.md for the full taxonomy.\n*\n* Naming rationale:\n* - `Ok<T>` / `NotOk<F>` mirror the `ok: true/false` discriminator\n* - `NotOk` avoids collision with domain types like \"Failure\" or \"Error\"\n* - `failure` property distinguishes from JS Error semantics\n*/\n/**\n* Result class that implements both Ok and NotOk variants.\n*/\nvar ResultImpl = class ResultImpl {\n\tok;\n\t_value;\n\t_failure;\n\tconstructor(ok, valueOrFailure) {\n\t\tthis.ok = ok;\n\t\tif (ok) this._value = blindCast(valueOrFailure);\n\t\telse this._failure = blindCast(valueOrFailure);\n\t\tObject.freeze(this);\n\t}\n\tget value() {\n\t\tif (!this.ok) throw new InternalError(\"Cannot access value on NotOk result\");\n\t\treturn this._value;\n\t}\n\tget failure() {\n\t\tif (this.ok) throw new InternalError(\"Cannot access failure on Ok result\");\n\t\treturn this._failure;\n\t}\n\t/**\n\t* Creates a successful result.\n\t*/\n\tstatic ok(value) {\n\t\treturn blindCast(new ResultImpl(true, value));\n\t}\n\t/**\n\t* Creates an unsuccessful result.\n\t*/\n\tstatic notOk(failure) {\n\t\treturn blindCast(new ResultImpl(false, failure));\n\t}\n\t/**\n\t* Asserts that this result is Ok and returns the value.\n\t* Throws if the result is NotOk.\n\t*/\n\tassertOk() {\n\t\tif (!this.ok) throw new InternalError(\"Expected Ok result but got NotOk\");\n\t\treturn this.value;\n\t}\n\t/**\n\t* Asserts that this result is NotOk and returns the failure.\n\t* Throws if the result is Ok.\n\t*/\n\tassertNotOk() {\n\t\tif (this.ok) throw new InternalError(\"Expected NotOk result but got Ok\");\n\t\treturn this.failure;\n\t}\n};\n/**\n* Creates a successful result.\n*/\nfunction ok(value) {\n\treturn ResultImpl.ok(value);\n}\n/**\n* Creates an unsuccessful result.\n*/\nfunction notOk(failure) {\n\treturn ResultImpl.notOk(failure);\n}\n/**\n* Singleton for void success results.\n* Use this for validation checks that don't produce a value.\n*/\nconst OK_VOID = ResultImpl.ok(void 0);\n/**\n* Returns a successful void result.\n* Use this for validation checks that don't produce a value.\n*/\nfunction okVoid() {\n\treturn OK_VOID;\n}\n//#endregion\nexport { notOk, ok, okVoid };\n\n//# sourceMappingURL=result.mjs.map","import { CliStructuredError } from \"@internal/foundation/errors\";\nimport { blindCast } from \"@internal/foundation/casts\";\nimport { notOk, ok } from \"@internal/foundation/result\";\n//#region src/operations/shared.ts\n/**\n* Reads the execution diagnostics an engine-failure error carries in\n* `meta.diagnostics`; undefined for every other failure.\n*/\nfunction executionDiagnostics(f) {\n\tconst diagnostics = f.meta?.[\"diagnostics\"];\n\tif (typeof diagnostics !== \"object\" || diagnostics === null) return void 0;\n\tconst candidate = blindCast(diagnostics);\n\tif (candidate[\"exitCode\"] !== void 0 && typeof candidate[\"exitCode\"] !== \"number\" || candidate[\"signal\"] !== void 0 && typeof candidate[\"signal\"] !== \"string\" || typeof candidate[\"stackFilePath\"] !== \"string\" || typeof candidate[\"reproduceCommand\"] !== \"string\" || typeof candidate[\"cwd\"] !== \"string\") return;\n\treturn blindCast(diagnostics);\n}\n/**\n* Site-specific wrap for foreign extension/environment causes — passthrough\n* when already structured; never a boundary fallback (base-type rule 6(ii)).\n*/\nfunction toStructured(code, error) {\n\treturn CliStructuredError.is(error) ? error : new CliStructuredError(code, error instanceof Error ? error.message : String(error), { cause: error });\n}\n/** A failed executor import: an environmental failure of the consumer's\n* installed tree, not a bug here. The import error rides as the cause. */\nfunction executorLoadFailure(operation, error) {\n\treturn new CliStructuredError(\"DEPS.EXECUTOR_UNLOADABLE\", `Could not load the ${operation} executor: ${error instanceof Error ? error.message : String(error)}`, {\n\t\twhy: `The ${operation} operation's executor imports the deploy engine's provider tree from your app's installed dependencies, and that import failed.`,\n\t\tfix: \"Reinstall your dependencies, and check that `alchemy` is installed and loadable from your app.\",\n\t\tcause: error\n\t});\n}\n//#endregion\n//#region src/operations/deploy.ts\nasync function deploy(input) {\n\treturn deployWithDeps(input, {});\n}\n/** In-package variant threading the injection seam, which the family's\n* commands and the unit tests use. Deliberately NOT re-exported through `./control` — the seam mirrors\n* internal types and is not part of the published surface. */\nasync function deployWithDeps(input, deps) {\n\tconst startedAt = performance.now();\n\tconst cwd = input.cwd ?? process.cwd();\n\tlet executor;\n\ttry {\n\t\texecutor = await import(\"./execute-deploy-destroy-DwcoZIks.mjs\");\n\t} catch (error) {\n\t\treturn notOk(executorLoadFailure(\"deploy\", error));\n\t}\n\tconst result = await executor.executeDeploy(input, deps, cwd);\n\tif (!result.ok) return result;\n\treturn ok({\n\t\t...result.value,\n\t\tdurationMs: Math.round(performance.now() - startedAt)\n\t});\n}\n//#endregion\n//#region src/operations/dev.ts\nasync function dev(input) {\n\treturn devWithDeps(input, {});\n}\n/** In-package variant threading the injection seam, which the family's\n* commands and the unit tests use. Deliberately NOT re-exported through `./control` — the seam mirrors\n* internal types and is not part of the published surface. */\nasync function devWithDeps(input, deps) {\n\tconst cwd = input.cwd ?? process.cwd();\n\tlet executor;\n\ttry {\n\t\texecutor = await import(\"./execute-dev-BHRWoEnd.mjs\");\n\t} catch (error) {\n\t\treturn notOk(executorLoadFailure(\"dev\", error));\n\t}\n\treturn executor.executeDev(input, deps, cwd);\n}\n//#endregion\n//#region src/operations/dev-current.ts\nasync function loadExecutor(operation) {\n\ttry {\n\t\treturn ok(await import(\"./execute-dev-current-D4RkOtPA.mjs\"));\n\t} catch (error) {\n\t\treturn notOk(executorLoadFailure(operation, error));\n\t}\n}\n/** Where the node at `input.address` of the directory's current app runs locally. */\nasync function devUrl(input) {\n\tconst executor = await loadExecutor(\"dev url\");\n\tif (!executor.ok) return executor;\n\treturn executor.value.executeDevUrl(input, input.cwd ?? process.cwd());\n}\n/** Stops the directory's current app: its service processes and database servers. Data and ports stay. */\nasync function devStop(input) {\n\tconst executor = await loadExecutor(\"dev stop\");\n\tif (!executor.ok) return executor;\n\treturn executor.value.executeDevStop(input, input.cwd ?? process.cwd());\n}\n//#endregion\nexport { deploy as a, executorLoadFailure as c, devWithDeps as i, toStructured as l, devUrl as n, deployWithDeps as o, dev as r, executionDiagnostics as s, devStop as t };\n\n//# sourceMappingURL=dev-current-BB02pfSh.mjs.map"],"mappings":"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"}
@@ -1 +0,0 @@
1
- {"version":3,"file":"dist-Xd2Pp_-u.mjs","names":[],"sources":["../../../0-framework/1-core/core/dist/index.mjs"],"sourcesContent":["import { _ as service, a as freezeNode, c as isProvisionNeed, d as paramNeed, f as paramSource, g as secretSource, h as secret, i as dependency, l as isSecretSource, m as resource, n as assertAppName, o as isNode, p as provisionNeed, r as ResourceNodeBase, s as isParamSource, t as Load, u as module, v as LoadError, y as RESOURCE_OUT_PORT } from \"./graph-D0ICjejE.mjs\";\nimport { SecretBox, isSecretString } from \"@internal/foundation/secret\";\n//#region src/config.ts\n/**\n* A data-only descriptor of a param's schema for introspection — the\n* validator's vendor tag, never the schema's own `validate`. `configOf`\n* reports it where the old model reported `type: 'string' | 'number'`, so the\n* config surface stays enumerable without leaking a function. Nothing consumes\n* more than the vendor tag yet; a richer projection (e.g. a JSON-Schema export\n* when the vendor offers one) is an additive change if a consumer needs it.\n*/\nfunction projectSchema(schema) {\n\treturn { vendor: schema[\"~standard\"].vendor };\n}\n/**\n* Enumerates every config param the service declares: each input's connection\n* params, then the service's own params. Pure — reads `root.inputs`/`params`\n* directly, executes nothing but the (also pure) schema projection. Deliberately\n* does not go through `Load`: a service's connection-end inputs are legitimately\n* unwired from its own point of view (wiring is an enclosing module's concern),\n* and this introspects one service's declared shape regardless of how — or\n* whether — it composes into a larger graph.\n*/\nfunction configOf(root) {\n\tconst entries = [];\n\tfor (const [input, value] of Object.entries(root.inputs)) {\n\t\tif (typeof value !== \"object\" || value === null) continue;\n\t\tfor (const [name, param] of Object.entries(value.connection.params)) entries.push({\n\t\t\towner: { input },\n\t\t\tname,\n\t\t\tschema: projectSchema(param.schema),\n\t\t\toptional: param.optional === true,\n\t\t\tdefault: param.default\n\t\t});\n\t}\n\tfor (const [name, param] of Object.entries(root.params)) entries.push({\n\t\towner: \"service\",\n\t\tname,\n\t\tschema: projectSchema(param.schema),\n\t\toptional: param.optional === true,\n\t\tdefault: param.default\n\t});\n\treturn entries;\n}\n/**\n* The app's input manifest: every service input binding a `provision()` call\n* supplied (ADR-0042). Pure graph introspection, TARGET-AGNOSTIC — a deploy\n* target's recursive descent classifies the binding's leaves (its preflight\n* verifies each `envSecret` leaf's platform var exists before deploy; the\n* values are provisioned out-of-band).\n*/\nfunction inputManifest(graph) {\n\treturn graph.inputBindings;\n}\n/**\n* The app's param-binding manifest: every param a `provision()` call bound —\n* literal or an opaque, target-defined `ParamSource` — at the address that\n* declared it. The param sibling of `provisionManifest`, for a deploy\n* target's own preflight to consume. Pure graph introspection,\n* TARGET-AGNOSTIC; a param this manifest omits simply falls back to its own\n* `default` at `buildConfig`.\n*/\nfunction paramManifest(graph) {\n\treturn graph.params;\n}\nfunction scalarSchema(name, check) {\n\treturn { \"~standard\": {\n\t\tversion: 1,\n\t\tvendor: \"@prisma/composer\",\n\t\tvalidate: (value) => check(value) ? { value } : { issues: [{ message: `expected ${name}, got ${typeof value}` }] }\n\t} };\n}\nconst stringSchema = scalarSchema(\"string\", (v) => typeof v === \"string\");\nconst numberSchema = scalarSchema(\"number\", (v) => typeof v === \"number\" && Number.isFinite(v));\nfunction withFacets(schema, opts) {\n\treturn {\n\t\tschema,\n\t\t...opts.optional !== void 0 ? { optional: opts.optional } : {},\n\t\t...opts.default !== void 0 ? { default: opts.default } : {},\n\t\t...opts.provision !== void 0 ? { provision: opts.provision } : {}\n\t};\n}\n/** A string-valued param. */\nfunction string(opts = {}) {\n\treturn withFacets(stringSchema, opts);\n}\n/** A number-valued param. */\nfunction number(opts = {}) {\n\treturn withFacets(numberSchema, opts);\n}\n/** A param over any caller-supplied Standard Schema — a structured `jobs`, say. */\nfunction param(schema, opts = {}) {\n\treturn withFacets(schema, opts);\n}\n//#endregion\n//#region src/hydrate.ts\n/**\n* Given a service and a concrete typed Config, hydrate every input\n* (connection.hydrate with its typed value slice). A resource dep and a\n* connection dep hydrate through identical machinery — the loaded client is\n* indistinguishable. The service's own params ride alongside in\n* `config.service`; the node's `load()` merges the two.\n*/\nasync function hydrate(root, config) {\n\tconst deps = {};\n\tfor (const [name, inputNode] of Object.entries(root.inputs)) {\n\t\tconst values = config.inputs[name] ?? {};\n\t\tdeps[name] = await inputNode.connection.hydrate(values);\n\t}\n\treturn deps;\n}\n/**\n* Synchronous hydrate — what the node's `load()` uses so\n* `const { db } = service.load()` reads without `await`. Requires every\n* connection.hydrate to return synchronously; a Promise return is a loud error\n* naming the input (an async client factory must use the async `hydrate` path).\n*/\nfunction hydrateSync(root, config) {\n\tconst deps = {};\n\tfor (const [name, inputNode] of Object.entries(root.inputs)) {\n\t\tconst values = config.inputs[name] ?? {};\n\t\tconst client = inputNode.connection.hydrate(values);\n\t\tif (client instanceof Promise) throw new Error(`Connection hydrate for input \"${name}\" returned a Promise; load() requires a synchronous client factory.`);\n\t\tdeps[name] = client;\n\t}\n\treturn deps;\n}\n//#endregion\nexport { Load, LoadError, RESOURCE_OUT_PORT, ResourceNodeBase, SecretBox, assertAppName, configOf, dependency, freezeNode, hydrate, hydrateSync, inputManifest, isNode, isParamSource, isProvisionNeed, isSecretSource, isSecretString, module, number, param, paramManifest, paramNeed, paramSource, provisionNeed, resource, secret, secretSource, service, string };\n\n//# sourceMappingURL=index.mjs.map"],"mappings":";;;;;;;;;;;AAWA,SAAS,cAAc,QAAQ;CAC9B,OAAO,EAAE,QAAQ,OAAO,YAAY,CAAC,OAAO;AAC7C;;;;;;;;;;AAUA,SAAS,SAAS,MAAM;CACvB,MAAM,UAAU,CAAC;CACjB,KAAK,MAAM,CAAC,OAAO,UAAU,OAAO,QAAQ,KAAK,MAAM,GAAG;EACzD,IAAI,OAAO,UAAU,YAAY,UAAU,MAAM;EACjD,KAAK,MAAM,CAAC,MAAM,UAAU,OAAO,QAAQ,MAAM,WAAW,MAAM,GAAG,QAAQ,KAAK;GACjF,OAAO,EAAE,MAAM;GACf;GACA,QAAQ,cAAc,MAAM,MAAM;GAClC,UAAU,MAAM,aAAa;GAC7B,SAAS,MAAM;EAChB,CAAC;CACF;CACA,KAAK,MAAM,CAAC,MAAM,UAAU,OAAO,QAAQ,KAAK,MAAM,GAAG,QAAQ,KAAK;EACrE,OAAO;EACP;EACA,QAAQ,cAAc,MAAM,MAAM;EAClC,UAAU,MAAM,aAAa;EAC7B,SAAS,MAAM;CAChB,CAAC;CACD,OAAO;AACR;;;;;;;;AAQA,SAAS,cAAc,OAAO;CAC7B,OAAO,MAAM;AACd;;;;;;;;;AASA,SAAS,cAAc,OAAO;CAC7B,OAAO,MAAM;AACd;AACA,SAAS,aAAa,MAAM,OAAO;CAClC,OAAO,EAAE,aAAa;EACrB,SAAS;EACT,QAAQ;EACR,WAAW,UAAU,MAAM,KAAK,IAAI,EAAE,MAAM,IAAI,EAAE,QAAQ,CAAC,EAAE,SAAS,YAAY,KAAK,QAAQ,OAAO,QAAQ,CAAC,EAAE;CAClH,EAAE;AACH;AACA,MAAM,eAAe,aAAa,WAAW,MAAM,OAAO,MAAM,QAAQ;AACxE,MAAM,eAAe,aAAa,WAAW,MAAM,OAAO,MAAM,YAAY,OAAO,SAAS,CAAC,CAAC;AAC9F,SAAS,WAAW,QAAQ,MAAM;CACjC,OAAO;EACN;EACA,GAAG,KAAK,aAAa,KAAK,IAAI,EAAE,UAAU,KAAK,SAAS,IAAI,CAAC;EAC7D,GAAG,KAAK,YAAY,KAAK,IAAI,EAAE,SAAS,KAAK,QAAQ,IAAI,CAAC;EAC1D,GAAG,KAAK,cAAc,KAAK,IAAI,EAAE,WAAW,KAAK,UAAU,IAAI,CAAC;CACjE;AACD;;AAEA,SAAS,OAAO,OAAO,CAAC,GAAG;CAC1B,OAAO,WAAW,cAAc,IAAI;AACrC;;AAEA,SAAS,OAAO,OAAO,CAAC,GAAG;CAC1B,OAAO,WAAW,cAAc,IAAI;AACrC;;AAEA,SAAS,MAAM,QAAQ,OAAO,CAAC,GAAG;CACjC,OAAO,WAAW,QAAQ,IAAI;AAC/B;;;;;;;;AAUA,eAAe,QAAQ,MAAM,QAAQ;CACpC,MAAM,OAAO,CAAC;CACd,KAAK,MAAM,CAAC,MAAM,cAAc,OAAO,QAAQ,KAAK,MAAM,GAAG;EAC5D,MAAM,SAAS,OAAO,OAAO,SAAS,CAAC;EACvC,KAAK,QAAQ,MAAM,UAAU,WAAW,QAAQ,MAAM;CACvD;CACA,OAAO;AACR;;;;;;;AAOA,SAAS,YAAY,MAAM,QAAQ;CAClC,MAAM,OAAO,CAAC;CACd,KAAK,MAAM,CAAC,MAAM,cAAc,OAAO,QAAQ,KAAK,MAAM,GAAG;EAC5D,MAAM,SAAS,OAAO,OAAO,SAAS,CAAC;EACvC,MAAM,SAAS,UAAU,WAAW,QAAQ,MAAM;EAClD,IAAI,kBAAkB,SAAS,MAAM,IAAI,MAAM,iCAAiC,KAAK,oEAAoE;EACzJ,KAAK,QAAQ;CACd;CACA,OAAO;AACR"}
@@ -1 +0,0 @@
1
- {"version":3,"file":"execute-deploy-destroy-DwcoZIks-Cl-tWvo0.mjs","names":["path","fs"],"sources":["../../../0-framework/3-tooling/cli/dist/validate-stage-DxRW3MwT.mjs","../../../0-framework/3-tooling/cli/dist/execute-deploy-destroy-DwcoZIks.mjs"],"sourcesContent":["import { CliStructuredError } from \"@internal/foundation/errors\";\nimport { spawnSync } from \"node:child_process\";\n//#region src/validate-stage.ts\n/** A stage name must be a valid git ref (deploy-cli.md) — checked via `git check-ref-format`, never silently normalized. Runs before anything platform-specific. */\nfunction validateStageName(stage) {\n\tconst result = spawnSync(\"git\", [\"check-ref-format\", `refs/heads/${stage}`], { stdio: \"ignore\" });\n\tif (result.error) throw new CliStructuredError(\"DEPLOY.STAGE_UNVALIDATABLE\", `git is required to validate --stage \"${stage}\" (git check-ref-format): ${result.error.message}.`, { cause: result.error });\n\tif (result.status !== 0) throw new CliStructuredError(\"DEPLOY.STAGE_INVALID\", `Invalid --stage \"${stage}\": must be a valid git ref name (git check-ref-format rejected \"refs/heads/${stage}\").`);\n}\n//#endregion\nexport { validateStageName as t };\n\n//# sourceMappingURL=validate-stage-DxRW3MwT.mjs.map","import { i as noComposerExportMessage } from \"./composer-config-ehUUVHtU.mjs\";\nimport { r as runPipeline } from \"./pipeline-BmWt-Nhb.mjs\";\nimport { t as validateStageName } from \"./validate-stage-DxRW3MwT.mjs\";\nimport { a as readEngineFailureCause, i as readDeploymentSummary, r as engineFailureFilePath, t as DEPLOYMENT_RESULT_FILE_ENV } from \"./deployment-summary-CDHdLtnO.mjs\";\nimport { l as toStructured } from \"./dev-current-BB02pfSh.mjs\";\nimport { a as writeRunReport, i as toRunReport, r as resolveRunReportPath, t as RUN_REPORT_FILE_ENV } from \"./run-report-C2o98uD-.mjs\";\nimport { i as spawnAlchemy, n as alchemyInvocation, r as reproduceCommand } from \"./run-alchemy-Dl_MWw4g.mjs\";\nimport * as fs from \"node:fs\";\nimport * as path from \"node:path\";\nimport { CliStructuredError } from \"@internal/foundation/errors\";\nimport { notOk, ok, okVoid } from \"@internal/foundation/result\";\nimport { randomUUID } from \"node:crypto\";\nimport { containerEnv, preflightEnv, preflightEnvVarName } from \"@internal/core/config\";\n//#region src/generate-stack.ts\n/** Pipeline step 6: writes a regenerated-every-run, independently runnable stack module at `.prisma-composer/alchemy.run.ts`. */\nconst GENERATED_DIR = \".prisma-composer\";\nconst GENERATED_FILE = \"alchemy.run.ts\";\n/** A relative import specifier from `.prisma-composer/alchemy.run.ts` to `target` (posix separators). */\nfunction relativeImportSpecifier(generatedDir, target) {\n\tconst rel = path.relative(generatedDir, target).split(path.sep).join(\"/\");\n\treturn rel.startsWith(\".\") ? rel : `./${rel}`;\n}\nfunction quote(value) {\n\treturn JSON.stringify(value);\n}\nfunction renderBundle(bundle) {\n\treturn `{ dir: ${quote(bundle.dir)}, entry: ${quote(bundle.entry)} }`;\n}\nfunction renderOptions(input) {\n\tconst lines = [];\n\tlines.push(` name: ${quote(input.name)},`);\n\tlines.push(\" bundles: {\");\n\tfor (const [id, bundle] of Object.entries(input.assembled.bundles)) lines.push(` ${quote(id)}: ${renderBundle(bundle)},`);\n\tlines.push(\" },\");\n\tlines.push(\" report: report.deploymentReport,\");\n\treturn lines.join(\"\\n\");\n}\n/** Renders the stack module's source (tests assert on it without touching disk) — uses `//` headers, not a block comment, since a cwd path with a star-slash could close one early. */\nfunction renderStackFile(input) {\n\tconst generatedDir = path.join(input.cwd, GENERATED_DIR);\n\tconst appImport = relativeImportSpecifier(generatedDir, input.entryPath);\n\tconst configImport = relativeImportSpecifier(generatedDir, input.configFile);\n\treturn `// Generated by Composer's deploy and destroy operations — overwritten on every\n// run; do not edit by hand. Runnable from ${quote(input.cwd)} WITH the env the\n// CLI passes its child (the PRISMA_COMPOSER_CONTAINER_*/_PREFLIGHT_* vars —\n// without them lower() refuses because no container is resolved), by the\n// command Composer starts, which a failed run prints:\n//\n// <node> <bin of the alchemy @prisma/composer depends on> deploy ${GENERATED_DIR}/${GENERATED_FILE} --yes --stage <stage>\n//\n// bisects a CLI bug from an Alchemy bug (deploy-cli.md § Implementation decisions).\nimport { lower } from '@prisma/composer/deploy';\nimport * as report from '@prisma/composer/report';\nimport prismaConfig from ${quote(configImport)};\nimport app from ${quote(appImport)};\n\nconst config = prismaConfig.composer;\nif (config === undefined) {\n throw new Error(${quote(noComposerExportMessage(input.configFile))});\n}\n\n// The app's own @prisma/composer may predate the failure recorder.\nreport.captureEngineFailure?.();\n\nexport default lower(app, config, {\n${renderOptions(input)}\n});\n`;\n}\n/** Writes the stack file, returning its absolute path. */\nfunction writeStackFile(input) {\n\tconst generatedDir = path.join(input.cwd, GENERATED_DIR);\n\tfs.mkdirSync(generatedDir, { recursive: true });\n\tconst filePath = path.join(generatedDir, GENERATED_FILE);\n\tfs.writeFileSync(filePath, renderStackFile(input));\n\treturn filePath;\n}\nconst GENERATED_STACK_RELATIVE_PATH = path.join(GENERATED_DIR, GENERATED_FILE);\n//#endregion\n//#region src/operations/execute-deploy-destroy.ts\n/**\n* The deploy/destroy executor — main.ts's pipeline orchestration with argv,\n* console, and exit codes removed: typed inputs in, structured results out.\n* Reached only by lazy import from deploy.ts/destroy.ts — this module's\n* static graph transitively loads alchemy's provider tree, so the control\n* entry must never import it statically.\n*/\nconst ALCHEMY_STATE_DIR = \".alchemy\";\n/** Destroy guardrail (moved from main.ts): true when `<cwd>/.alchemy` is missing or empty — likely wrong directory or nothing deployed yet. */\nfunction hasNoLocalDeployState(cwd) {\n\tconst stateDir = path.join(cwd, ALCHEMY_STATE_DIR);\n\treturn !(fs.existsSync(stateDir) && fs.readdirSync(stateDir).length > 0);\n}\n/**\n* Times each deploy step for the host's `onEvent`. A step still open when the\n* run fails is closed as failed, innermost first. A host `onEvent` that throws\n* is the host's bug and cannot fail the deploy.\n*/\nfunction deploySteps(onEvent) {\n\tconst open = /* @__PURE__ */ new Map();\n\tconst keyOf = (step) => step.name === \"assemble-service\" ? `${step.name}:${step.address}` : step.name;\n\tconst emit = (event) => {\n\t\ttry {\n\t\t\tonEvent?.(event);\n\t\t} catch {}\n\t};\n\tconst finish = (step, outcome, data) => {\n\t\tconst entry = open.get(keyOf(step));\n\t\tif (entry === void 0) return;\n\t\topen.delete(keyOf(step));\n\t\tconst durationMs = Math.round(performance.now() - entry.startedAt);\n\t\temit({\n\t\t\tkind: \"step-finished\",\n\t\t\tstep,\n\t\t\toutcome,\n\t\t\tdurationMs,\n\t\t\tdata\n\t\t});\n\t};\n\treturn {\n\t\tstart(step) {\n\t\t\topen.set(keyOf(step), {\n\t\t\t\tstep,\n\t\t\t\tstartedAt: performance.now()\n\t\t\t});\n\t\t\temit({\n\t\t\t\tkind: \"step-started\",\n\t\t\t\tstep\n\t\t\t});\n\t\t},\n\t\tfinish(step, data) {\n\t\t\tfinish(step, \"ok\", data);\n\t\t},\n\t\tfail(step) {\n\t\t\tfinish(step, \"failed\");\n\t\t},\n\t\tfailOpen() {\n\t\t\tfor (const { step } of [...open.values()].reverse()) finish(step, \"failed\");\n\t\t}\n\t};\n}\nasync function executeDeploy(input, deps, cwd) {\n\tconst outcome = await runStackPipeline(\"deploy\", {\n\t\tentry: input.entry,\n\t\tconfig: input.config,\n\t\tname: input.name,\n\t\tstage: input.stage,\n\t\tcwd,\n\t\tonEvent: void 0,\n\t\tdeps,\n\t\treportId: input.reportId,\n\t\treportPath: resolveRunReportPath(input.reportPath, process.env[RUN_REPORT_FILE_ENV], cwd),\n\t\tsteps: deploySteps(input.onEvent)\n\t});\n\tif (!outcome.ok) return outcome;\n\treturn ok({ summary: outcome.value });\n}\nasync function executeDestroy(input, deps, cwd) {\n\tconst outcome = await runStackPipeline(\"destroy\", {\n\t\tentry: input.entry,\n\t\tconfig: input.config,\n\t\tname: input.name,\n\t\tstage: input.target.kind === \"stage\" ? input.target.stage : void 0,\n\t\tcwd,\n\t\tonEvent: input.onEvent,\n\t\tdeps,\n\t\treportId: void 0,\n\t\treportPath: void 0,\n\t\tsteps: deploySteps(void 0)\n\t});\n\tif (!outcome.ok) return outcome;\n\treturn okVoid();\n}\n/**\n* Opens a session per extension that declares a reporter. A `begin` that\n* throws costs that extension its reporting and nothing else — the deploy\n* has not started, and refusing to run it because an observer failed would\n* invert the relationship.\n*/\nasync function beginReporters(extensions, context) {\n\treturn (await Promise.all(extensions.map(async (extension) => {\n\t\tif (extension.reporter === void 0) return void 0;\n\t\ttry {\n\t\t\tconst reporter = await extension.reporter.begin(context);\n\t\t\treturn reporter === void 0 ? void 0 : {\n\t\t\t\textensionId: extension.id,\n\t\t\t\treporter\n\t\t\t};\n\t\t} catch (error) {\n\t\t\tconst detail = error instanceof Error ? error.message : String(error);\n\t\t\tconsole.warn(`\\nCould not start deploy reporting for ${extension.id}: ${detail}`);\n\t\t\treturn;\n\t\t}\n\t}))).filter((entry) => entry !== void 0);\n}\n/** Hands each session its own extension's resolved container, so it can attach the run to what that container names. */\nasync function attachReporters(reporters, containers) {\n\tawait Promise.all(reporters.map(async ({ extensionId, reporter }) => {\n\t\ttry {\n\t\t\tawait reporter.attach({ container: containers.get(extensionId) });\n\t\t} catch (error) {\n\t\t\tconst detail = error instanceof Error ? error.message : String(error);\n\t\t\tconsole.warn(`\\nCould not attach this deploy to its project for ${extensionId}: ${detail}`);\n\t\t}\n\t}));\n}\n/** Every session's contribution to the alchemy child's environment, so reporting that happens inside the apply can find the run. */\nfunction reporterChildEnv(reporters) {\n\tconst env = {};\n\tfor (const { extensionId, reporter } of reporters) try {\n\t\tObject.assign(env, reporter.childEnv());\n\t} catch (error) {\n\t\tconst detail = error instanceof Error ? error.message : String(error);\n\t\tconsole.warn(`\\nCould not pass deploy reporting into the apply for ${extensionId}: ${detail}`);\n\t}\n\treturn env;\n}\n/** `failingStep` is capped at 500 by the platform and `errorMessage` at 5000; truncating here keeps a long message from costing the whole report. */\nfunction truncate(value, limit) {\n\treturn value.length <= limit ? value : `${value.slice(0, limit - 1)}…`;\n}\n/** An interrupted converge (the engine settled a Ctrl-C) — reported as `cancelled`, never as `failed`. */\nfunction wasInterrupted(failure) {\n\treturn typeof failure.meta?.[\"signal\"] === \"string\";\n}\n/**\n* Ends every reporting session, whatever the run did. Sessions never reject\n* by contract, but a buggy one must not turn a converged deploy into a\n* failure — so this swallows anyway, and reports each session independently\n* so one bad implementation cannot silence another.\n*/\nasync function finishReporters(reporters, outcome) {\n\tconst entities = outcome.summary?.nodes.flatMap((node) => node.entities) ?? [];\n\tawait Promise.all(reporters.map(async ({ reporter }) => {\n\t\ttry {\n\t\t\tawait reporter.finish({\n\t\t\t\tok: outcome.ok,\n\t\t\t\tcancelled: outcome.cancelled,\n\t\t\t\tfailingStep: outcome.code === void 0 ? void 0 : truncate(outcome.code, 500),\n\t\t\t\terrorMessage: outcome.message === void 0 ? void 0 : truncate(outcome.message, 5e3),\n\t\t\t\tentities\n\t\t\t});\n\t\t} catch (error) {\n\t\t\tconst detail = error instanceof Error ? error.message : String(error);\n\t\t\tconsole.warn(`\\nCould not report this deploy's outcome: ${detail}`);\n\t\t}\n\t}));\n}\n/**\n* Owns the reporting sessions around the pipeline: the inner run opens them\n* once it knows which extensions are configured, and this closes them on\n* every exit path — a returned failure, a success, or a thrown defect — as\n* the `record` step, which also writes the run report.\n* Nothing here can change what the pipeline returns.\n*/\nasync function runStackPipeline(action, opts) {\n\tconst reporters = [];\n\tlet outcome;\n\ttry {\n\t\toutcome = await runStackPipelineInner(action, opts, reporters);\n\t} catch (error) {\n\t\topts.steps.failOpen();\n\t\topts.steps.start({ name: \"record\" });\n\t\tawait finishReporters(reporters, {\n\t\t\tok: false,\n\t\t\tcancelled: false,\n\t\t\tcode: \"DEPLOY.UNEXPECTED\",\n\t\t\tmessage: error instanceof Error ? error.message : String(error)\n\t\t});\n\t\topts.steps.finish({ name: \"record\" });\n\t\tthrow error;\n\t}\n\tif (!outcome.ok) opts.steps.failOpen();\n\topts.steps.start({ name: \"record\" });\n\tawait finishReporters(reporters, outcome.ok ? {\n\t\tok: true,\n\t\tcancelled: false,\n\t\tsummary: outcome.value\n\t} : {\n\t\tok: false,\n\t\tcancelled: wasInterrupted(outcome.failure),\n\t\tcode: outcome.failure.code,\n\t\tmessage: outcome.failure.message\n\t});\n\tif (opts.reportPath === void 0 || writeRunReport(opts.reportPath, toRunReport({\n\t\tsummary: outcome.ok ? outcome.value : void 0,\n\t\tstage: opts.stage,\n\t\tfailure: outcome.ok ? void 0 : {\n\t\t\tcode: outcome.failure.code,\n\t\t\tmessage: outcome.failure.message\n\t\t}\n\t}))) opts.steps.finish({ name: \"record\" });\n\telse opts.steps.fail({ name: \"record\" });\n\treturn outcome;\n}\n/** The pipeline both actions share: validate, resolve containers, preflight,\n* write the stack file, run alchemy against it, then the destroy-only\n* teardown/removal suffix. The value is only ever a summary for deploy. */\nasync function runStackPipelineInner(action, opts, reporters) {\n\tconst { entry, config: composerConfig, name, stage, cwd, onEvent, deps, steps } = opts;\n\tsteps.start({ name: \"prepare\" });\n\tif (stage !== void 0) try {\n\t\tvalidateStageName(stage);\n\t} catch (error) {\n\t\tif (CliStructuredError.is(error)) return notOk(error);\n\t\tthrow error;\n\t}\n\tif (action === \"destroy\" && hasNoLocalDeployState(cwd)) onEvent?.({\n\t\tkind: \"no-local-deploy-state\",\n\t\tcwd\n\t});\n\tlet pipeline;\n\tlet containers;\n\tlet alchemyStage;\n\tconst preflightPayloads = /* @__PURE__ */ new Map();\n\tlet preflightTransportEnv = {};\n\ttry {\n\t\tpipeline = await runPipeline(entry, name, cwd, composerConfig, {\n\t\t\trunAssembler: deps.runAssembler,\n\t\t\tonEvent: (event) => {\n\t\t\t\tswitch (event.kind) {\n\t\t\t\t\tcase \"loaded\":\n\t\t\t\t\t\tsteps.finish({ name: \"prepare\" });\n\t\t\t\t\t\tsteps.start({ name: \"assemble\" });\n\t\t\t\t\t\treturn;\n\t\t\t\t\tcase \"service-started\":\n\t\t\t\t\t\tsteps.start({\n\t\t\t\t\t\t\tname: \"assemble-service\",\n\t\t\t\t\t\t\taddress: event.address\n\t\t\t\t\t\t});\n\t\t\t\t\t\treturn;\n\t\t\t\t\tcase \"service-assembled\":\n\t\t\t\t\t\tsteps.finish({\n\t\t\t\t\t\t\tname: \"assemble-service\",\n\t\t\t\t\t\t\taddress: event.address\n\t\t\t\t\t\t}, event.data);\n\t\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t}\n\t\t}, action === \"destroy\" ? (error) => new CliStructuredError(\"DEPLOY.BUILD_REQUIRED\", error.message, {\n\t\t\twhy: \"destroy evaluates the same stack program as deploy, which packages the built artifacts — so the app must be built first.\",\n\t\t\tfix: \"Run the build, then retry the destroy.\",\n\t\t\tcause: error\n\t\t}) : void 0);\n\t\tsteps.finish({ name: \"assemble\" });\n\t\tconst { graph, name: resolvedName } = pipeline;\n\t\tconst config = pipeline.configSource.value;\n\t\tsteps.start({ name: \"connect\" });\n\t\tif (action === \"deploy\") reporters.push(...await beginReporters(config.extensions, {\n\t\t\tappName: resolvedName,\n\t\t\tgraph,\n\t\t\tstage,\n\t\t\tcwd,\n\t\t\treportId: opts.reportId,\n\t\t\tcredentials: deps.credentials\n\t\t}));\n\t\tcontainers = /* @__PURE__ */ new Map();\n\t\tfor (const extension of config.extensions) {\n\t\t\tif (extension.container === void 0) continue;\n\t\t\ttry {\n\t\t\t\tif (action === \"deploy\") containers.set(extension.id, await extension.container.ensure({\n\t\t\t\t\tappName: resolvedName,\n\t\t\t\t\tstage\n\t\t\t\t}, deps.credentials));\n\t\t\t\telse {\n\t\t\t\t\tconst instance = await extension.container.locate({\n\t\t\t\t\t\tappName: resolvedName,\n\t\t\t\t\t\tstage\n\t\t\t\t\t}, deps.credentials);\n\t\t\t\t\tif (instance === void 0) throw new CliStructuredError(\"DEPLOY.TARGET_NOT_FOUND\", `Nothing deployed for ${resolvedName}${stage !== void 0 ? `/${stage}` : \"\"}.`, { fix: \"Deploy it first.\" });\n\t\t\t\t\tcontainers.set(extension.id, instance);\n\t\t\t\t}\n\t\t\t} catch (error) {\n\t\t\t\tthrow toStructured(\"DEPLOY.CONTAINER_FAILED\", error);\n\t\t\t}\n\t\t}\n\t\tawait attachReporters(reporters, containers);\n\t\tconst pinnedStage = containers.get(config.state.extension)?.alchemyStage ?? stage;\n\t\tif (pinnedStage === void 0) throw new CliStructuredError(\"DEPLOY.SCOPE_MISSING\", \"The configured deploy target supplied no deploy scope (its container defines no alchemyStage), so Alchemy has no stage to run under.\", { fix: action === \"deploy\" ? \"Pass --stage <name> to choose the deploy scope explicitly.\" : \"Destroying production needs a target whose container supplies the production deploy scope.\" });\n\t\talchemyStage = pinnedStage;\n\t\tsteps.finish({ name: \"connect\" });\n\t\tif (action === \"deploy\") {\n\t\t\tsteps.start({ name: \"preflight\" });\n\t\t\tconst counts = {};\n\t\t\tconst report = (reported) => {\n\t\t\t\tfor (const [key, value] of Object.entries(reported)) counts[key] = (counts[key] ?? 0) + value;\n\t\t\t};\n\t\t\tfor (const extension of config.extensions) {\n\t\t\t\tif (extension.preflight === void 0) continue;\n\t\t\t\ttry {\n\t\t\t\t\tconst payload = await extension.preflight({\n\t\t\t\t\t\tgraph,\n\t\t\t\t\t\tcontainer: containers.get(extension.id),\n\t\t\t\t\t\tstage,\n\t\t\t\t\t\tcredentials: deps.credentials,\n\t\t\t\t\t\treport\n\t\t\t\t\t});\n\t\t\t\t\tif (payload !== void 0) preflightPayloads.set(extension.id, payload);\n\t\t\t\t} catch (error) {\n\t\t\t\t\tthrow toStructured(\"DEPLOY.PREFLIGHT_FAILED\", error);\n\t\t\t\t}\n\t\t\t}\n\t\t\ttry {\n\t\t\t\tpreflightTransportEnv = preflightEnv(preflightPayloads);\n\t\t\t} catch (error) {\n\t\t\t\tthrow toStructured(\"DEPLOY.PREFLIGHT_FAILED\", error);\n\t\t\t}\n\t\t\tsteps.finish({ name: \"preflight\" }, counts);\n\t\t}\n\t\tfor (const extension of config.extensions) preflightTransportEnv[preflightEnvVarName(extension.id)] ??= \"\";\n\t} catch (error) {\n\t\tif (CliStructuredError.is(error)) return notOk(error);\n\t\tthrow error;\n\t}\n\tlet stackPath;\n\tconst resultFilePath = path.join(cwd, \".prisma-composer\", `deployment-result-${String(process.pid)}-${randomUUID()}.json`);\n\ttry {\n\t\ttry {\n\t\t\tstackPath = writeStackFile({\n\t\t\t\tentryPath: pipeline.entryModule.path,\n\t\t\t\tcwd,\n\t\t\t\tconfigFile: pipeline.configSource.file,\n\t\t\t\tname: pipeline.name,\n\t\t\t\tassembled: pipeline.assembled\n\t\t\t});\n\t\t} catch (error) {\n\t\t\treturn notOk(toStructured(\"DEPLOY.STACK_WRITE_FAILED\", error));\n\t\t}\n\t\tconst invocation = alchemyInvocation({\n\t\t\tcommand: action,\n\t\t\tstackFileRelativePath: GENERATED_STACK_RELATIVE_PATH,\n\t\t\tcwd,\n\t\t\tstage: alchemyStage,\n\t\t\tcontainerEnv: containerEnv(containers),\n\t\t\tpreflightEnv: preflightTransportEnv,\n\t\t\tenv: {\n\t\t\t\t...reporterChildEnv(reporters),\n\t\t\t\t[DEPLOYMENT_RESULT_FILE_ENV]: resultFilePath\n\t\t\t}\n\t\t});\n\t\tsteps.start({ name: \"apply\" });\n\t\tlet outcome;\n\t\ttry {\n\t\t\toutcome = await (deps.alchemy ?? spawnAlchemy)(invocation);\n\t\t} catch (error) {\n\t\t\tif (CliStructuredError.is(error)) return notOk(error);\n\t\t\treturn notOk(new CliStructuredError(\"DEPLOY.ENGINE_FAILED\", error instanceof Error ? error.message : String(error), {\n\t\t\t\tcause: error,\n\t\t\t\tmeta: { diagnostics: {\n\t\t\t\t\texitCode: void 0,\n\t\t\t\t\tstackFilePath: stackPath,\n\t\t\t\t\treproduceCommand: reproduceCommand(invocation),\n\t\t\t\t\tcwd\n\t\t\t\t} }\n\t\t\t}));\n\t\t}\n\t\tconst reproduce = reproduceCommand(invocation, outcome);\n\t\tif (outcome.signal !== null) return notOk(new CliStructuredError(\"DEPLOY.ENGINE_FAILED\", `alchemy ${action} was interrupted by ${outcome.signal}.`, { meta: {\n\t\t\tsignal: outcome.signal,\n\t\t\tdiagnostics: {\n\t\t\t\texitCode: void 0,\n\t\t\t\tsignal: outcome.signal,\n\t\t\t\tstackFilePath: stackPath,\n\t\t\t\treproduceCommand: reproduce,\n\t\t\t\tcwd\n\t\t\t}\n\t\t} }));\n\t\tconst status = outcome.exitCode ?? 1;\n\t\tif (status !== 0) {\n\t\t\tconst engineCause = readEngineFailureCause(resultFilePath);\n\t\t\tconst withCause = (sentence) => engineCause === void 0 ? sentence : `${sentence}\\n${engineCause}`;\n\t\t\treturn notOk(new CliStructuredError(\"DEPLOY.ENGINE_FAILED\", withCause(`alchemy ${action} exited with status ${status}.`), { meta: {\n\t\t\t\texitCode: status,\n\t\t\t\t...engineCause !== void 0 ? { engineCause } : {},\n\t\t\t\tdiagnostics: {\n\t\t\t\t\texitCode: status,\n\t\t\t\t\tstackFilePath: stackPath,\n\t\t\t\t\treproduceCommand: reproduce,\n\t\t\t\t\tcwd\n\t\t\t\t}\n\t\t\t} }));\n\t\t}\n\t\tsteps.finish({ name: \"apply\" });\n\t\ttry {\n\t\t\tif (action === \"destroy\") {\n\t\t\t\tfor (const extension of pipeline.configSource.value.extensions) {\n\t\t\t\t\tif (extension.teardown === void 0) continue;\n\t\t\t\t\ttry {\n\t\t\t\t\t\tawait extension.teardown({\n\t\t\t\t\t\t\tcontainer: containers.get(extension.id),\n\t\t\t\t\t\t\tstage\n\t\t\t\t\t\t});\n\t\t\t\t\t} catch (error) {\n\t\t\t\t\t\tthrow toStructured(\"DEPLOY.TEARDOWN_FAILED\", error);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tfor (const extension of pipeline.configSource.value.extensions) {\n\t\t\t\t\tif (extension.container === void 0) continue;\n\t\t\t\t\tconst instance = containers.get(extension.id);\n\t\t\t\t\tif (instance === void 0) continue;\n\t\t\t\t\ttry {\n\t\t\t\t\t\tawait extension.container.remove(instance, deps.credentials);\n\t\t\t\t\t} catch (error) {\n\t\t\t\t\t\tthrow toStructured(\"DEPLOY.CONTAINER_REMOVE_FAILED\", error);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t} catch (error) {\n\t\t\tif (CliStructuredError.is(error)) return notOk(error);\n\t\t\tthrow error;\n\t\t}\n\t\tif (action === \"deploy\") return ok(readDeploymentSummary(resultFilePath));\n\t\treturn ok(void 0);\n\t} finally {\n\t\ttry {\n\t\t\tfs.rmSync(resultFilePath, { force: true });\n\t\t\tfs.rmSync(engineFailureFilePath(resultFilePath), { force: true });\n\t\t} catch {}\n\t}\n}\n//#endregion\nexport { executeDeploy, executeDestroy };\n\n//# sourceMappingURL=execute-deploy-destroy-DwcoZIks.mjs.map"],"mappings":"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"}