@prisma/composer 0.1.0 → 0.2.0-dev.2

package/dist/{config-ob5OhCSP-sP3GW3uu.d.mts → graph-types-BcbVhojU-C3fhxjPK.d.mts}

@@ -1,5 +1,4 @@
 import { StandardSchemaV1 } from "@standard-schema/spec";
-
 //#region ../../0-framework/0-foundation/foundation/dist/secret.d.mts
 //#region src/secret.d.ts
 /**
@@ -23,9 +22,111 @@ declare class SecretBox<T> {
   [Symbol.toPrimitive](): string;
 }
 /** The common case: a secret string. */
-type SecretString = SecretBox<string>; //#endregion
+type SecretString = SecretBox<string>;
+//#endregion
+//#region ../../0-framework/1-core/core/dist/graph-types-BcbVhojU.d.mts
+//#region src/config.d.ts
+/**
+ * A declared config param — pure data: a caller-owned Standard Schema
+ * (ADR-0018) plus a few framework facets. The framework carries the schema,
+ * infers the value type from it, and validates with it, without ever
+ * enumerating permitted shapes. Turning a value into stored config and back is
+ * the deploy target's job, not the param's (ADR-0019) — the same split RPC
+ * uses: schema on the declaration, wire owned by the mover.
+ */
+interface ConfigParam<S extends StandardSchemaV1 = StandardSchemaV1> {
+  readonly schema: S;
+  readonly optional?: boolean;
+  readonly default?: StandardSchemaV1.InferOutput<S>;
+  /**
+   * A framework-minted value (ADR-0031): core resolves `provision.brand`
+   * against the consumer extension's `provisions` registry and mints this
+   * param's value per dependency edge. Opaque — core forwards the need and
+   * never reads its payload.
+   */
+  readonly provision?: ProvisionNeed;
+}
+type Params = Record<string, ConfigParam>;
+/** What implementations receive — undefined only for optional params with no default. */
+type Values<P extends Params> = { readonly [K in keyof P]: P[K]['optional'] extends true ? undefined extends P[K]['default'] ? StandardSchemaV1.InferOutput<P[K]['schema']> | undefined : StandardSchemaV1.InferOutput<P[K]['schema']> : StandardSchemaV1.InferOutput<P[K]['schema']>; };
+/**
+ * The connection face of a dependency: declared params (data) and how
+ * validated values become a client (the hydrate behavior slot). Both P and C
+ * are INFERRED — the declaration types hydrate's input; the factory types the
+ * loaded dep.
+ */
+interface Connection<P extends Params = Params, C = unknown> {
+  readonly params: P;
+  hydrate(values: Values<P>): C | Promise<C>;
+}
+/**
+ * The enumerable config surface of a service — derivable from the graph
+ * alone, nothing booted, no platform keys. The introspection artifact (values
+ * absent). `schema` is a data-only projection of the param's Standard Schema
+ * (JSON Schema when the vendor supports the optional conversion, a `{ vendor }`
+ * tag otherwise) — never the param's functions. Physical locations are the
+ * target pack's business. Secrets are not here — they live on their own slot.
+ */
+interface ConfigDeclaration {
+  readonly owner: 'service' | {
+    readonly input: string;
+  };
+  readonly name: string;
+  readonly schema: Readonly<Record<string, unknown>>;
+  readonly optional: boolean;
+  readonly default: unknown;
+}
+/**
+ * The resolved, typed configuration of one service — what crosses the
+ * core→pack boundary. Core builds it at deploy (leaf values are provisioning
+ * refs, so the env writes depend on the resources/producer — the ordering
+ * edges); the pack serializes it, and at boot reconstructs the identical
+ * structure with concrete values. Both forms conform to the shape from
+ * configOf. Core never stringifies.
+ */
+interface Config {
+  readonly service: Readonly<Record<string, unknown>>;
+  readonly inputs: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
+}
+/**
+ * Enumerates every config param the service declares: each input's connection
+ * params, then the service's own params. Pure — reads `root.inputs`/`params`
+ * directly, executes nothing but the (also pure) schema projection. Deliberately
+ * does not go through `Load`: a service's connection-end inputs are legitimately
+ * unwired from its own point of view (wiring is an enclosing module's concern),
+ * and this introspects one service's declared shape regardless of how — or
+ * whether — it composes into a larger graph.
+ */
+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.
+ */
+declare function provisionManifest(graph: Graph): readonly SecretBinding[];
+/**
+ * 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-AGNOSTIC; a param this manifest omits simply falls back to its own
+ * `default` at `buildConfig`.
+ */
+declare function paramManifest(graph: Graph): readonly ParamBinding[];
+interface ParamOptions<T> {
+  readonly optional?: boolean;
+  readonly default?: T;
+  readonly provision?: ProvisionNeed;
+}
+/** A string-valued param. */
+declare function string(opts?: ParamOptions<string>): ConfigParam<StandardSchemaV1<string, string>>;
+/** A number-valued param. */
+declare function number(opts?: ParamOptions<number>): ConfigParam<StandardSchemaV1<number, number>>;
+/** A param over any caller-supplied Standard Schema — a structured `jobs`, say. */
+declare function param<S extends StandardSchemaV1>(schema: S, opts?: ParamOptions<StandardSchemaV1.InferOutput<S>>): ConfigParam<S>;
 //#endregion
