@prisma/composer 0.2.0 → 0.3.0-dev.10

package/dist/{graph-types-BgT9UEdm-Bz-_OcJH.d.mts → graph-types-C3FOaaXm-C6_rGzfn.d.mts}

@@ -1,30 +1,5 @@
 import { StandardSchemaV1 } from "@standard-schema/spec";
-//#region ../../0-framework/0-foundation/foundation/dist/secret.d.mts
-//#region src/secret.d.ts
-/**
- * A value wrapper that redacts everywhere except the one explicit reader,
- * `expose()`. Sensitivity is carried by the TYPE (`SecretBox<T>`), not a flag a
- * sink must remember to check: `String(box)`, template interpolation,
- * `JSON.stringify`, and `console.log`/`util.inspect` all print `[REDACTED]`, so
- * a secret can't leak through an accidental log or serialization.
- *
- * Shape matches the platform's own `secrecy` type (pdp-control-plane). The class
- * is nominal enough on its own — no phantom brand.
- */
-declare class SecretBox<T> {
-  #private;
-  constructor(value: T);
-  /** The sole explicit door to the wrapped value. */
-  expose(): T;
-  toString(): string;
-  toJSON(): string;
-  valueOf(): string;
-  [Symbol.toPrimitive](): string;
-}
-/** The common case: a secret string. */
-type SecretString = SecretBox<string>;
-//#endregion
-//#region ../../0-framework/1-core/core/dist/graph-types-BgT9UEdm.d.mts
+//#region ../../0-framework/1-core/core/dist/graph-types-C3FOaaXm.d.mts
 //#region src/config.d.ts
 /**
  * A declared config param — pure data: a caller-owned Standard Schema
@@ -99,18 +74,18 @@ interface Config {
  */
 declare function configOf(root: ServiceNode): readonly ConfigDeclaration[];
 /**
- * The app's provision manifest: every secret binding the root resolved across
- * the graph (ADR-0029) — an opaque, target-defined source per service secret
- * slot; a deploy target's preflight reads its own payload. Pure graph
- * introspection, TARGET-AGNOSTIC — the target consumes it to verify each secret
- * exists on the platform before deploy. The values are provisioned out-of-band.
+ * The app's input manifest: every service input binding a `provision()` call
+ * supplied (ADR-0042). Pure graph introspection, TARGET-AGNOSTIC — a deploy
+ * target's recursive descent classifies the binding's leaves (its preflight
+ * verifies each `envSecret` leaf's platform var exists before deploy; the
+ * values are provisioned out-of-band).
  */
-declare function provisionManifest(graph: Graph): readonly SecretBinding[];
+declare function inputManifest(graph: Graph): readonly ServiceInputBinding[];
 /**
  * The app's param-binding manifest: every param a `provision()` call bound —
  * literal or an opaque, target-defined `ParamSource` — at the address that
  * declared it. The param sibling of `provisionManifest`, for a deploy
- * target's own preflight to consume (D2). Pure graph introspection,
+ * target's own preflight to consume. Pure graph introspection,
  * TARGET-AGNOSTIC; a param this manifest omits simply falls back to its own
  * `default` at `buildConfig`.
  */
@@ -152,7 +127,7 @@ interface SecretNeed {
   readonly [SECRET_NEED]: true;
   readonly kind: 'secret';
 }
