@prisma/composer 0.1.0

package/dist/config-ob5OhCSP-sP3GW3uu.d.mts

@@ -0,0 +1,477 @@
+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
+//#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
+ * protocol brand (`kind`) plus an opaque comparison type (`Cmp`) the core
+ * never inspects. Wiring compatibility is plain TypeScript assignability on
+ * `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()`.
+ */
+interface Contract<Kind extends string, Cmp> {
+  readonly kind: Kind;
+  readonly __cmp: Cmp;
+  satisfies(required: Contract<Kind, unknown>): boolean;
+} //#endregion
+//#region src/node.d.ts
+declare const NODE: unique symbol;
+declare const SECRET_NEED: unique symbol;
+declare const SECRET_SOURCE: unique symbol;
+/** A declared secret input slot — nameless; the root binds it and the topology forwards it in. */
+interface SecretNeed {
+  readonly [SECRET_NEED]: true;
+  readonly kind: 'secret';
+}
+/** A service/module's secret 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> {
+  readonly [SECRET_SOURCE]: true;
+  /** 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. */
+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. */
+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;
+/** 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. */
+interface BuildAdapter {
+  /** The extension package that provides the build descriptor, e.g. "@prisma/composer/node". */
+  readonly extension: string;
+  /** The build descriptor's node ID within its extension, e.g. "node" · "nextjs". */
+  readonly type: string;
+  /** The authoring module's `import.meta.url` — every other path on this descriptor resolves relative to `dirname(module)`. */
+  readonly module: string;
+  /** The app's built runnable, resolved relative to `dirname(module)` and interpreted by the type's build descriptor (e.g. "node": a server file; "nextjs": located in the standalone tree). */
+  readonly entry: string;
+}
+/**
+ * A Resource's identity: the one place a piece of infrastructure exists.
+ * Provisioned by a module, never embedded in a service's deps. `provides`
+ * is the Contract the resource offers; `type` is derived from `provides.kind`.
+ */
+interface ResourceNode<C extends AnyContract = AnyContract> {
+  readonly [NODE]: true;
+  readonly kind: 'resource';
+  /** Human-readable, given at authoring — logs/diagnostics only; identity remains the deploy address (ADR-0006). */
+  readonly name: string;
+  /** The extension package that authored this node, e.g. "@prisma/composer-prisma-cloud" — the registry key at deploy. */
+  readonly extension: string;
+  readonly type: C['kind'];
+  /** The Contract this resource provides — the resource's single port. */
+  readonly provides: C;
+}
+/**
+ * A Service: inputs + its own declared params + how it is built. Inspectable,
+ * 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> {
+  readonly [NODE]: true;
+  readonly kind: 'service';
+  /** Human-readable, given at authoring — logs/diagnostics only; identity remains the deploy address (ADR-0006). */
+  readonly name: string;
+  /** The extension package that authored this node, e.g. "@prisma/composer-prisma-cloud" — the registry key at deploy. */
+  readonly extension: string;
+  readonly type: string;
+  readonly inputs: D;
+  /** Service-level config declarations (e.g. port). */
+  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;
+  /** 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. */
+  readonly expose: E | undefined;
+}
+/**
+ * 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).
+ */
+interface RunnableServiceNode<D extends Deps = Deps, P extends Params = Params, E extends Expose = Expose, S extends Secrets = Secrets> extends ServiceNode<D, P, E, S> {
+  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>;
+}
+/**
+ * A service's dependency slot. At Load the enclosing module wires a
+ * producer's ref into it; at run it hydrates a client via Connection. `Req`
+ * is the required contract (`unknown` for an untyped end like `http()`).
+ */
+interface DependencyEnd<C = unknown, Req = unknown> {
+  readonly [NODE]: true;
+  readonly kind: 'dependency';
+  /** Human-readable, given at authoring — logs/diagnostics only. */
+  readonly name: string;
+  readonly type: string;
+  readonly connection: Connection<Params, C>;
+  /** The required contract, or `undefined` for an untyped end (e.g. `http()`). */
+  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> {
+  readonly [NODE]: true;
+  readonly kind: 'module';
+  /** Human-readable, given at authoring — logs/diagnostics only. */
+  readonly name: string;
+  readonly deps: D;
+  /** Declared secret input slots (authored as `secrets`) — forwarded to internals via `ctx.secrets` (ADR-0029). */
+  readonly secretSlots: S;
+  readonly expose: E;
+  body(ctx: ModuleContext<D, S>): 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> {
+  /** The module's declared inputs as wiring values — pass them into provision(). */
+  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 };
+  /** Registers an owned child (service or module) under a stable id. */
+  readonly provision: ModuleBuilder['provision'];
+}
+/**
+ * A module's forwarded-input value: the same ref-port shape a producer's
+ * output carries, so it flows down a nested `provision()` call indistinguishably
+ * from a sibling's exposed port.
+ */
+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]>> };
+/**
+ * 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).
+ */
+type RefPort<C extends AnyContract> = C & {
+  readonly __providerId: string;
+};
+/**
+ * What `provision(id, service)` hands back: a stable id plus one ref-port per
+ * exposed contract. `provision(id, resource)` returns the same shape with the
+ * resource's one port flattened onto the ref itself.
+ */
+type ProvisionedRef<E extends Expose = Record<never, never>> = {
+  readonly id: string;
+} & { 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;
+/**
+ * The producers that satisfy a node's declared dependency slots — one ref per
+ * slot, checked against its required contract. A slot also accepts
+ * `InputRef<D[K]>` so a module body can forward its own `ctx.inputs` straight
+ * 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]> };
+/**
+ * `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.
+ */
+type ProvisionArgs<D extends Deps, S extends Secrets> = [keyof D] extends [never] ? [keyof S] extends [never] ? [opts?: {
+  id?: string;
+}] : [opts: {
+  id?: string;
+  secrets: SecretBindings<S>;
+}] : [keyof S] extends [never] ? [opts: {
+  id?: string;
+  deps: DepBindings<D>;
+}] : [opts: {
+  id?: string;
+  deps: DepBindings<D>;
+  secrets: SecretBindings<S>;
+}];
+interface ModuleBuilder {
+  /** Provisions an owned resource; its id defaults to the node's `name`. */
+  provision<C extends AnyContract>(resource: ResourceNode<C>, opts?: {
+    id?: string;
+  }): {
+    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>;
+  /**
+   * 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: {
+    id?: string;
+    deps: DepBindings<D>;
+    secrets?: SecretBindings<S>;
+  }): 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>;
+  /** 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: {
+    id?: string;
+    deps: DepBindings<D>;
+    secrets?: SecretBindings<S>;
+  }): ProvisionedRef<E>;
+}
+/** Dependency map: name → the slot the service declares. Only declarations are admitted, never a concrete ResourceNode. */
+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]> };
+/**
+ * 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
+ * a base-class method, so an instance stays structurally a plain frozen node.
+ */
+declare function freezeNode<T extends object>(node: T): T;
+/**
+ * Everything `resource()` establishes, minus the freeze — an extension
+ * whose resource node carries extra fields extends this, assigns them, and
+ * calls `freezeNode(this)` as its constructor's last statement.
+ */
+declare abstract class ResourceNodeBase<C extends AnyContract = AnyContract> implements ResourceNode<C> {
+  readonly [NODE]: true;
+  readonly kind: "resource";
+  readonly name: string;
+  readonly extension: string;
+  readonly type: C['kind'];
+  readonly provides: C;
+  constructor(def: {
+    name: string;
+    extension: string;
+    provides: C;
+  });
+}
+/**
+ * Constructs a branded, frozen Resource node — an identity plus the Contract
+ * it provides; the routing `type` is the contract's `kind`. Pure — nothing
+ * is provisioned until a module provisions it.
+ */
+declare function resource<C extends AnyContract>(def: {
+  name: string;
+  extension: string;
+  provides: C;
+}): ResourceNode<C>;
+/**
+ * Constructs a branded, frozen Service node — declarations only (inputs,
+ * params, 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: {
+  name: string;
+  extension: string;
+  type: string;
+  inputs: D;
+  params: P;
+  secrets?: S;
+  build: BuildAdapter;
+  expose?: E;
+}): ServiceNode<D, P, E, S>;
+/**
+ * Constructs a branded, frozen DependencyEnd. `required` (if given) is the
+ * contract Load compares a wired ref against via `satisfies()`; an unnamed
+ * end's diagnostic `name` falls back to its `type`.
+ */
+declare function dependency<P extends Params, C, Req = unknown>(def: {
+  name?: string;
+  type: string;
+  connection: Connection<P, C>;
+  required?: Req;
+}): DependencyEnd<C, Req>;
+/**
+ * A closed root: no `deps`, no `expose`, nothing wiring in or out. The body
+ * only provisions and needs no return. Omitting the boundary argument IS the
+ * 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>>;
+/**
+ * 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: {
+  deps?: D;
+  secrets?: S;
+  expose?: E;
+}, body: (ctx: ModuleContext<D, S>) => ModuleOutputs<E> | void): ModuleNode<D, E, S>;
+/**
+ * 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
+//#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;
+interface GraphNode {
+  readonly id: NodeId;
+  readonly node: ServiceNode | ResourceNode | DependencyEnd | ModuleNode;
+}
+/**
+ * `input`: a service consumes its own declared dependency slot — from the
+ * slot node to the service. `dependency`: a service consumes a provisioned
+ * producer (a service or a resource — the one wiring mechanism) — from the
+ * producer to the consumer, labeled with the consumer's input name (from the
+ * module wiring).
+ */
+interface Edge {
+  readonly from: NodeId;
+  readonly to: NodeId;
+  readonly input: string;
+  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.
+ */
+interface SecretBinding {
+  /** The graph address of the service that declares the secret slot. */
+  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;
+}
+interface Graph {
+  readonly root: GraphNode;
+  /** 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[];
+}
+/** 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

package/dist/config.d.mts

@@ -0,0 +1,2 @@
+import { f as NodeDescriptor, h as PrismaAppConfig, m as PreflightInput, o as ExtensionDescriptor, v as defineConfig } from "./app-config-BUqyK6N6-CVq3uvHF.mjs";
+export { ExtensionDescriptor, NodeDescriptor, PreflightInput, PrismaAppConfig, defineConfig };

package/dist/config.mjs

@@ -0,0 +1,9 @@
+//#region ../../0-framework/1-core/core/dist/config.mjs
+/** Typed identity — exists so `prisma-composer.config.ts` gets checked against PrismaAppConfig where it is written. */
+function defineConfig(config) {
+	return config;
+}
+//#endregion
+export { defineConfig };
+
+//# sourceMappingURL=config.mjs.map

package/dist/config.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.mjs","names":[],"sources":["../../../0-framework/1-core/core/dist/config.mjs"],"sourcesContent":["//#region src/app-config.ts\n/** Typed identity — exists so `prisma-composer.config.ts` gets checked against PrismaAppConfig where it is written. */\nfunction defineConfig(config) {\n\treturn config;\n}\n//#endregion\nexport { defineConfig };\n\n//# sourceMappingURL=config.mjs.map"],"mappings":";;AAEA,SAAS,aAAa,QAAQ;CAC7B,OAAO;AACR"}

package/dist/deploy-BVVgDSdq.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/deploy.d.mts

@@ -0,0 +1,2 @@
+import { S as resolveStateLayer, _ as buildConfig, a as Bundle, b as lowering, c as LowerError, d as Lowering, g as ServiceLowering, i as AssembleInput, l as LowerOptions, n as ApplicationDescriptor, p as PackageInput, r as Artifact, s as LowerContext, t as AlchemyStateLayer, u as LoweredNode, x as mergedProviders, y as lower } from "./app-config-BUqyK6N6-CVq3uvHF.mjs";
+export { AlchemyStateLayer, ApplicationDescriptor, Artifact, AssembleInput, Bundle, LowerContext, LowerError, LowerOptions, LoweredNode, Lowering, PackageInput, ServiceLowering, buildConfig, lower, lowering, mergedProviders, resolveStateLayer };

package/dist/deploy.mjs

@@ -0,0 +1,154 @@
+import { t as Load } from "./graph-BYdCQKya-BI0njTow.mjs";
+import * as Alchemy from "alchemy";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+//#region ../../0-framework/1-core/core/dist/deploy.mjs
+var LowerError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "LowerError";
+	}
+};
+/** Assembles a service's typed Config from its dependency edges' lowered outputs plus its own param defaults. */
+function buildConfig(node, id, graph, lowered) {
+	const inputs = {};
+	for (const [inputName, inputNode] of Object.entries(node.inputs)) {
+		const edge = graph.edges.find((e) => e.to === id && e.input === inputName && e.kind === "dependency");
+		const producedOutputs = edge !== void 0 ? lowered.get(edge.from)?.outputs ?? {} : {};
+		const values = {};
+		for (const name of Object.keys(inputNode.connection.params)) values[name] = producedOutputs[name];
+		inputs[inputName] = values;
+	}
+	const service = {};
+	for (const [name, param] of Object.entries(node.params)) if (param.default !== void 0) service[name] = param.default;
+	return {
+		service,
+		inputs
+	};
+}
+function missingBundleError(id) {
+	return new LowerError(`No bundle provided for service "${id}" (opts.bundles["${id}"] is required).`);
+}
+function duplicateExtensionError(id) {
+	return new LowerError(`Extension "${id}" is listed more than once in \`extensions\` — each extension id must be unique.`);
+}
+/** Registries as extension id → descriptor. Fails on a duplicate id — the CLI validates config, but lowering() is the programmatic escape hatch that doesn't. */
+function extensionsById(config) {
+	const map = /* @__PURE__ */ new Map();
+	for (const extension of config.extensions) {
+		if (map.has(extension.id)) return Effect.fail(duplicateExtensionError(extension.id));
+		map.set(extension.id, extension);
+	}
+	return Effect.succeed(map);
+}
+function unknownExtensionError(extension, id) {
+	return new LowerError(`No extension "${extension}" is configured (needed by node "${id}") — add it to prisma-composer.config.ts's \`extensions\` (import its /control entry and list its descriptor).`);
+}
+function unknownNodeTypeError(extension, type) {
+	return new LowerError(`Extension "${extension.id}" has no descriptor for node type "${type}" (known: ${Object.keys(extension.nodes).join(", ")}).`);
+}
+function wrongKindError(extension, type, expected, got) {
+	return new LowerError(`Extension "${extension}"'s descriptor for node type "${type}" is a "${got}" descriptor — this node needs a "${expected}" descriptor.`);
+}
+/** Looks up one node's descriptor: extension by `node.extension`, then descriptor by `node.type`, then the kind check. */
+function descriptorFor(extensions, node, id) {
+	const extension = extensions.get(node.extension);
+	if (extension === void 0) return Effect.fail(unknownExtensionError(node.extension, id));
+	const descriptor = extension.nodes[node.type];
+	if (descriptor === void 0) return Effect.fail(unknownNodeTypeError(extension, node.type));
+	if (descriptor.kind !== node.kind) return Effect.fail(wrongKindError(node.extension, node.type, node.kind, descriptor.kind));
+	return Effect.succeed(descriptor);
+}
+/**
+* The state-layer precedence a deploy resolves to: an explicit opts.state
+* always wins; failing that, the config's own (required) state. A pure
+* function so the precedence is testable without booting Alchemy.
+*/
+function resolveStateLayer(opts, config) {
+	return opts.state ?? config.state();
+}
+/**
+* All configured extensions' providers merged, config array order — an
+* extension without `providers` is skipped; no used-extensions-only
+* filtering (ADR-0017's pinned providers rule).
+*/
+function mergedProviders(config) {
+	const [first, ...rest] = config.extensions.flatMap((extension) => extension.providers !== void 0 ? [extension.providers()] : []);
+	return first === void 0 ? Layer.empty : Layer.mergeAll(first, ...rest);
+}
+/**
+* Composable form for mixed stacks: hand-wired Alchemy resources alongside Prisma App nodes in one stack effect.
+* Fails with LowerError or whatever an extension's lowering raises — the error type is open.
+*/
+function lowering(root, config, opts) {
+	return Effect.gen(function* () {
+		const graph = Load(root, { id: opts.name });
+		const extensions = yield* extensionsById(config);
+		const lowered = /* @__PURE__ */ new Map();
+		const noApplication = { outputs: {} };
+		const applications = /* @__PURE__ */ new Map();
+		for (const descriptor of config.extensions) {
+			if (descriptor.application === void 0) continue;
+			const appCtx = {
+				id: graph.root.id,
+				address: "",
+				node: graph.root.node,
+				graph,
+				opts,
+				application: noApplication,
+				lowered
+			};
+			applications.set(descriptor.id, yield* descriptor.application.provision(appCtx));
+		}
+		for (const { id, node } of graph.nodes) {
+			if (node.kind === "module") continue;
+			if (node.kind === "dependency") continue;
+			const ctx = {
+				id,
+				address: id,
+				node,
+				graph,
+				opts,
+				application: applications.get(node.extension) ?? noApplication,
+				lowered
+			};
+			const descriptor = yield* descriptorFor(extensions, node, id);
+			if (descriptor.kind === "resource") {
+				lowered.set(id, yield* descriptor(ctx));
+				continue;
+			}
+			if (descriptor.kind !== "service") return yield* Effect.fail(wrongKindError(node.extension, node.type, node.kind, descriptor.kind));
+			const service = node;
+			const provisioned = yield* descriptor.provision(ctx);
+			const typedConfig = buildConfig(service, id, graph, lowered);
+			const serialized = yield* descriptor.serialize(ctx, provisioned, typedConfig);
+			const bundle = opts.bundles[id];
+			if (bundle === void 0) return yield* Effect.fail(missingBundleError(id));
+			const artifact = yield* descriptor.package(ctx, {
+				assembled: {
+					dir: bundle.dir,
+					entry: bundle.entry
+				},
+				address: id
+			});
+			lowered.set(id, yield* descriptor.deploy(ctx, provisioned, artifact, serialized));
+		}
+		return { outputs: {} };
+	});
+}
+/**
+* The whole-stack wrapper: Load → route each node through the config's
+* extension registries → an Alchemy Stack (the default export the alchemy
+* CLI consumes).
+*/
+function lower(root, config, opts) {
+	const stackEffect = Effect.orDie(lowering(root, config, opts));
+	return Alchemy.Stack(opts.name, {
+		providers: mergedProviders(config),
+		state: resolveStateLayer(opts, config)
+	}, stackEffect);
+}
+//#endregion
+export { LowerError, buildConfig, lower, lowering, mergedProviders, resolveStateLayer };
+
+//# sourceMappingURL=deploy.mjs.map