-//#region ../../0-framework/1-core/core/dist/config-ob5OhCSP.d.mts
 //#region src/contract.d.ts
 /**
  * A Contract is the declared interface of a service-to-service dependency: a
@@ -34,13 +135,14 @@ type SecretString = SecretBox<string>; //#endregion
  * `Cmp`, checked at `ModuleBuilder.provision`'s call site (node.ts); `satisfies`
  * is its runtime mirror, called at Load (graph.ts). Correctness comes from
  * the kind's builder shaping `Cmp` so assignability means the right thing —
- * see @prisma/composer/rpc's `contract()`/`rpc()`.
+ * see @prisma/composer/service-rpc's `contract()`/`rpc()`.
  */
 interface Contract<Kind extends string, Cmp> {
   readonly kind: Kind;
   readonly __cmp: Cmp;
   satisfies(required: Contract<Kind, unknown>): boolean;
-} //#endregion
+}
+//#endregion
 //#region src/node.d.ts
 declare const NODE: unique symbol;
 declare const SECRET_NEED: unique symbol;
@@ -59,15 +161,53 @@ interface SecretSource<T = unknown> {
   readonly payload: T;
 }
 /** What `provision(node, { secrets })` supplies: one source per declared secret slot. */
-type SecretBindings<S extends Secrets> = { [K in keyof S]: SecretSource };
+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 };
+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. */
 declare function secretSource<T>(payload: T): SecretSource<T>;
 /** True if `value` is a secret source (an `envSecret` result or a forwarded ctx.secrets ref). */
 declare function isSecretSource(value: unknown): value is SecretSource;
+declare const PROVISION_NEED: unique symbol;
+/** A param value the framework mints. Opaque to core: it forwards the payload to the resolved provisioner and never reads it (ADR-0031). */
+interface ProvisionNeed<T = unknown> {
+  readonly [PROVISION_NEED]: true;
+  /** Selects the provisioner in an extension's `provisions` registry. */
+  readonly brand: symbol;
+  /** Provisioner-defined; core never reads it. */
+  readonly payload: T;
+}
+/** Builds an opaque provisioning need — the declaring package's own brand plus whatever payload its provisioner reads back. */
+declare function provisionNeed<T = undefined>(brand: symbol, payload?: T): ProvisionNeed<T>;
+/** True if `value` is a provisioning need (a `provisionNeed()` result). */
+declare function isProvisionNeed(value: unknown): value is ProvisionNeed;
+declare const PARAM_SOURCE: unique symbol;
+declare const PARAM_NEED: unique symbol;
+/** The wiring value bound to a param at provision time: a target-defined payload core forwards but never inspects. A target (e.g. @prisma/composer-prisma-cloud's `envParam`) builds one via `paramSource()`. */
+interface ParamSource<T = unknown> {
+  readonly [PARAM_SOURCE]: true;
+  /** Target-defined. Core never reads this; the target that authored the source reads it back. */
+  readonly payload: T;
+}
+/** Builds an opaque param source from a target-defined payload — the SPI a deploy target's own source constructor (e.g. `envParam`) calls. Core forwards the source and never inspects the payload. */
+declare function paramSource<T>(payload: T): ParamSource<T>;
+/** True if `value` is a param source (an `envParam` result or a forwarded ctx.params ref). */
+declare function isParamSource(value: unknown): value is ParamSource;
+/** A module's declared param-forwarding slot — nameless, schema-less; the root (or an ancestor module) binds a `ParamSource` and the topology forwards it into a child's real, schema-bearing param. */
+interface ParamNeed {
+  readonly [PARAM_NEED]: true;
+  readonly kind: 'param';
+}
+/** A module's param-forwarding slots: name → the need it declares. */
+type ParamNeeds = Record<string, ParamNeed>;
+/** Declares a module param-forwarding NEED. Nameless — bound to a `ParamSource` by an enclosing scope and forwarded into a child's real param. */
+declare function paramNeed(): ParamNeed;
+/** What `provision(service, { params })` accepts per declared param: a literal (schema-validated when config is built) or an opaque `ParamSource`, taking precedence over `param.default`. Every entry is optional — an unbound param falls back to its `default`. */
+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; };
 /** 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. */