-/** A service/module's secret slots: name → the need it declares. */
+/** A module's secret-forwarding slots: name → the need it declares. */
 type Secrets = Record<string, SecretNeed>;
 /** The wiring value bound to a secret slot: a target-defined payload core forwards but never inspects. A target (e.g. @prisma/composer-prisma-cloud's `envSecret`) builds one via `secretSource()`. */
 interface SecretSource<T = unknown> {
@@ -160,10 +135,8 @@ interface SecretSource<T = unknown> {
   /** Target-defined. Core never reads this; the target that authored the source reads it back. */
   readonly payload: T;
 }
-/** What `provision(node, { secrets })` supplies: one source per declared secret slot. */
+/** What `provision(moduleChild, { secrets })` supplies: one source per declared secret slot. */
 type SecretBindings<S extends Secrets> = { [K in keyof S]: SecretSource; };
-/** What `secrets()` returns: one redacting SecretBox per declared slot. */
-type SecretValues<S extends Secrets> = { readonly [K in keyof S]: SecretString; };
 /** Declares a secret NEED. Nameless — the platform name is bound at the root via `envSecret`. */
 declare function secret(): SecretNeed;
 /** Builds an opaque secret source from a target-defined payload — the SPI a deploy target's own source constructor (e.g. `envSecret`) calls. Core forwards the source and never inspects the payload. */
@@ -208,6 +181,19 @@ declare function paramNeed(): ParamNeed;
 type ParamBindings<P extends Params> = { readonly [K in keyof P]?: StandardSchemaV1.InferOutput<P[K]['schema']> | ParamSource; };
 /** What `provision(moduleChild, { params })` accepts per declared `ParamNeed`: a `ParamSource` only — a need carries no schema to validate a literal against. */
 type ParamNeedBindings<PN extends ParamNeeds> = { readonly [K in keyof PN]?: ParamSource; };
+/**
+ * What `provision(service, { input })` accepts (ADR-0042): a plain object
+ * mirroring the service's input schema, whose leaves are literals,
+ * `envParam(...)` sources, or `envSecret(...)` sources. Deliberately a
+ * best-effort structural type: the framework never introspects a Standard
+ * Schema, so the binding's exact shape cannot be derived from it — deploy-time
+ * validation of the resolved binding is the real check.
+ */
+type InputBinding = string | number | boolean | null | ParamSource | SecretSource | readonly InputBinding[] | {
+  readonly [key: string]: InputBinding;
+};
+/** What `input()` returns: the schema's validated output type; `never` on a service that declares no input schema. */
+type InputValueOf<I> = I extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<I> : never;
 /** Opaque `Contract<any, any>` bound shared by every node/port type that doesn't care which contract. */
 type AnyContract = Contract<any, any>;
 /** How a service's app becomes a runnable artifact — the build descriptor's routing key (`extension`/`type`) plus paths resolved relative to the authoring module. */
@@ -242,7 +228,7 @@ interface ResourceNode<C extends AnyContract = AnyContract> {
  * inert until run, and carries NO runtime behavior — an extension's factory
  * wraps it into a runnable/loadable shape (see RunnableServiceNode).
  */
-interface ServiceNode<D extends Deps = Deps, P extends Params = Params, E extends Expose = Expose, S extends Secrets = Secrets> {
+interface ServiceNode<D extends Deps = Deps, P extends Params = Params, E extends Expose = Expose, I extends StandardSchemaV1 | undefined = StandardSchemaV1 | undefined> {
   readonly [NODE]: true;
   readonly kind: 'service';
   /** Human-readable, given at authoring — logs/diagnostics only; identity remains the deploy address (ADR-0006). */
@@ -251,10 +237,10 @@ interface ServiceNode<D extends Deps = Deps, P extends Params = Params, E extend
   readonly extension: string;
   readonly type: string;
   readonly inputs: D;
-  /** Service-level config declarations (e.g. port). */
+  /** Extension-reserved config declarations (e.g. compute's `port`) — never user-authored (ADR-0042). */
   readonly params: P;
-  /** Declared secret input slots (authored as `secrets`) — bound at the root via `envSecret`, read via the `secrets()` accessor (ADR-0029). Named `secretSlots` on the node so the data field does not collide with that accessor. */
-  readonly secretSlots: S;
+  /** The service's whole incoming configuration as ONE Standard Schema (authored as `input`, ADR-0042), or `undefined` when it takes none. The framework never introspects it — it only calls `~standard.validate`. Named `inputSchema` on the node so the data field does not collide with the `input()` accessor. */
+  readonly inputSchema: I;
   /** How the app's entry is built + assembled. */
   readonly build: BuildAdapter;
   /** Named output ports this service exposes — the Contracts a consumer's `rpc(contract)` can require. `undefined` when the service exposes nothing. */
@@ -262,15 +248,14 @@ interface ServiceNode<D extends Deps = Deps, P extends Params = Params, E extend
 }
 /**
  * The extension's runnable/loadable service node. `run` boots the app after
- * deserializing its Config; `load`/`config` then read deps/params back out
- * (kept separate per ADR-0021 so a same-named dep and param never collide).
+ * deserializing its environment; `load` reads the hydrated deps and `input`
+ * the validated, typed input object (ADR-0042).
  */
-interface RunnableServiceNode<D extends Deps = Deps, P extends Params = Params, E extends Expose = Expose, S extends Secrets = Secrets> extends ServiceNode<D, P, E, S> {
+interface RunnableServiceNode<D extends Deps = Deps, P extends Params = Params, E extends Expose = Expose, I extends StandardSchemaV1 | undefined = StandardSchemaV1 | undefined> extends ServiceNode<D, P, E, I> {
   run(address: string, boot: () => Promise<unknown>): Promise<unknown>;
   load(): HydratedDeps<D>;
-  config(): Values<P>;
-  /** The service's secrets, each a redacting SecretBox — a third accessor beside load()/config() (ADR-0021). */
-  secrets(): SecretValues<S>;
+  /** The service's validated input — one typed object, secrets as redacting `SecretString` boxes (ADR-0042). */
+  input(): InputValueOf<I>;
 }
 /**
  * A service's dependency slot. At Load the enclosing module wires a
@@ -349,19 +334,36 @@ type ReqOf<DE> = DE extends DependencyEnd<any, infer Req> ? Req : never;
  */
 type DepBindings<D extends Deps> = { [K in keyof D]: NoInfer<ReqOf<D[K]>> | InputRef<D[K]>; };
 /**
- * `provision`'s trailing options: an explicit `id` (default: the node's own
- * `name`) plus, for a node that declares dependency slots, the `deps` that
- * satisfy them. `deps` is required exactly when the node has slots —
- * `[keyof D] extends [never]` is the "no slots" test — so a dependency can
- * never be left unwired at compile time. The whole object is therefore
- * optional for a slot-less node and required for one with slots. `params` is
- * always optional — a bound value overrides `param.default`, but a param may
- * fall back to its default (or be `optional`) instead, unlike `deps`/`secrets`.
- * `PB` is the params-binding map appropriate to the target: `ParamBindings<P>`
- * for a service's real, schema-bearing params; `ParamNeedBindings<PN>` for a
- * child module's nameless forwarding slots.
+ * A SERVICE provision's trailing options: an explicit `id` (default: the
+ * node's own `name`); `deps` required exactly when the node declares
+ * dependency slots (`[keyof D] extends [never]` is the "no slots" test);
+ * `input` required exactly when the node declares an input schema (ADR-0042).
+ * `params` is always optional — it binds only extension-reserved params (e.g.
+ * compute's `port`), which fall back to their own defaults.
+ */
+type ServiceProvisionArgs<D extends Deps, I extends StandardSchemaV1 | undefined, PB> = [keyof D] extends [never] ? I extends undefined ? [opts?: {
+  id?: string;
+  params?: PB;
+}] : [opts: {
+  id?: string;
+  input: InputBinding;
+  params?: PB;
+}] : I extends undefined ? [opts: {
+  id?: string;
+  deps: DepBindings<D>;
+  params?: PB;
+}] : [opts: {
+  id?: string;
+  deps: DepBindings<D>;
+  input: InputBinding;
+  params?: PB;
+}];
+/**
+ * A child-MODULE provision's trailing options: `deps`/`secrets` required
+ * exactly when the module declares the slots; a declared param-forwarding
+ * slot may be bound to a `ParamSource`.
  */
-type ProvisionArgs<D extends Deps, S extends Secrets, PB> = [keyof D] extends [never] ? [keyof S] extends [never] ? [opts?: {
+type ModuleProvisionArgs<D extends Deps, S extends Secrets, PB> = [keyof D] extends [never] ? [keyof S] extends [never] ? [opts?: {
   id?: string;
   params?: PB;
 }] : [opts: {
@@ -385,22 +387,22 @@ interface ModuleBuilder {
   }): {
     readonly id: string;
   } & RefPort<C>;
-  /** Registers an owned service; its id defaults to the node's `name`; `deps`/`secrets` are required iff it declares them; a declared param may be bound (literal or `ParamSource`), overriding its default. */
-  provision<D extends Deps, P extends Params, E extends Expose, S extends Secrets>(service: ServiceNode<D, P, E, S>, ...args: ProvisionArgs<D, S, ParamBindings<P>>): ProvisionedRef<E>;
+  /** Registers an owned service; its id defaults to the node's `name`; `deps`/`input` are required iff it declares them; a reserved param may be bound (literal or `ParamSource`), overriding its default. */
+  provision<D extends Deps, P extends Params, E extends Expose, I extends StandardSchemaV1 | undefined>(service: ServiceNode<D, P, E, I>, ...args: ServiceProvisionArgs<D, I, ParamBindings<P>>): ProvisionedRef<E>;
   /**
-   * The service call with `deps`/`secrets` spelled out. `ProvisionArgs` above
-   * cannot resolve while `D`/`S` are still unbound type parameters — a generic
-   * wrapper like `cron()` provisioning a caller-supplied service — so that call
-   * site resolves to this concrete overload instead.
+   * The service call with `deps`/`input` spelled out. `ServiceProvisionArgs`
+   * above cannot resolve while `D`/`I` are still unbound type parameters — a
+   * generic wrapper like `cron()` provisioning a caller-supplied service — so
+   * that call site resolves to this concrete overload instead.
    */
-  provision<D extends Deps, P extends Params, E extends Expose, S extends Secrets>(service: ServiceNode<D, P, E, S>, opts: {
+  provision<D extends Deps, P extends Params, E extends Expose, I extends StandardSchemaV1 | undefined>(service: ServiceNode<D, P, E, I>, opts: {
     id?: string;
     deps: DepBindings<D>;
-    secrets?: SecretBindings<S>;
+    input?: InputBinding;
     params?: ParamBindings<P>;
   }): ProvisionedRef<E>;
   /** Registers an owned child module; its id defaults to the node's `name`; `deps`/`secrets` are required iff it declares them; a declared param-forwarding slot may be bound to a `ParamSource`. */
-  provision<D extends Deps, E extends Expose, S extends Secrets, PN extends ParamNeeds>(child: ModuleNode<D, E, S, PN>, ...args: ProvisionArgs<D, S, ParamNeedBindings<PN>>): ProvisionedRef<E>;
+  provision<D extends Deps, E extends Expose, S extends Secrets, PN extends ParamNeeds>(child: ModuleNode<D, E, S, PN>, ...args: ModuleProvisionArgs<D, S, ParamNeedBindings<PN>>): ProvisionedRef<E>;
   /** The child-module call with `deps`/`secrets` spelled out — the same generic-wrapper escape as the service overload above. */
   provision<D extends Deps, E extends Expose, S extends Secrets, PN extends ParamNeeds>(child: ModuleNode<D, E, S, PN>, opts: {
     id?: string;
@@ -451,18 +453,19 @@ declare function resource<C extends AnyContract>(def: {
 }): ResourceNode<C>;
 /**
  * Constructs a branded, frozen Service node — declarations only (inputs,
- * params, build adapter, and the ports it exposes). Pure; carries no runtime behavior.
+ * params, the input schema, build adapter, and the ports it exposes). Pure;
+ * carries no runtime behavior.
  */
-declare function service<D extends Deps, P extends Params, E extends Expose = Record<never, never>, S extends Secrets = Record<never, never>>(def: {
+declare function service<D extends Deps, P extends Params, E extends Expose = Record<never, never>, I extends StandardSchemaV1 | undefined = undefined>(def: {
   name: string;
   extension: string;
   type: string;
   inputs: D;
   params: P;
-  secrets?: S;
+  input?: I;
   build: BuildAdapter;
   expose?: E;
-}): ServiceNode<D, P, E, S>;
+}): ServiceNode<D, P, E, I>;
 /**
  * Constructs a branded, frozen DependencyEnd. `required` (if given) is the
  * contract Load compares a wired ref against via `satisfies()`; an unnamed
@@ -519,19 +522,16 @@ interface Edge {
   readonly kind: 'input' | 'dependency';
 }
 /**
- * A resolved secret binding: the root bound a service's secret slot to an
- * opaque, target-defined source, and the wiring forwarded it to that service's
- * address (ADR-0029). Core never inspects the source; the deploy target reads
- * its own payload. A target's serializer keys the pointer row off this; the
- * preflight manifest aggregates the sources.
+ * A service's provision-time input binding (ADR-0042): the plain object a
+ * `provision(service, { input })` call supplied, recorded at that service's
+ * address. Core never walks it beyond usage tracking; the deploy target's
+ * recursive descent classifies its leaves (literals, `envParam`, `envSecret`).
  */
-interface SecretBinding {
-  /** The graph address of the service that declares the secret slot. */
+interface ServiceInputBinding {
+  /** The graph address of the service that declares the input schema. */
   readonly serviceAddress: NodeId;
-  /** The secret slot key on that service. */
-  readonly slot: string;
-  /** The opaque source the root bound the slot to. Core never inspects it; the deploy target reads back its own payload. */
-  readonly source: SecretSource;
+  /** The binding object supplied at provision. */
+  readonly binding: InputBinding;
 }
 /**
  * A resolved param binding: a `provision()` call bound a service's param
@@ -554,8 +554,8 @@ interface Graph {
   /** Root + one per input, topo-ordered (deps first). */
   readonly nodes: readonly GraphNode[];
   readonly edges: readonly Edge[];
-  /** Every service secret slot resolved to its root-bound opaque source. */
-  readonly secrets: readonly SecretBinding[];
+  /** Every service input binding a `provision()` call supplied (ADR-0042). */
+  readonly inputBindings: readonly ServiceInputBinding[];
   /** Every service param bound at provision — literal or source; unbound params are absent here and fall back to their `default` (see `buildConfig`). */
   readonly params: readonly ParamBinding[];
 }
@@ -564,5 +564,5 @@ declare class LoadError extends Error {
   constructor(message: string);
 }
 //#endregion
-export { paramManifest as $, ProvisionedRef as A, Secrets as B, ParamBindings as C, ParamSource as D, ParamNeeds as E, SecretBinding as F, freezeNode as G, Values as H, SecretBindings as I, isProvisionNeed as J, isNode as K, SecretNeed as L, ResourceNode as M, ResourceNodeBase as N, Params as O, RunnableServiceNode as P, param as Q, SecretSource as R, ParamBinding as S, ParamNeedBindings as T, configOf as U, ServiceNode as V, dependency as W, module as X, isSecretSource as Y, number as Z, ModuleBuilder as _, Connection as a, secret as at, ModuleOutputs as b, Deps as c, string as ct, Graph as d, paramNeed as et, GraphNode as f, LoadError as g, InputRef as h, ConfigParam as i, resource as it, RefPort as j, ProvisionNeed as k, Edge as l, SecretBox as lt, HydratedDeps as m, Config as n, provisionManifest as nt, Contract as o, secretSource as ot, Hydrated as p, isParamSource as q, ConfigDeclaration as r, provisionNeed as rt, DependencyEnd as s, service as st, BuildAdapter as t, paramSource as tt, Expose as u, SecretString as ut, ModuleContext as v, ParamNeed as w, NodeId as x, ModuleNode as y, SecretValues as z };
-//# sourceMappingURL=graph-types-BgT9UEdm-Bz-_OcJH.d.mts.map
+export { module as $, ParamSource as A, SecretSource as B, NODE as C, ParamNeed as D, ParamBindings as E, ResourceNode as F, configOf as G, ServiceInputBinding as H, ResourceNodeBase as I, inputManifest as J, dependency as K, RunnableServiceNode as L, ProvisionNeed as M, ProvisionedRef as N, ParamNeedBindings as O, RefPort as P, isSecretSource as Q, SecretBindings as R, ModuleOutputs as S, ParamBinding as T, ServiceNode as U, Secrets as V, Values as W, isParamSource as X, isNode as Y, isProvisionNeed as Z, InputValueOf as _, Connection as a, provisionNeed as at, ModuleContext as b, Deps as c, secretSource as ct, Graph as d, number as et, GraphNode as f, InputRef as g, InputBinding as h, ConfigParam as i, paramSource as it, Params as j, ParamNeeds as k, Edge as l, service as lt, HydratedDeps as m, Config as n, paramManifest as nt, Contract as o, resource as ot, Hydrated as p, freezeNode as q, ConfigDeclaration as r, paramNeed as rt, DependencyEnd as s, secret as st, BuildAdapter as t, param as tt, Expose as u, string as ut, LoadError as v, NodeId as w, ModuleNode as x, ModuleBuilder as y, SecretNeed as z };
+//# sourceMappingURL=graph-types-C3FOaaXm-C6_rGzfn.d.mts.map

package/dist/graph-types-C3FOaaXm-C6_rGzfn.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph-types-C3FOaaXm-C6_rGzfn.d.mts","names":[],"sources":["../../../0-framework/1-core/core/dist/graph-types-C3FOaaXm.d.mts"],"mappings":"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"}

package/dist/index-BQVrMGfe.d.mts

@@ -0,0 +1,22 @@
+import { U as ServiceNode, c as Deps, m as HydratedDeps, n as Config } from "./graph-types-C3FOaaXm-C6_rGzfn.mjs";
+import "./graph-DDpXh7S8-b-93BcHn.mjs";
+//#region ../../0-framework/1-core/core/dist/index.d.mts
+//#region src/hydrate.d.ts
+/**
+ * Given a service and a concrete typed Config, hydrate every input
+ * (connection.hydrate with its typed value slice). A resource dep and a
+ * connection dep hydrate through identical machinery — the loaded client is
+ * indistinguishable. The service's own params ride alongside in
+ * `config.service`; the node's `load()` merges the two.
+ */
+declare function hydrate(root: ServiceNode, config: Config): Promise<HydratedDeps<Deps>>;
+/**
+ * Synchronous hydrate — what the node's `load()` uses so
+ * `const { db } = service.load()` reads without `await`. Requires every
+ * connection.hydrate to return synchronously; a Promise return is a loud error
+ * naming the input (an async client factory must use the async `hydrate` path).
+ */
+declare function hydrateSync(root: ServiceNode, config: Config): HydratedDeps<Deps>;
+//#endregion
+export { hydrateSync as n, hydrate as t };
+//# sourceMappingURL=index-BQVrMGfe.d.mts.map

package/dist/index-BQVrMGfe.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-BQVrMGfe.d.mts","names":[],"sources":["../../../0-framework/1-core/core/dist/index.d.mts"],"mappings":";;;;;;;;;;;iBAWiB,QAAQ,MAAM,aAAa,QAAQ,SAAS,QAAQ,aAAa;;;;;;;iBAOjE,YAAY,MAAM,aAAa,QAAQ,SAAS,aAAa"}

package/dist/index.d.mts

@@ -1,4 +1,5 @@
-import { $ as paramManifest, A as ProvisionedRef, B as Secrets, C as ParamBindings, D as ParamSource, E as ParamNeeds, F as SecretBinding, G as freezeNode, H as Values, I as SecretBindings, J as isProvisionNeed, K as isNode, L as SecretNeed, M as ResourceNode, N as ResourceNodeBase, O as Params, P as RunnableServiceNode, Q as param, R as SecretSource, S as ParamBinding, T as ParamNeedBindings, U as configOf, V as ServiceNode, W as dependency, X as module, Y as isSecretSource, Z as number, _ as ModuleBuilder, a as Connection, at as secret, b as ModuleOutputs, c as Deps, ct as string, d as Graph, et as paramNeed, f as GraphNode, g as LoadError, h as InputRef, i as ConfigParam, it as resource, j as RefPort, k as ProvisionNeed, l as Edge, lt as SecretBox, m as HydratedDeps, n as Config, nt as provisionManifest, o as Contract, ot as secretSource, p as Hydrated, q as isParamSource, r as ConfigDeclaration, rt as provisionNeed, s as DependencyEnd, st as service, t as BuildAdapter, tt as paramSource, u as Expose, ut as SecretString, v as ModuleContext, w as ParamNeed, x as NodeId, y as ModuleNode, z as SecretValues } from "./graph-types-BgT9UEdm-Bz-_OcJH.mjs";
-import { t as Load } from "./graph-B7NcPiOr-aSUOCGTH.mjs";
-import { n as hydrateSecrets, r as hydrateSync, t as hydrate } from "./index-B2DJ5CN4.mjs";
-export { type BuildAdapter, type Config, type ConfigDeclaration, type ConfigParam, type Connection, type Contract, type DependencyEnd, type Deps, type Edge, type Expose, type Graph, type GraphNode, type Hydrated, type HydratedDeps, type InputRef, Load, LoadError, type ModuleBuilder, type ModuleContext, type ModuleNode, type ModuleOutputs, type NodeId, type ParamBinding, type ParamBindings, type ParamNeed, type ParamNeedBindings, type ParamNeeds, type ParamSource, type Params, type ProvisionNeed, type ProvisionedRef, type RefPort, type ResourceNode, ResourceNodeBase, type RunnableServiceNode, type SecretBinding, type SecretBindings, SecretBox, type SecretNeed, type SecretSource, type SecretString, type SecretValues, type Secrets, type ServiceNode, type Values, configOf, dependency, freezeNode, hydrate, hydrateSecrets, hydrateSync, isNode, isParamSource, isProvisionNeed, isSecretSource, module, number, param, paramManifest, paramNeed, paramSource, provisionManifest, provisionNeed, resource, secret, secretSource, service, string };
+import { n as SecretString, r as isSecretString, t as SecretBox } from "./secret-CHOw4LBU-C8yXoC9N.mjs";
+import { $ as module, A as ParamSource, B as SecretSource, C as NODE, D as ParamNeed, E as ParamBindings, F as ResourceNode, G as configOf, H as ServiceInputBinding, I as ResourceNodeBase, J as inputManifest, K as dependency, L as RunnableServiceNode, M as ProvisionNeed, N as ProvisionedRef, O as ParamNeedBindings, P as RefPort, Q as isSecretSource, R as SecretBindings, S as ModuleOutputs, T as ParamBinding, U as ServiceNode, V as Secrets, W as Values, X as isParamSource, Y as isNode, Z as isProvisionNeed, _ as InputValueOf, a as Connection, at as provisionNeed, b as ModuleContext, c as Deps, ct as secretSource, d as Graph, et as number, f as GraphNode, g as InputRef, h as InputBinding, i as ConfigParam, it as paramSource, j as Params, k as ParamNeeds, l as Edge, lt as service, m as HydratedDeps, n as Config, nt as paramManifest, o as Contract, ot as resource, p as Hydrated, q as freezeNode, r as ConfigDeclaration, rt as paramNeed, s as DependencyEnd, st as secret, t as BuildAdapter, tt as param, u as Expose, ut as string, v as LoadError, w as NodeId, x as ModuleNode, y as ModuleBuilder, z as SecretNeed } from "./graph-types-C3FOaaXm-C6_rGzfn.mjs";
+import { t as Load } from "./graph-DDpXh7S8-b-93BcHn.mjs";
+import { n as hydrateSync, t as hydrate } from "./index-BQVrMGfe.mjs";
+export { type BuildAdapter, type Config, type ConfigDeclaration, type ConfigParam, type Connection, type Contract, type DependencyEnd, type Deps, type Edge, type Expose, type Graph, type GraphNode, type Hydrated, type HydratedDeps, type InputBinding, type InputRef, type InputValueOf, Load, LoadError, type ModuleBuilder, type ModuleContext, type ModuleNode, type ModuleOutputs, type NODE, type NodeId, type ParamBinding, type ParamBindings, type ParamNeed, type ParamNeedBindings, type ParamNeeds, type ParamSource, type Params, type ProvisionNeed, type ProvisionedRef, type RefPort, type ResourceNode, ResourceNodeBase, type RunnableServiceNode, type SecretBindings, SecretBox, type SecretNeed, type SecretSource, type SecretString, type Secrets, type ServiceInputBinding, type ServiceNode, type Values, configOf, dependency, freezeNode, hydrate, hydrateSync, inputManifest, isNode, isParamSource, isProvisionNeed, isSecretSource, isSecretString, module, number, param, paramManifest, paramNeed, paramSource, provisionNeed, resource, secret, secretSource, service, string };

package/dist/index.mjs

@@ -1,3 +1,4 @@
-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 LoadError, o as isNode, p as provisionNeed, r as ResourceNodeBase, s as isParamSource, t as Load, u as module } from "./graph-BmrUEdo9-6Oq1hSmS.mjs";
-import { a as number, c as provisionManifest, i as hydrateSync, l as string, n as hydrate, o as param, r as hydrateSecrets, s as paramManifest, t as configOf, u as SecretBox } from "./dist-B0axxnBf.mjs";
-export { Load, LoadError, ResourceNodeBase, SecretBox, configOf, dependency, freezeNode, hydrate, hydrateSecrets, hydrateSync, isNode, isParamSource, isProvisionNeed, isSecretSource, module, number, param, paramManifest, paramNeed, paramSource, provisionManifest, provisionNeed, resource, secret, secretSource, service, string };
+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 LoadError, o as isNode, p as provisionNeed, r as ResourceNodeBase, s as isParamSource, t as Load, u as module } from "./graph-DgbALPDo-BEHF94BN.mjs";
+import { n as isSecretString, t as SecretBox } from "./secret-DoWGmN7m-DO5Brq1Y.mjs";
+import { a as number, c as string, i as inputManifest, n as hydrate, o as param, r as hydrateSync, s as paramManifest, t as configOf } from "./dist-BdvFDCLV.mjs";
+export { Load, LoadError, ResourceNodeBase, SecretBox, configOf, dependency, freezeNode, hydrate, hydrateSync, inputManifest, isNode, isParamSource, isProvisionNeed, isSecretSource, isSecretString, module, number, param, paramManifest, paramNeed, paramSource, provisionNeed, resource, secret, secretSource, service, string };

package/dist/local-target.d.mts

@@ -0,0 +1,29 @@
+import { O as PrismaAppConfig, _ as LocalTargetProvidersInput, c as DEV_DIR, g as LocalTargetEmulatorsInput, h as LocalTargetDescriptor, m as LocalTargetAttachment, p as LocalTargetAttachInput, s as ContainerInstance } from "./app-config-bsTo57A8-BfG21wAI.mjs";
+import * as Layer from "effect/Layer";
+//#region ../../0-framework/1-core/core/dist/local-target.d.mts
+//#region src/control/local-target.d.ts
+/**
+ * Resolves every non-build-only configured extension's lazy `localTarget`
+ * thunk, once (ADR-0041's lazy local-target reference — operator directive:
+ * the production control entry carries only the thunk, never the
+ * descriptor, so resolving it is this module's job, not something a deploy
+ * path ever does). A build-only extension (`isBuildOnlyExtension`) owns no
+ * resources or services and is skipped entirely — never even checked for a
+ * `localTarget` thunk. Every other configured extension must be
+ * local-target-capable, or the dev command cannot bring the app up at all,
+ * so a missing thunk throws naming the extension. The generated dev stack
+ * module calls this once and threads the resolved map through every
+ * subsequent hook, including `localTargetProviders`.
+ */
+declare function resolveLocalTargets(config: PrismaAppConfig): Promise<ReadonlyMap<string, LocalTargetDescriptor>>;
+/**
+ * All configured extensions' local-target providers merged, config array
+ * order (ADR-0041), from the ALREADY-RESOLVED descriptor map
+ * (`resolveLocalTargets`'s product — this function itself never touches a
+ * `localTarget` thunk). The generated dev stack module is this
+ * aggregator's one caller, passing the result as `LowerOptions.providers`.
+ */
+declare function localTargetProviders(resolved: ReadonlyMap<string, LocalTargetDescriptor>, containers: ReadonlyMap<string, ContainerInstance>, devDir: string): Layer.Layer<never>;
+//#endregion
+export { DEV_DIR, type LocalTargetAttachInput, type LocalTargetAttachment, type LocalTargetDescriptor, type LocalTargetEmulatorsInput, type LocalTargetProvidersInput, localTargetProviders, resolveLocalTargets };
+//# sourceMappingURL=local-target.d.mts.map

package/dist/local-target.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-target.d.mts","names":[],"sources":["../../../0-framework/1-core/core/dist/local-target.d.mts"],"mappings":";;;;;;;;;;;;;;;;;iBAgBiB,oBAAoB,QAAQ,kBAAkB,QAAQ,oBAAoB;;;;;;;;iBAQ1E,qBAAqB,UAAU,oBAAoB,wBAAwB,YAAY,oBAAoB,oBAAoB,iBAAiB,MAAM"}

package/dist/local-target.mjs

@@ -0,0 +1,47 @@
+import { r as isBuildOnlyExtension, t as DEV_DIR } from "./app-config-joXc-BKm-CdcXqNMD.mjs";
+import { t as LowerError } from "./deploy-C4DxNkJ9-D73lmBqy.mjs";
+import * as Layer from "effect/Layer";
+//#region ../../0-framework/1-core/core/dist/local-target.mjs
+/** The local-target stack's own provider aggregation (ADR-0041; naming, operator 2026-07-23 — the seam is `localTarget`, "dev" names the user-facing feature only) — the local-target counterpart of `deploy.ts`'s `mergedProviders`, kept in its own module so `lower()` learns nothing about it (deploy.ts's REVISED — operator review of #162). */
+function noLocalTargetSupportError(id) {
+	return new LowerError(`extension "${id}" has no dev support — it declares no \`localTarget\` descriptor (ADR-0041).`);
+}
+/**
+* Resolves every non-build-only configured extension's lazy `localTarget`
+* thunk, once (ADR-0041's lazy local-target reference — operator directive:
+* the production control entry carries only the thunk, never the
+* descriptor, so resolving it is this module's job, not something a deploy
+* path ever does). A build-only extension (`isBuildOnlyExtension`) owns no
+* resources or services and is skipped entirely — never even checked for a
+* `localTarget` thunk. Every other configured extension must be
+* local-target-capable, or the dev command cannot bring the app up at all,
+* so a missing thunk throws naming the extension. The generated dev stack
+* module calls this once and threads the resolved map through every
+* subsequent hook, including `localTargetProviders`.
+*/
+async function resolveLocalTargets(config) {
+	const entries = await Promise.all(config.extensions.flatMap((extension) => {
+		if (isBuildOnlyExtension(extension)) return [];
+		if (extension.localTarget === void 0) throw noLocalTargetSupportError(extension.id);
+		return [extension.localTarget().then((descriptor) => [extension.id, descriptor])];
+	}));
+	return new Map(entries);
+}
+/**
+* All configured extensions' local-target providers merged, config array
+* order (ADR-0041), from the ALREADY-RESOLVED descriptor map
+* (`resolveLocalTargets`'s product — this function itself never touches a
+* `localTarget` thunk). The generated dev stack module is this
+* aggregator's one caller, passing the result as `LowerOptions.providers`.
+*/
+function localTargetProviders(resolved, containers, devDir) {
+	const [first, ...rest] = [...resolved.entries()].map(([id, descriptor]) => descriptor.providers({
+		container: containers.get(id),
+		devDir
+	}));
+	return first === void 0 ? Layer.empty : Layer.mergeAll(first, ...rest);
+}
+//#endregion
+export { DEV_DIR, localTargetProviders, resolveLocalTargets };
+
+//# sourceMappingURL=local-target.mjs.map

package/dist/local-target.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-target.mjs","names":[],"sources":["../../../0-framework/1-core/core/dist/local-target.mjs"],"sourcesContent":["import { t as LowerError } from \"./deploy-C4DxNkJ9.mjs\";\nimport { r as isBuildOnlyExtension, t as DEV_DIR } from \"./app-config-joXc-BKm.mjs\";\nimport * as Layer from \"effect/Layer\";\n//#region src/control/local-target.ts\n/** The local-target stack's own provider aggregation (ADR-0041; naming, operator 2026-07-23 — the seam is `localTarget`, \"dev\" names the user-facing feature only) — the local-target counterpart of `deploy.ts`'s `mergedProviders`, kept in its own module so `lower()` learns nothing about it (deploy.ts's REVISED — operator review of #162). */\nfunction noLocalTargetSupportError(id) {\n\treturn new LowerError(`extension \"${id}\" has no dev support — it declares no \\`localTarget\\` descriptor (ADR-0041).`);\n}\n/**\n* Resolves every non-build-only configured extension's lazy `localTarget`\n* thunk, once (ADR-0041's lazy local-target reference — operator directive:\n* the production control entry carries only the thunk, never the\n* descriptor, so resolving it is this module's job, not something a deploy\n* path ever does). A build-only extension (`isBuildOnlyExtension`) owns no\n* resources or services and is skipped entirely — never even checked for a\n* `localTarget` thunk. Every other configured extension must be\n* local-target-capable, or the dev command cannot bring the app up at all,\n* so a missing thunk throws naming the extension. The generated dev stack\n* module calls this once and threads the resolved map through every\n* subsequent hook, including `localTargetProviders`.\n*/\nasync function resolveLocalTargets(config) {\n\tconst entries = await Promise.all(config.extensions.flatMap((extension) => {\n\t\tif (isBuildOnlyExtension(extension)) return [];\n\t\tif (extension.localTarget === void 0) throw noLocalTargetSupportError(extension.id);\n\t\treturn [extension.localTarget().then((descriptor) => [extension.id, descriptor])];\n\t}));\n\treturn new Map(entries);\n}\n/**\n* All configured extensions' local-target providers merged, config array\n* order (ADR-0041), from the ALREADY-RESOLVED descriptor map\n* (`resolveLocalTargets`'s product — this function itself never touches a\n* `localTarget` thunk). The generated dev stack module is this\n* aggregator's one caller, passing the result as `LowerOptions.providers`.\n*/\nfunction localTargetProviders(resolved, containers, devDir) {\n\tconst [first, ...rest] = [...resolved.entries()].map(([id, descriptor]) => descriptor.providers({\n\t\tcontainer: containers.get(id),\n\t\tdevDir\n\t}));\n\treturn first === void 0 ? Layer.empty : Layer.mergeAll(first, ...rest);\n}\n//#endregion\nexport { DEV_DIR, localTargetProviders, resolveLocalTargets };\n\n//# sourceMappingURL=local-target.mjs.map"],"mappings":";;;;;AAKA,SAAS,0BAA0B,IAAI;CACtC,OAAO,IAAI,WAAW,cAAc,GAAG,6EAA6E;AACrH;;;;;;;;;;;;;;AAcA,eAAe,oBAAoB,QAAQ;CAC1C,MAAM,UAAU,MAAM,QAAQ,IAAI,OAAO,WAAW,SAAS,cAAc;EAC1E,IAAI,qBAAqB,SAAS,GAAG,OAAO,CAAC;EAC7C,IAAI,UAAU,gBAAgB,KAAK,GAAG,MAAM,0BAA0B,UAAU,EAAE;EAClF,OAAO,CAAC,UAAU,YAAY,CAAC,CAAC,MAAM,eAAe,CAAC,UAAU,IAAI,UAAU,CAAC,CAAC;CACjF,CAAC,CAAC;CACF,OAAO,IAAI,IAAI,OAAO;AACvB;;;;;;;;AAQA,SAAS,qBAAqB,UAAU,YAAY,QAAQ;CAC3D,MAAM,CAAC,OAAO,GAAG,QAAQ,CAAC,GAAG,SAAS,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,gBAAgB,WAAW,UAAU;EAC/F,WAAW,WAAW,IAAI,EAAE;EAC5B;CACD,CAAC,CAAC;CACF,OAAO,UAAU,KAAK,IAAI,MAAM,QAAQ,MAAM,SAAS,OAAO,GAAG,IAAI;AACtE"}

package/dist/{nextjs-DLyeRR7M-B9ukbB2L.d.mts → nextjs-DLyeRR7M-D47aMmfr.d.mts}

@@ -1,5 +1,5 @@
-import { t as BuildAdapter } from "./graph-types-BgT9UEdm-Bz-_OcJH.mjs";
-import "./index-B2DJ5CN4.mjs";
+import { t as BuildAdapter } from "./graph-types-C3FOaaXm-C6_rGzfn.mjs";
+import "./index-BQVrMGfe.mjs";
 //#region ../../0-framework/2-authoring/nextjs/dist/nextjs-DLyeRR7M.d.mts
 //#region src/nextjs.d.ts
 /** The nextjs build adapter's descriptor — `appDir` is this kind's own extra path input (the Next app root), beyond the shared `{ extension, type, module, entry }`. `entry` is a placeholder; the assembler locates `server.js` in the standalone tree. */
@@ -13,4 +13,4 @@ declare const nextjsBuild: (opts: {
 }) => NextjsBuildAdapter;
 //#endregion
 export { nextjsBuild as n, NextjsBuildAdapter as t };
-//# sourceMappingURL=nextjs-DLyeRR7M-B9ukbB2L.d.mts.map
+//# sourceMappingURL=nextjs-DLyeRR7M-D47aMmfr.d.mts.map

package/dist/nextjs-DLyeRR7M-D47aMmfr.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nextjs-DLyeRR7M-D47aMmfr.d.mts","names":[],"sources":["../../../0-framework/2-authoring/nextjs/dist/nextjs-DLyeRR7M.d.mts"],"mappings":";;;;;UAGU,2BAA2B;WAC1B;WACA;;cAEG,cAAc;EAC1B;EACA;MACI"}

package/dist/nextjs-control.d.mts

@@ -1,7 +1,7 @@
-import { a as Bundle, d as ExtensionDescriptor, i as AssembleInput } from "./app-config-DJdU4ubR-BwioNK8j.mjs";
-import "./config-ByZICgry.mjs";
-import "./deploy-ByZICgry.mjs";
-import { t as NextjsBuildAdapter } from "./nextjs-DLyeRR7M-B9ukbB2L.mjs";
+import { a as Bundle, f as ExtensionDescriptor, i as AssembleInput } from "./app-config-bsTo57A8-BfG21wAI.mjs";
+import "./config-DUzvB5cQ.mjs";
+import "./deploy-DUzvB5cQ.mjs";
+import { t as NextjsBuildAdapter } from "./nextjs-DLyeRR7M-D47aMmfr.mjs";
 //#region ../../0-framework/2-authoring/nextjs/dist/control.d.mts
 //#region src/control/build.d.ts
 /** The built standalone server.js for a nextjs build — `appDir`'s standalone root plus the app subpath Next recorded. Single-sourced so `assemble()` (deploy) and the integration-test seam can't drift. */

package/dist/nextjs-control.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nextjs-control.d.mts","names":[],"sources":["../../../0-framework/2-authoring/nextjs/dist/control.d.mts"],"mappings":";;;;;;;iBAKiB,qBAAqB,OAAO;iBAC5B,SAAS,OAAO,gBAAkB,QAAQ;;cAE7C,mBAAmB"}

package/dist/nextjs-control.mjs

@@ -88,7 +88,8 @@ async function assemble(input) {
 	if (!fs.existsSync(path.join(workDir, "main.mjs"))) throw new Error(`esbuild produced no main.mjs in ${workDir}`);
 	return {
 		dir: workDir,
-		entry: path.posix.join("bundle", appRel.split(path.sep).join("/"), "server.js")
+		entry: path.posix.join("bundle", appRel.split(path.sep).join("/"), "server.js"),
+		watch: [standaloneRoot]
 	};
 }
 /** The nextjs build extension descriptor — `prisma-composer.config.ts` lists it under `extensions`. */

package/dist/nextjs-control.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"nextjs-control.mjs","names":[],"sources":["../../../0-framework/2-authoring/nextjs/dist/control.mjs"],"sourcesContent":["import * as fs from \"node:fs\";\nimport * as path from \"node:path\";\nimport { fileURLToPath } from \"node:url\";\nimport { build } from \"esbuild\";\n//#region src/control/build.ts\n/**\n* The extension's control entry (ADR-0017): `nextjsBuild()` returns the build\n* descriptor `prisma-composer.config.ts` lists. Deploy-only (ADR-0005): the user\n* runs `next build` (`output: \"standalone\"`); `assemble` then performs the\n* *documented* Next standalone deploy — it ships the standalone tree and copies\n* in the client assets Next deliberately omits (`.next/static`, `public/`) — and\n* adds the framework's boot wrapper. This is the canonical `cp` step from the\n* Next docs, run at deploy so no app needs a build-script for it.\n*\n* It does not guess: the app's location inside the standalone tree (deep, when\n* `outputFileTracingRoot` is the monorepo root) is *read from Next's own build\n* manifest* (`.next/required-server-files.json`'s `relativeAppDir`), never walked\n* for or computed from a hardcoded depth. It does not launder: node_modules is\n* shipped exactly as `next build` produced it, so a symlinked (non-hoisted)\n* node_modules is the packager's hard error — the same misconfiguration crashes\n* the standalone server at boot, so it must be a flat install (npm, or pnpm/bun\n* with a hoisted node-linker).\n*\n* Artifact layout: `<workDir>/main.mjs` (our wrapper) + `<workDir>/bundle/`\n* (the standalone tree, with static/public copied in). The packager adds\n* `bootstrap.js` + the manifest at the root; bootstrap imports main.mjs, whose\n* run() dynamically imports `./bundle/<relativeAppDir>/server.js`.\n*\n* Paths are file-relative (ADR-0004): `appDir` resolves against\n* `dirname(build.module)`.\n*/\n/** Narrows the shared BuildAdapter to this extension's own descriptor — the value-level mirror of the registry routing on (extension, type). */\nfunction isNextjsBuild(descriptor) {\n\treturn descriptor.type === \"nextjs\" && \"appDir\" in descriptor && typeof descriptor.appDir === \"string\";\n}\n/**\n* The app's own subpath within `.next/standalone`, as an OS-relative path. Next\n* mirrors the app's location under `outputFileTracingRoot` (deep, when that's the\n* monorepo root); rather than walk the tree for `server.js`, we read where Next\n* put it from `.next/required-server-files.json` — `relativeAppDir` is exactly\n* that subpath. Older Next lacks the field; fall back to computing it from the\n* same manifest's `config.outputFileTracingRoot`.\n*/\nfunction nextAppRel(appDir) {\n\tconst manifestPath = path.join(appDir, \".next\", \"required-server-files.json\");\n\tif (!fs.existsSync(manifestPath)) throw new Error(`no ${path.join(\".next\", \"required-server-files.json\")} under ${appDir} — run \\`next build\\` with output: \"standalone\" first.`);\n\tconst manifest = JSON.parse(fs.readFileSync(manifestPath, \"utf8\"));\n\tconst relativeAppDir = manifest?.relativeAppDir;\n\tconst tracingRoot = manifest?.config?.outputFileTracingRoot;\n\tconst posixRel = typeof relativeAppDir === \"string\" ? relativeAppDir : typeof tracingRoot === \"string\" ? path.relative(tracingRoot, appDir).split(path.sep).join(\"/\") : void 0;\n\tif (posixRel === void 0) throw new Error(`${manifestPath} records neither relativeAppDir nor config.outputFileTracingRoot — cannot locate the standalone server`);\n\treturn posixRel.split(\"/\").join(path.sep);\n}\n/** The built standalone server.js for a nextjs build — `appDir`'s standalone root plus the app subpath Next recorded. Single-sourced so `assemble()` (deploy) and the integration-test seam can't drift. */\nfunction standaloneServerPath(build) {\n\tconst appDir = path.resolve(path.dirname(fileURLToPath(build.module)), build.appDir);\n\treturn path.join(appDir, \".next\", \"standalone\", nextAppRel(appDir), \"server.js\");\n}\nasync function assemble(input) {\n\tif (!isNextjsBuild(input.build)) throw new Error(`@prisma/composer/nextjs/control: expected a \"nextjs\" build adapter (with appDir), got \"${input.build.type}\".`);\n\tconst buildDescriptor = input.build;\n\tconst appDir = path.resolve(path.dirname(fileURLToPath(buildDescriptor.module)), buildDescriptor.appDir);\n\tconst standaloneRoot = path.join(appDir, \".next\", \"standalone\");\n\tif (!fs.existsSync(standaloneRoot)) throw new Error(`no ${path.join(\".next\", \"standalone\")} under ${appDir} — run \\`next build\\` with output: \"standalone\" first.`);\n\tconst appRel = nextAppRel(appDir);\n\tconst workDir = path.join(input.cwd, \".prisma-composer\", \"artifacts\", input.address);\n\tawait fs.promises.rm(workDir, {\n\t\trecursive: true,\n\t\tforce: true\n\t});\n\tawait fs.promises.mkdir(workDir, { recursive: true });\n\tconst bundleDir = path.join(workDir, \"bundle\");\n\tawait fs.promises.cp(standaloneRoot, bundleDir, { recursive: true });\n\tconst appOut = path.join(bundleDir, appRel);\n\tconst staticSrc = path.join(appDir, \".next\", \"static\");\n\tif (fs.existsSync(staticSrc)) await fs.promises.cp(staticSrc, path.join(appOut, \".next\", \"static\"), { recursive: true });\n\tconst publicSrc = path.join(appDir, \"public\");\n\tif (fs.existsSync(publicSrc)) await fs.promises.cp(publicSrc, path.join(appOut, \"public\"), { recursive: true });\n\tawait build({\n\t\tentryPoints: { main: fileURLToPath(buildDescriptor.module) },\n\t\toutdir: workDir,\n\t\tbundle: true,\n\t\tformat: \"esm\",\n\t\tplatform: \"node\",\n\t\texternal: [\"bun\", \"bun:*\"],\n\t\toutExtension: { \".js\": \".mjs\" }\n\t});\n\tif (!fs.existsSync(path.join(workDir, \"main.mjs\"))) throw new Error(`esbuild produced no main.mjs in ${workDir}`);\n\treturn {\n\t\tdir: workDir,\n\t\tentry: path.posix.join(\"bundle\", appRel.split(path.sep).join(\"/\"), \"server.js\")\n\t};\n}\n/** The nextjs build extension descriptor — `prisma-composer.config.ts` lists it under `extensions`. */\nconst nextjsBuild = () => ({\n\tid: \"@prisma/composer/nextjs\",\n\tnodes: { nextjs: {\n\t\tkind: \"build\",\n\t\tassemble\n\t} }\n});\n//#endregion\nexport { assemble, nextjsBuild, standaloneServerPath };\n\n//# sourceMappingURL=control.mjs.map"],"mappings":"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"}
+{"version":3,"file":"nextjs-control.mjs","names":[],"sources":["../../../0-framework/2-authoring/nextjs/dist/control.mjs"],"sourcesContent":["import * as fs from \"node:fs\";\nimport * as path from \"node:path\";\nimport { fileURLToPath } from \"node:url\";\nimport { build } from \"esbuild\";\n//#region src/control/build.ts\n/**\n* The extension's control entry (ADR-0017): `nextjsBuild()` returns the build\n* descriptor `prisma-composer.config.ts` lists. Deploy-only (ADR-0005): the user\n* runs `next build` (`output: \"standalone\"`); `assemble` then performs the\n* *documented* Next standalone deploy — it ships the standalone tree and copies\n* in the client assets Next deliberately omits (`.next/static`, `public/`) — and\n* adds the framework's boot wrapper. This is the canonical `cp` step from the\n* Next docs, run at deploy so no app needs a build-script for it.\n*\n* It does not guess: the app's location inside the standalone tree (deep, when\n* `outputFileTracingRoot` is the monorepo root) is *read from Next's own build\n* manifest* (`.next/required-server-files.json`'s `relativeAppDir`), never walked\n* for or computed from a hardcoded depth. It does not launder: node_modules is\n* shipped exactly as `next build` produced it, so a symlinked (non-hoisted)\n* node_modules is the packager's hard error — the same misconfiguration crashes\n* the standalone server at boot, so it must be a flat install (npm, or pnpm/bun\n* with a hoisted node-linker).\n*\n* Artifact layout: `<workDir>/main.mjs` (our wrapper) + `<workDir>/bundle/`\n* (the standalone tree, with static/public copied in). The packager adds\n* `bootstrap.js` + the manifest at the root; bootstrap imports main.mjs, whose\n* run() dynamically imports `./bundle/<relativeAppDir>/server.js`.\n*\n* Paths are file-relative (ADR-0004): `appDir` resolves against\n* `dirname(build.module)`.\n*/\n/** Narrows the shared BuildAdapter to this extension's own descriptor — the value-level mirror of the registry routing on (extension, type). */\nfunction isNextjsBuild(descriptor) {\n\treturn descriptor.type === \"nextjs\" && \"appDir\" in descriptor && typeof descriptor.appDir === \"string\";\n}\n/**\n* The app's own subpath within `.next/standalone`, as an OS-relative path. Next\n* mirrors the app's location under `outputFileTracingRoot` (deep, when that's the\n* monorepo root); rather than walk the tree for `server.js`, we read where Next\n* put it from `.next/required-server-files.json` — `relativeAppDir` is exactly\n* that subpath. Older Next lacks the field; fall back to computing it from the\n* same manifest's `config.outputFileTracingRoot`.\n*/\nfunction nextAppRel(appDir) {\n\tconst manifestPath = path.join(appDir, \".next\", \"required-server-files.json\");\n\tif (!fs.existsSync(manifestPath)) throw new Error(`no ${path.join(\".next\", \"required-server-files.json\")} under ${appDir} — run \\`next build\\` with output: \"standalone\" first.`);\n\tconst manifest = JSON.parse(fs.readFileSync(manifestPath, \"utf8\"));\n\tconst relativeAppDir = manifest?.relativeAppDir;\n\tconst tracingRoot = manifest?.config?.outputFileTracingRoot;\n\tconst posixRel = typeof relativeAppDir === \"string\" ? relativeAppDir : typeof tracingRoot === \"string\" ? path.relative(tracingRoot, appDir).split(path.sep).join(\"/\") : void 0;\n\tif (posixRel === void 0) throw new Error(`${manifestPath} records neither relativeAppDir nor config.outputFileTracingRoot — cannot locate the standalone server`);\n\treturn posixRel.split(\"/\").join(path.sep);\n}\n/** The built standalone server.js for a nextjs build — `appDir`'s standalone root plus the app subpath Next recorded. Single-sourced so `assemble()` (deploy) and the integration-test seam can't drift. */\nfunction standaloneServerPath(build) {\n\tconst appDir = path.resolve(path.dirname(fileURLToPath(build.module)), build.appDir);\n\treturn path.join(appDir, \".next\", \"standalone\", nextAppRel(appDir), \"server.js\");\n}\nasync function assemble(input) {\n\tif (!isNextjsBuild(input.build)) throw new Error(`@prisma/composer/nextjs/control: expected a \"nextjs\" build adapter (with appDir), got \"${input.build.type}\".`);\n\tconst buildDescriptor = input.build;\n\tconst appDir = path.resolve(path.dirname(fileURLToPath(buildDescriptor.module)), buildDescriptor.appDir);\n\tconst standaloneRoot = path.join(appDir, \".next\", \"standalone\");\n\tif (!fs.existsSync(standaloneRoot)) throw new Error(`no ${path.join(\".next\", \"standalone\")} under ${appDir} — run \\`next build\\` with output: \"standalone\" first.`);\n\tconst appRel = nextAppRel(appDir);\n\tconst workDir = path.join(input.cwd, \".prisma-composer\", \"artifacts\", input.address);\n\tawait fs.promises.rm(workDir, {\n\t\trecursive: true,\n\t\tforce: true\n\t});\n\tawait fs.promises.mkdir(workDir, { recursive: true });\n\tconst bundleDir = path.join(workDir, \"bundle\");\n\tawait fs.promises.cp(standaloneRoot, bundleDir, { recursive: true });\n\tconst appOut = path.join(bundleDir, appRel);\n\tconst staticSrc = path.join(appDir, \".next\", \"static\");\n\tif (fs.existsSync(staticSrc)) await fs.promises.cp(staticSrc, path.join(appOut, \".next\", \"static\"), { recursive: true });\n\tconst publicSrc = path.join(appDir, \"public\");\n\tif (fs.existsSync(publicSrc)) await fs.promises.cp(publicSrc, path.join(appOut, \"public\"), { recursive: true });\n\tawait build({\n\t\tentryPoints: { main: fileURLToPath(buildDescriptor.module) },\n\t\toutdir: workDir,\n\t\tbundle: true,\n\t\tformat: \"esm\",\n\t\tplatform: \"node\",\n\t\texternal: [\"bun\", \"bun:*\"],\n\t\toutExtension: { \".js\": \".mjs\" }\n\t});\n\tif (!fs.existsSync(path.join(workDir, \"main.mjs\"))) throw new Error(`esbuild produced no main.mjs in ${workDir}`);\n\treturn {\n\t\tdir: workDir,\n\t\tentry: path.posix.join(\"bundle\", appRel.split(path.sep).join(\"/\"), \"server.js\"),\n\t\twatch: [standaloneRoot]\n\t};\n}\n/** The nextjs build extension descriptor — `prisma-composer.config.ts` lists it under `extensions`. */\nconst nextjsBuild = () => ({\n\tid: \"@prisma/composer/nextjs\",\n\tnodes: { nextjs: {\n\t\tkind: \"build\",\n\t\tassemble\n\t} }\n});\n//#endregion\nexport { assemble, nextjsBuild, standaloneServerPath };\n\n//# sourceMappingURL=control.mjs.map"],"mappings":"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"}

package/dist/nextjs.d.mts

@@ -1,2 +1,2 @@
-import { n as nextjsBuild, t as NextjsBuildAdapter } from "./nextjs-DLyeRR7M-B9ukbB2L.mjs";
+import { n as nextjsBuild, t as NextjsBuildAdapter } from "./nextjs-DLyeRR7M-D47aMmfr.mjs";
 export { type NextjsBuildAdapter, nextjsBuild as default };

package/dist/node-control.d.mts

@@ -1,6 +1,6 @@
-import { a as Bundle, d as ExtensionDescriptor, i as AssembleInput } from "./app-config-DJdU4ubR-BwioNK8j.mjs";
-import "./config-ByZICgry.mjs";
-import "./deploy-ByZICgry.mjs";
+import { a as Bundle, f as ExtensionDescriptor, i as AssembleInput } from "./app-config-bsTo57A8-BfG21wAI.mjs";
+import "./config-DUzvB5cQ.mjs";
+import "./deploy-DUzvB5cQ.mjs";
 //#region ../../0-framework/2-authoring/node/dist/control.d.mts
 //#region src/control/build.d.ts
 declare function assemble(input: AssembleInput): Promise<Bundle>;

package/dist/node-control.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-control.d.mts","names":[],"sources":["../../../0-framework/2-authoring/node/dist/control.d.mts"],"mappings":";;;;;iBAGiB,SAAS,OAAO,gBAAkB,QAAQ;;cAE7C,iBAAiB"}