@@ -148,7 +288,7 @@ interface DependencyEnd<C = unknown, Req = unknown> {
   readonly required: Req | undefined;
 }
 /** A Module: the same Deps/Expose boundary a service has, around transparent wiring instead of a black-box body — its `body` runs at Load, not at authoring. */
-interface ModuleNode<D extends Deps = Deps, E extends Expose = Expose, S extends Secrets = Secrets> {
+interface ModuleNode<D extends Deps = Deps, E extends Expose = Expose, S extends Secrets = Secrets, PN extends ParamNeeds = ParamNeeds> {
   readonly [NODE]: true;
   readonly kind: 'module';
   /** Human-readable, given at authoring — logs/diagnostics only. */
@@ -156,18 +296,22 @@ interface ModuleNode<D extends Deps = Deps, E extends Expose = Expose, S extends
   readonly deps: D;
   /** Declared secret input slots (authored as `secrets`) — forwarded to internals via `ctx.secrets` (ADR-0029). */
   readonly secretSlots: S;
+  /** Declared param-forwarding slots (authored as `params`) — forwarded to internals via `ctx.params`, the same rail secrets ride on. */
+  readonly paramSlots: PN;
   readonly expose: E;
-  body(ctx: ModuleContext<D, S>): ModuleOutputs<E> | void;
+  body(ctx: ModuleContext<D, S, PN>): ModuleOutputs<E> | void;
 }
 /**
  * What a module's body receives: its declared inputs as forwardable wiring
  * values, plus `provision` to register the owned services/modules it wires them into.
  */
-interface ModuleContext<D extends Deps, S extends Secrets = Secrets> {
+interface ModuleContext<D extends Deps, S extends Secrets = Secrets, PN extends ParamNeeds = ParamNeeds> {
   /** The module's declared inputs as wiring values — pass them into provision(). */
-  readonly inputs: { [K in keyof D]: InputRef<D[K]> };
+  readonly inputs: { [K in keyof D]: InputRef<D[K]>; };
   /** The module's declared secret slots as forwardable sources — pass them into a child's `secrets` (ADR-0029). */
-  readonly secrets: { readonly [K in keyof S]: SecretSource };
+  readonly secrets: { readonly [K in keyof S]: SecretSource; };
+  /** The module's declared param-forwarding slots as forwardable sources — pass them into a child's `params`. */
+  readonly params: { readonly [K in keyof PN]: ParamSource; };
   /** Registers an owned child (service or module) under a stable id. */
   readonly provision: ModuleBuilder['provision'];
 }
@@ -178,7 +322,7 @@ interface ModuleContext<D extends Deps, S extends Secrets = Secrets> {
  */
 type InputRef<DE> = DE extends DependencyEnd<any, infer Req extends AnyContract> ? RefPort<Req> : never;
 /** One ref-port per declared expose key, contract-checked against `E` (mirrors `Wiring`'s `NoInfer` use). */
-type ModuleOutputs<E extends Expose> = { [P in keyof E]: RefPort<NoInfer<E[P]>> };
+type ModuleOutputs<E extends Expose> = { [P in keyof E]: RefPort<NoInfer<E[P]>>; };
 /**
  * A provisioned producer's port as a wiring-time value: its contract, tagged
  * with which provider produced it (`__providerId`, read by Load to resolve the edge).
@@ -193,7 +337,7 @@ type RefPort<C extends AnyContract> = C & {
  */
 type ProvisionedRef<E extends Expose = Record<never, never>> = {
   readonly id: string;
-} & { readonly [P in keyof E]: RefPort<E[P]> };
+} & { readonly [P in keyof E]: RefPort<E[P]>; };
 /** A DependencyEnd's required contract (unknown for an untyped end). */
 type ReqOf<DE> = DE extends DependencyEnd<any, infer Req> ? Req : never;
 /**
@@ -203,27 +347,36 @@ type ReqOf<DE> = DE extends DependencyEnd<any, infer Req> ? Req : never;
  * into a nested `provision()` call — the same value shape a producer's own
  * exposed port carries.
  */
-type DepBindings<D extends Deps> = { [K in keyof D]: NoInfer<ReqOf<D[K]>> | InputRef<D[K]> };
+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.
+ * 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.
  */
-type ProvisionArgs<D extends Deps, S extends Secrets> = [keyof D] extends [never] ? [keyof S] extends [never] ? [opts?: {
+type ProvisionArgs<D extends Deps, S extends Secrets, PB> = [keyof D] extends [never] ? [keyof S] extends [never] ? [opts?: {
   id?: string;
+  params?: PB;
 }] : [opts: {
   id?: string;
   secrets: SecretBindings<S>;
+  params?: PB;
 }] : [keyof S] extends [never] ? [opts: {
   id?: string;
   deps: DepBindings<D>;
+  params?: PB;
 }] : [opts: {
   id?: string;
   deps: DepBindings<D>;
   secrets: SecretBindings<S>;
+  params?: PB;
 }];
 interface ModuleBuilder {
   /** Provisions an owned resource; its id defaults to the node's `name`. */
@@ -232,26 +385,28 @@ 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. */
-  provision<D extends Deps, E extends Expose, S extends Secrets>(service: ServiceNode<D, any, E, S>, ...args: ProvisionArgs<D, S>): ProvisionedRef<E>;
+  /** 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>;
   /**
    * 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.
    */
-  provision<D extends Deps, E extends Expose, S extends Secrets>(service: ServiceNode<D, any, E, S>, opts: {
+  provision<D extends Deps, P extends Params, E extends Expose, S extends Secrets>(service: ServiceNode<D, P, E, S>, opts: {
     id?: string;
     deps: DepBindings<D>;
     secrets?: SecretBindings<S>;
+    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. */
-  provision<D extends Deps, E extends Expose, S extends Secrets>(child: ModuleNode<D, E, S>, ...args: ProvisionArgs<D, S>): 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>;
   /** 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>(child: ModuleNode<D, E, S>, opts: {
+  provision<D extends Deps, E extends Expose, S extends Secrets, PN extends ParamNeeds>(child: ModuleNode<D, E, S, PN>, opts: {
     id?: string;
     deps: DepBindings<D>;
     secrets?: SecretBindings<S>;
+    params?: ParamNeedBindings<PN>;
   }): ProvisionedRef<E>;
 }
 /** Dependency map: name → the slot the service declares. Only declarations are admitted, never a concrete ResourceNode. */
@@ -259,7 +414,7 @@ type Deps = Record<string, DependencyEnd<any, any>>;
 /** Output-port map: name → the Contract a service exposes for others to depend on. */
 type Expose = Readonly<Record<string, AnyContract>>;
 type Hydrated<N> = N extends DependencyEnd<infer C, any> ? C : never;
-type HydratedDeps<D extends Deps> = { readonly [K in keyof D]: Hydrated<D[K]> };
+type HydratedDeps<D extends Deps> = { readonly [K in keyof D]: Hydrated<D[K]>; };
 /**
  * Seals a node instance after its constructor has assigned all fields — the
  * last statement of a concrete node class's constructor. A free function, not
@@ -325,22 +480,24 @@ declare function dependency<P extends Params, C, Req = unknown>(def: {
  * closed-root shape — `module(name, body)` instead of `module(name, {}, () =>
  * ({}))`.
  */
-declare function module(name: string, body: (ctx: ModuleContext<Record<never, never>, Record<never, never>>) => void): ModuleNode<Record<never, never>, Record<never, never>, Record<never, never>>;
+declare function module(name: string, body: (ctx: ModuleContext<Record<never, never>, Record<never, never>, Record<never, never>>) => void): ModuleNode<Record<never, never>, Record<never, never>, Record<never, never>, Record<never, never>>;
 /**
  * A module with a boundary: `deps` and/or `expose` declare what wires in and
  * out, the same way a service does. The body returns one port per `expose` key.
  */
-declare function module<D extends Deps = Record<never, never>, E extends Expose = Record<never, never>, S extends Secrets = Record<never, never>>(name: string, boundary: {
+declare function module<D extends Deps = Record<never, never>, E extends Expose = Record<never, never>, S extends Secrets = Record<never, never>, PN extends ParamNeeds = Record<never, never>>(name: string, boundary: {
   deps?: D;
   secrets?: S;
+  params?: PN;
   expose?: E;
-}, body: (ctx: ModuleContext<D, S>) => ModuleOutputs<E> | void): ModuleNode<D, E, S>;
+}, body: (ctx: ModuleContext<D, S, PN>) => ModuleOutputs<E> | void): ModuleNode<D, E, S, PN>;
 /**
  * True if `value` was constructed by this module's factories. Checks the
  * brand only, never a prototype — a graph may mix nodes from a different
  * installed copy of core (dual-package hazard).
  */
-declare function isNode(value: unknown): value is ServiceNode | ResourceNode | DependencyEnd | ModuleNode; //#endregion
+declare function isNode(value: unknown): value is ServiceNode | ResourceNode | DependencyEnd | ModuleNode;
+//#endregion
 //#region src/graph-types.d.ts
 /** Path-derived: root-scope children are bare ids ("auth", "db"); a nested module's own children dot-join under its address ("auth.db"). */
 type NodeId = string;
@@ -376,6 +533,22 @@ interface SecretBinding {
   /** The opaque source the root bound the slot to. Core never inspects it; the deploy target reads back its own payload. */
   readonly source: SecretSource;
 }
+/**
+ * A resolved param binding: a `provision()` call bound a service's param
+ * slot to either a literal value or an opaque `ParamSource` — the non-secret
+ * sibling of `SecretBinding`. Unlike a secret, a param binding is not
+ * required for every declared param (a param may fall back to its own
+ * `default`), so this list only carries the ones a `provision()` call
+ * actually bound.
+ */
+interface ParamBinding {
+  /** The graph address of the service that declares the param. */
+  readonly serviceAddress: NodeId;
+  /** The param name on that service. */
+  readonly slot: string;
+  /** A literal value (schema-validated by `buildConfig`) or an opaque `ParamSource` (the deploy target reads its own payload back) — check with `isParamSource`. Core never inspects a `ParamSource`'s payload. */
+  readonly binding: unknown;
+}
 interface Graph {
   readonly root: GraphNode;
   /** Root + one per input, topo-ordered (deps first). */
@@ -383,95 +556,13 @@ interface Graph {
   readonly edges: readonly Edge[];
   /** Every service secret slot resolved to its root-bound opaque source. */
   readonly secrets: readonly SecretBinding[];
+  /** 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[];
 }
 /** Thrown by Load when the graph is malformed. */
 declare class LoadError extends Error {
   constructor(message: string);
-} //#endregion
-//#region src/config.d.ts
-/**
- * A declared config param — pure data: a caller-owned Standard Schema
- * (ADR-0018) plus a few framework facets. The framework carries the schema,
- * infers the value type from it, and validates with it, without ever
- * enumerating permitted shapes. Turning a value into stored config and back is
- * the deploy target's job, not the param's (ADR-0019) — the same split RPC
- * uses: schema on the declaration, wire owned by the mover.
- */
-interface ConfigParam<S extends StandardSchemaV1 = StandardSchemaV1> {
-  readonly schema: S;
-  readonly optional?: boolean;
-  readonly default?: StandardSchemaV1.InferOutput<S>;
 }
-type Params = Record<string, ConfigParam>;
-/** What implementations receive — undefined only for optional params with no default. */
-type Values<P extends Params> = { readonly [K in keyof P]: P[K]['optional'] extends true ? undefined extends P[K]['default'] ? StandardSchemaV1.InferOutput<P[K]['schema']> | undefined : StandardSchemaV1.InferOutput<P[K]['schema']> : StandardSchemaV1.InferOutput<P[K]['schema']> };
-/**
- * The connection face of a dependency: declared params (data) and how
- * validated values become a client (the hydrate behavior slot). Both P and C
- * are INFERRED — the declaration types hydrate's input; the factory types the
- * loaded dep.
- */
-interface Connection<P extends Params = Params, C = unknown> {
-  readonly params: P;
-  hydrate(values: Values<P>): C | Promise<C>;
-}
-/**
- * The enumerable config surface of a service — derivable from the graph
- * alone, nothing booted, no platform keys. The introspection artifact (values
- * absent). `schema` is a data-only projection of the param's Standard Schema
- * (JSON Schema when the vendor supports the optional conversion, a `{ vendor }`
- * tag otherwise) — never the param's functions. Physical locations are the
- * target pack's business. Secrets are not here — they live on their own slot.
- */
-interface ConfigDeclaration {
-  readonly owner: 'service' | {
-    readonly input: string;
-  };
-  readonly name: string;
-  readonly schema: Readonly<Record<string, unknown>>;
-  readonly optional: boolean;
-  readonly default: unknown;
-}
-/**
- * The resolved, typed configuration of one service — what crosses the
- * core→pack boundary. Core builds it at deploy (leaf values are provisioning
- * refs, so the env writes depend on the resources/producer — the ordering
- * edges); the pack serializes it, and at boot reconstructs the identical
- * structure with concrete values. Both forms conform to the shape from
- * configOf. Core never stringifies.
- */
-interface Config {
-  readonly service: Readonly<Record<string, unknown>>;
-  readonly inputs: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
-}
-/**
- * Enumerates every config param the service declares: each input's connection
- * params, then the service's own params. Pure — reads `root.inputs`/`params`
- * directly, executes nothing but the (also pure) schema projection. Deliberately
- * does not go through `Load`: a service's connection-end inputs are legitimately
- * unwired from its own point of view (wiring is an enclosing module's concern),
- * and this introspects one service's declared shape regardless of how — or
- * whether — it composes into a larger graph.
- */
-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.
- */
-declare function provisionManifest(graph: Graph): readonly SecretBinding[];
-interface ParamOptions<T> {
-  readonly optional?: boolean;
-  readonly default?: T;
-}
-/** A string-valued param. */
-declare function string(opts?: ParamOptions<string>): ConfigParam<StandardSchemaV1<string, string>>;
-/** A number-valued param. */
-declare function number(opts?: ParamOptions<number>): ConfigParam<StandardSchemaV1<number, number>>;
-/** A param over any caller-supplied Standard Schema — a structured `jobs`, say. */
-declare function param<S extends StandardSchemaV1>(schema: S, opts?: ParamOptions<StandardSchemaV1.InferOutput<S>>): ConfigParam<S>; //#endregion
 //#endregion
-export { SecretNeed as A, isSecretSource as B, ProvisionedRef as C, RunnableServiceNode as D, ResourceNodeBase as E, Values as F, resource as G, number as H, configOf as I, service as J, secret as K, dependency as L, SecretValues as M, Secrets as N, SecretBinding as O, ServiceNode as P, freezeNode as R, Params as S, ResourceNode as T, param as U, module as V, provisionManifest as W, SecretBox as X, string as Y, SecretString as Z, ModuleBuilder as _, Connection as a, ModuleOutputs as b, Deps as c, Graph as d, GraphNode as f, LoadError as g, InputRef as h, ConfigParam as i, SecretSource as j, SecretBindings as k, Edge as l, HydratedDeps as m, Config as n, Contract as o, Hydrated as p, secretSource as q, ConfigDeclaration as r, DependencyEnd as s, BuildAdapter as t, Expose as u, ModuleContext as v, RefPort as w, NodeId as x, ModuleNode as y, isNode as z };
-//# sourceMappingURL=config-ob5OhCSP-sP3GW3uu.d.mts.map
+export { param as $, ProvisionNeed as A, SecretValues as B, ParamBinding as C, ParamNeeds as D, ParamNeedBindings as E, RunnableServiceNode as F, dependency as G, ServiceNode as H, SecretBinding as I, isParamSource as J, freezeNode as K, SecretBindings as L, RefPort as M, ResourceNode as N, ParamSource as O, ResourceNodeBase as P, number as Q, SecretNeed as R, NodeId as S, ParamNeed as T, Values as U, Secrets as V, configOf as W, isSecretSource as X, isProvisionNeed as Y, module as Z, ModuleBuilder as _, Connection as a, resource as at, ModuleOutputs as b, Deps as c, service as ct, Graph as d, SecretString as dt, paramManifest as et, GraphNode as f, LoadError as g, InputRef as h, ConfigParam as i, provisionNeed as it, ProvisionedRef as j, Params as k, Edge as l, string as lt, HydratedDeps as m, Config as n, paramSource as nt, Contract as o, secret as ot, Hydrated as p, isNode as q, ConfigDeclaration as r, provisionManifest as rt, DependencyEnd as s, secretSource as st, BuildAdapter as t, paramNeed as tt, Expose as u, SecretBox as ut, ModuleContext as v, ParamBindings as w, NODE as x, ModuleNode as y, SecretSource as z };
+//# sourceMappingURL=graph-types-BcbVhojU-C3fhxjPK.d.mts.map

package/dist/graph-types-BcbVhojU-C3fhxjPK.d.mts.map

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

package/dist/{index-CZSc9drz.d.mts → index-BFBNz7Aw.d.mts}

@@ -1,20 +1,5 @@
-import { M as SecretValues, N as Secrets, P as ServiceNode, c as Deps, d as Graph, m as HydratedDeps, n as Config, x as NodeId, y as ModuleNode } from "./config-ob5OhCSP-sP3GW3uu.mjs";
-
-//#region ../../0-framework/1-core/core/dist/graph-BCsfgIWh.d.mts
-//#region src/graph.d.ts
-/**
- * Builds the in-memory graph from a root node. A service root walks its own
- * `inputs`; a module root executes its body (wiring, not user code — the
- * designed exception to imports-run-nothing) and recursively flattens every
- * module it provisions into one graph of hierarchical addresses. A malformed
- * graph is a `LoadError` that names its fix; the individual validation rules
- * live with `loadService` / `loadModule` and are covered by name in the Load
- * tests. Executes nothing of the user's own code beyond module bodies.
- */
-declare function Load(root: ServiceNode | ModuleNode, opts?: {
-  id?: NodeId;
-}): Graph; //#endregion
-//#endregion
+import { B as SecretValues, H as ServiceNode, V as Secrets, c as Deps, m as HydratedDeps, n as Config } from "./graph-types-BcbVhojU-C3fhxjPK.mjs";
+import "./graph-DUSgjmzA-DhtkTqoz.mjs";
 //#region ../../0-framework/1-core/core/dist/index.d.mts
 //#region src/hydrate.d.ts
 /**
@@ -41,7 +26,7 @@ declare function hydrateSync(root: ServiceNode, config: Config): HydratedDeps<De
  * so a secret is redacted by TYPE from here on. A declared slot missing from
  * `values` is a target contract violation, named loudly.
  */
-declare function hydrateSecrets(root: ServiceNode, values: Record<string, string>): SecretValues<Secrets>; //#endregion
+declare function hydrateSecrets(root: ServiceNode, values: Record<string, string>): SecretValues<Secrets>;
 //#endregion
-export { Load as i, hydrateSecrets as n, hydrateSync as r, hydrate as t };
-//# sourceMappingURL=index-CZSc9drz.d.mts.map
+export { hydrateSecrets as n, hydrateSync as r, hydrate as t };
+//# sourceMappingURL=index-BFBNz7Aw.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index-BFBNz7Aw.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;;;;;;;;;;iBAU7D,eAAe,MAAM,aAAa,QAAQ,yBAAyB,aAAa"}

package/dist/index.d.mts

@@ -1,3 +1,4 @@
-import { A as SecretNeed, B as isSecretSource, C as ProvisionedRef, D as RunnableServiceNode, E as ResourceNodeBase, F as Values, G as resource, H as number, I as configOf, J as service, K as secret, L as dependency, M as SecretValues, N as Secrets, O as SecretBinding, P as ServiceNode, R as freezeNode, S as Params, T as ResourceNode, U as param, V as module, W as provisionManifest, X as SecretBox, Y as string, Z as SecretString, _ as ModuleBuilder, a as Connection, b as ModuleOutputs, c as Deps, d as Graph, f as GraphNode, g as LoadError, h as InputRef, i as ConfigParam, j as SecretSource, k as SecretBindings, l as Edge, m as HydratedDeps, n as Config, o as Contract, p as Hydrated, q as secretSource, r as ConfigDeclaration, s as DependencyEnd, t as BuildAdapter, u as Expose, v as ModuleContext, w as RefPort, x as NodeId, y as ModuleNode, z as isNode } from "./config-ob5OhCSP-sP3GW3uu.mjs";
-import { i as Load, n as hydrateSecrets, r as hydrateSync, t as hydrate } from "./index-CZSc9drz.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 Params, 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, isSecretSource, module, number, param, provisionManifest, resource, secret, secretSource, service, string };
+import { $ as param, A as ProvisionNeed, B as SecretValues, C as ParamBinding, D as ParamNeeds, E as ParamNeedBindings, F as RunnableServiceNode, G as dependency, H as ServiceNode, I as SecretBinding, J as isParamSource, K as freezeNode, L as SecretBindings, M as RefPort, N as ResourceNode, O as ParamSource, P as ResourceNodeBase, Q as number, R as SecretNeed, S as NodeId, T as ParamNeed, U as Values, V as Secrets, W as configOf, X as isSecretSource, Y as isProvisionNeed, Z as module, _ as ModuleBuilder, a as Connection, at as resource, b as ModuleOutputs, c as Deps, ct as service, d as Graph, dt as SecretString, et as paramManifest, f as GraphNode, g as LoadError, h as InputRef, i as ConfigParam, it as provisionNeed, j as ProvisionedRef, k as Params, l as Edge, lt as string, m as HydratedDeps, n as Config, nt as paramSource, o as Contract, ot as secret, p as Hydrated, q as isNode, r as ConfigDeclaration, rt as provisionManifest, s as DependencyEnd, st as secretSource, t as BuildAdapter, tt as paramNeed, u as Expose, ut as SecretBox, v as ModuleContext, w as ParamBindings, x as NODE, y as ModuleNode, z as SecretSource } from "./graph-types-BcbVhojU-C3fhxjPK.mjs";
+import { t as Load } from "./graph-DUSgjmzA-DhtkTqoz.mjs";
+import { n as hydrateSecrets, r as hydrateSync, t as hydrate } from "./index-BFBNz7Aw.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 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 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 };

package/dist/index.mjs

@@ -1,3 +1,3 @@
-import { a as freezeNode, c as module, d as secretSource, f as service, i as dependency, l as resource, n as LoadError, o as isNode, r as ResourceNodeBase, s as isSecretSource, t as Load, u as secret } from "./graph-BYdCQKya-BI0njTow.mjs";
-import { a as number, c as string, i as hydrateSync, l as SecretBox, n as hydrate, o as param, r as hydrateSecrets, s as provisionManifest, t as configOf } from "./dist-zBU8ASQW.mjs";
-export { Load, LoadError, ResourceNodeBase, SecretBox, configOf, dependency, freezeNode, hydrate, hydrateSecrets, hydrateSync, isNode, isSecretSource, module, number, param, provisionManifest, 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-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 };

package/dist/{index-Dh4Zro0y.d.mts → nextjs-DLyeRR7M-DwnBjryZ.d.mts}

@@ -1,6 +1,7 @@
-import { t as BuildAdapter } from "./config-ob5OhCSP-sP3GW3uu.mjs";
-//#region ../../0-framework/2-authoring/nextjs/dist/index.d.mts
-//#region src/index.d.ts
+import { t as BuildAdapter } from "./graph-types-BcbVhojU-C3fhxjPK.mjs";
+import "./index-BFBNz7Aw.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. */
 interface NextjsBuildAdapter extends BuildAdapter {
   readonly type: 'nextjs';
@@ -9,7 +10,7 @@ interface NextjsBuildAdapter extends BuildAdapter {
 declare const nextjsBuild: (opts: {
   module: string;
   appDir: string;
-}) => NextjsBuildAdapter; //#endregion
+}) => NextjsBuildAdapter;
 //#endregion
 export { nextjsBuild as n, NextjsBuildAdapter as t };
-//# sourceMappingURL=index-Dh4Zro0y.d.mts.map
+//# sourceMappingURL=nextjs-DLyeRR7M-DwnBjryZ.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"nextjs-DLyeRR7M-DwnBjryZ.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,13 +1,14 @@
-import { a as Bundle, i as AssembleInput, o as ExtensionDescriptor } from "./app-config-BUqyK6N6-CVq3uvHF.mjs";
-import { t as NextjsBuildAdapter } from "./index-Dh4Zro0y.mjs";
-
+import { a as Bundle, d as ExtensionDescriptor, i as AssembleInput } from "./app-config-BPb3LCdH-CH7b8Khi.mjs";
+import "./config-Cqu_-Hna.mjs";
+import "./deploy-Cqu_-Hna.mjs";
+import { t as NextjsBuildAdapter } from "./nextjs-DLyeRR7M-DwnBjryZ.mjs";
 //#region ../../0-framework/2-authoring/nextjs/dist/control.d.mts
-//#region src/control.d.ts
+//#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. */
 declare function standaloneServerPath(build: NextjsBuildAdapter): string;
 declare function assemble(input: AssembleInput): Promise<Bundle>;
 /** The nextjs build extension descriptor — `prisma-composer.config.ts` lists it under `extensions`. */
-declare const nextjsBuild: () => ExtensionDescriptor; //#endregion
+declare const nextjsBuild: () => ExtensionDescriptor;
 //#endregion
 export { type AssembleInput, type Bundle, assemble, nextjsBuild, standaloneServerPath };
 //# sourceMappingURL=nextjs-control.d.mts.map

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"}