@prisma/composer 0.2.0 → 0.3.0-dev.10

package/dist/deploy.mjs

@@ -1,312 +1,2 @@
-import { s as isParamSource, t as Load } from "./graph-BmrUEdo9-6Oq1hSmS.mjs";
-import { r as deserializeContainers } from "./container-transport-DKmKg5JQ-DKWs0ubK.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";
-	}
-};
-/**
-* Resolves one SERVICE-OWN param to its config value. The full resolution
-* order across both value channels:
-*
-* 1. A param claiming BOTH a provision-time binding and a `provision` need
-*    (ADR-0031) is a loud error — two sources for one value.
-* 2. A provision-time binding (a schema-validated literal, or an opaque
-*    `ParamSource` the target resolves at boot per ADR-0019) beats the
-*    declared `default`.
-* 3. A framework-minted `provision` need is resolved per dependency EDGE
-*    against the consumer extension's registry — that path fills CONNECTION
-*    params in `buildConfig`'s inputs loop, never this function. A
-*    service-own param has no edge to mint against, so an unbound need here
-*    falls through like any unbound param.
-* 4. The `default`, else absent (only legal when `optional`), else a loud
-*    error naming the param, the service, and the fix.
-*/
-function resolveParam(node, serviceId, name, param, bound) {
-	if (bound !== void 0) {
-		if (param.provision !== void 0) throw new LowerError(`Param "${name}" of "${serviceId}" (service "${node.name}") has two sources claiming one value: a provision-time binding (${isParamSource(bound) ? "a param source" : "a literal value"}) AND a framework provision need ("${String(param.provision.brand)}") on its declaration — remove the binding or drop the \`provision\` facet.`);
-		if (isParamSource(bound)) return bound;
-		const result = param.schema["~standard"].validate(bound);
-		if (result instanceof Promise) throw new LowerError(`Param "${name}" of "${serviceId}" (service "${node.name}") uses an async Standard Schema — a provision-time literal value requires a synchronous validator.`);
-		if (result.issues !== void 0) {
-			const messages = result.issues.map((issue) => issue.message).join("; ");
-			throw new LowerError(`Param "${name}" of "${serviceId}" (service "${node.name}") received an invalid provision-time value: ${messages}`);
-		}
-		return result.value;
-	}
-	if (param.default !== void 0) return param.default;
-	if (param.optional === true) return void 0;
-	throw new LowerError(`Param "${name}" of "${serviceId}" (service "${node.name}") has no default, is not optional, and was not bound at provision — bind it with a literal value or a param source (e.g. envParam('NAME')) on its provision() call, or give it a default.`);
-}
-/**
-* Assembles a service's typed Config. Connection params come from the
-* dependency edge's lowered outputs — or, for a param carrying a `provision`
-* need (ADR-0031), from `provisioned` (keyed by edge id): the framework mints
-* it, the producer hands nothing over. The service's own params resolve via
-* `resolveParam` (provision-time binding, then default, then loud
-* unbound-required failure).
-*
-* This is also where the connection contract is enforced: a producer that fails to
-* supply a required param its consumer's connection declares fails the deploy
-* here, naming the edge, rather than reaching the consumer as `undefined`.
-*/
-function buildConfig(node, id, graph, lowered, provisioned) {
-	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) ?? {} : {};
-		const values = {};
-		for (const [name, param] of Object.entries(inputNode.connection.params)) {
-			if (param.provision !== void 0) {
-				values[name] = provisioned.get(`${id}.${inputName}`);
-				continue;
-			}
-			const value = producedOutputs[name];
-			if (value === void 0 && param.optional !== true && edge !== void 0) throw new LowerError(`Connection input "${id}.${inputName}" declares param "${name}", but its producer "${edge.from}" did not supply it — the producer's outputs carry [${Object.keys(producedOutputs).join(", ") || "nothing"}]. Add "${name}" to the outputs the producer returns from its lowering, or declare the param optional on the connection.`);
-			values[name] = value;
-		}
-		inputs[inputName] = values;
-	}
-	const boundParams = new Map(graph.params.filter((binding) => binding.serviceAddress === id).map((b) => [b.slot, b.binding]));
-	const service = {};
-	for (const [name, param] of Object.entries(node.params)) {
-		const value = resolveParam(node, id, name, param, boundParams.get(name));
-		if (value !== void 0) service[name] = value;
-	}
-	return {
-		service,
-		inputs
-	};
-}
-/**
-* Joins resolved report entries back to their graph nodes — the last step of a
-* deploy report, run inside the Action with apply's resolved values.
-*
-* The entries cross Alchemy's action-input boundary, so they carry addresses
-* and plain entities only; the graph is held by closure on this side. That
-* split is why this join exists at all, and it is what keeps functions and
-* Standard Schemas (which a node carries, and which the plan's input hash
-* would have to serialize) out of the input.
-*
-* Skips an address the graph no longer holds: entries are data, the graph is
-* truth.
-*/
-function joinDeployment(graph, entries) {
-	const nodes = [];
-	for (const entry of entries) {
-		const node = graph.nodes.find((n) => n.id === entry.address)?.node;
-		if (node === void 0 || node.kind !== "service" && node.kind !== "resource") continue;
-		nodes.push({
-			address: entry.address,
-			node,
-			entities: entry.entities
-		});
-	}
-	return nodes;
-}
-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(", ")}).`);
-}
-/** A provisioned param's need brand isn't registered by the consumer's extension (ADR-0031). */
-function unknownProvisionerError(extension, brand, edgeId) {
-	const known = extension.provisions !== void 0 && extension.provisions.size > 0 ? Array.from(extension.provisions.keys(), String).join(", ") : "(none registered)";
-	return new LowerError(`Extension "${extension.id}" has no provisioner for need "${String(brand)}" (needed by edge "${edgeId}") (known: ${known}).`);
-}
-/** A provisioned edge whose consumer and provider nodes belong to different extensions (ADR-0031). */
-function crossExtensionProvisionError(edgeId) {
-	return new LowerError(`Provisioned edge "${edgeId}" spans two extensions — cross-extension provisioned edges aren't supported yet.`);
-}
-/**
-* More than one provisioned param on one connection (ADR-0031). One edge mints
-* ONE value, keyed by edge id, so a second need on the same connection would
-* silently receive the first's value under the first's brand.
-*/
-function multipleProvisionedParamsError(edgeId, names) {
-	return new LowerError(`Connection input "${edgeId}" declares more than one provisioned param (${names.join(", ")}) — only one provisioned param per connection is supported.`);
-}
-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 descriptor,
-* created with its owning extension's resolved container (`undefined` when
-* that extension declared none). A pure function so the precedence is
-* testable without booting Alchemy.
-*/
-function resolveStateLayer(opts, config, containers) {
-	return opts.state ?? config.state.create(containers.get(config.state.extension));
-}
-/**
-* 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 containers = deserializeContainers(config.extensions, process.env);
-		const lowered = /* @__PURE__ */ new Map();
-		const entries = [];
-		const provisioned = /* @__PURE__ */ new Map();
-		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: void 0,
-				container: containers.get(descriptor.id),
-				lowered,
-				provisioned
-			};
-			applications.set(descriptor.id, yield* descriptor.application.provision(appCtx));
-		}
-		for (const edge of graph.edges) {
-			if (edge.kind !== "dependency") continue;
-			const consumer = graph.nodes.find((n) => n.id === edge.to)?.node;
-			if (consumer === void 0 || consumer.kind !== "service") continue;
-			const slot = consumer.inputs[edge.input];
-			if (slot === void 0) continue;
-			const provisionedParams = Object.entries(slot.connection.params).filter(([, param]) => param.provision !== void 0);
-			if (provisionedParams.length === 0) continue;
-			const edgeId = `${edge.to}.${edge.input}`;
-			if (provisionedParams.length > 1) return yield* Effect.fail(multipleProvisionedParamsError(edgeId, provisionedParams.map(([name]) => name)));
-			const need = provisionedParams[0]?.[1].provision;
-			if (need === void 0) continue;
-			const provider = graph.nodes.find((n) => n.id === edge.from)?.node;
-			if (provider === void 0 || provider.kind !== "service" && provider.kind !== "resource") continue;
-			if (consumer.extension !== provider.extension) return yield* Effect.fail(crossExtensionProvisionError(edgeId));
-			const extension = extensions.get(consumer.extension);
-			if (extension === void 0) return yield* Effect.fail(unknownExtensionError(consumer.extension, edge.to));
-			const provisioner = extension.provisions?.get(need.brand);
-			if (provisioner === void 0) return yield* Effect.fail(unknownProvisionerError(extension, need.brand, edgeId));
-			const ref = yield* provisioner.provision({
-				edgeId,
-				consumerAddress: edge.to,
-				providerAddress: edge.from,
-				input: edge.input,
-				need
-			});
-			provisioned.set(edgeId, ref);
-		}
-		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),
-				container: containers.get(node.extension),
-				lowered,
-				provisioned
-			};
-			const descriptor = yield* descriptorFor(extensions, node, id);
-			if (descriptor.kind === "resource") {
-				const result = yield* descriptor(ctx);
-				lowered.set(id, result.outputs);
-				entries.push({
-					address: id,
-					entities: result.entities
-				});
-				continue;
-			}
-			if (descriptor.kind !== "service") return yield* Effect.fail(wrongKindError(node.extension, node.type, node.kind, descriptor.kind));
-			const service = node;
-			const provisionedNode = yield* descriptor.provision(ctx);
-			const typedConfig = buildConfig(service, id, graph, lowered, provisioned);
-			const serialized = yield* descriptor.serialize(ctx, provisionedNode, 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
-			});
-			const result = yield* descriptor.deploy(ctx, provisionedNode, artifact, serialized);
-			lowered.set(id, result.outputs);
-			entries.push({
-				address: id,
-				entities: result.entities
-			});
-		}
-		if (opts.report !== void 0) {
-			const report = opts.report;
-			yield* Alchemy.Action("composer-deployment-report", (input) => Effect.sync(() => {
-				report({
-					app: opts.name,
-					nodes: joinDeployment(graph, input.entries)
-				});
-			}))({
-				nonce: Date.now(),
-				entries
-			});
-		}
-	});
-}
-/**
-* 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));
-	const containers = deserializeContainers(config.extensions, process.env);
-	return Alchemy.Stack(opts.name, {
-		providers: mergedProviders(config),
-		state: resolveStateLayer(opts, config, containers)
-	}, stackEffect);
-}
-//#endregion
+import { a as lowering, i as lower, n as buildConfig, o as mergedProviders, r as joinDeployment, s as resolveStateLayer, t as LowerError } from "./deploy-C4DxNkJ9-D73lmBqy.mjs";
 export { LowerError, buildConfig, joinDeployment, lower, lowering, mergedProviders, resolveStateLayer };
-
-//# sourceMappingURL=deploy.mjs.map

package/dist/{dist-B0axxnBf.mjs → dist-BdvFDCLV.mjs}

@@ -1,43 +1,5 @@
-import { t as blindCast } from "./casts-Ci5rYYaR.mjs";
-import "./graph-BmrUEdo9-6Oq1hSmS.mjs";
-//#region ../../0-framework/0-foundation/foundation/dist/secret.mjs
-/**
-* 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.
-*/
-const REDACTED = "[REDACTED]";
-var SecretBox = class {
-	#value;
-	constructor(value) {
-		this.#value = value;
-	}
-	/** The sole explicit door to the wrapped value. */
-	expose() {
-		return this.#value;
-	}
-	toString() {
-		return REDACTED;
-	}
-	toJSON() {
-		return REDACTED;
-	}
-	valueOf() {
-		return REDACTED;
-	}
-	[Symbol.toPrimitive]() {
-		return REDACTED;
-	}
-	[Symbol.for("nodejs.util.inspect.custom")]() {
-		return REDACTED;
-	}
-};
-//#endregion
+import "./graph-DgbALPDo-BEHF94BN.mjs";
+import "./secret-DoWGmN7m-DO5Brq1Y.mjs";
 //#region ../../0-framework/1-core/core/dist/index.mjs
 /**
 * A data-only descriptor of a param's schema for introspection — the
@@ -81,20 +43,20 @@ function configOf(root) {
 	return entries;
 }
 /**
-* 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).
 */
-function provisionManifest(graph) {
-	return graph.secrets;
+function inputManifest(graph) {
+	return graph.inputBindings;
 }
 /**
 * 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`.
 */
@@ -131,14 +93,6 @@ function param(schema, opts = {}) {
 	return withFacets(schema, opts);
 }
 /**
-* The boot-side half of the runtime split (see core-model.md § Runtime:
-* booting a service). Core's job at boot is structural only: turn a
-* concrete, typed Config into hydrated deps by calling each input's
-* connection.hydrate with its value slice. No environment read, no
-* validation, no strings — the pack's `load()` already read the process-local
-* stash into a typed Config before calling this.
-*/
-/**
 * 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
@@ -169,25 +123,7 @@ function hydrateSync(root, config) {
 	}
 	return deps;
 }
-/**
-* Wraps each of a service's resolved secret values in a redacting `SecretBox`
-* — what the node's `secrets()` accessor returns (ADR-0021, sibling to
-* `load()`/`config()`). The RESOLUTION of a secret's value (the boot
-* double-lookup that reads the platform var the pointer names) is the target
-* pack's job; core is handed the already-resolved strings and only boxes them,
-* so a secret is redacted by TYPE from here on. A declared slot missing from
-* `values` is a target contract violation, named loudly.
-*/
-function hydrateSecrets(root, values) {
-	const boxed = {};
-	for (const slot of Object.keys(root.secretSlots)) {
-		const value = values[slot];
-		if (value === void 0) throw new Error(`secret slot "${slot}" has no resolved value — the target must resolve every declared secret before hydrateSecrets().`);
-		boxed[slot] = new SecretBox(value);
-	}
-	return blindCast(boxed);
-}
 //#endregion
-export { number as a, provisionManifest as c, hydrateSync as i, string as l, hydrate as n, param as o, hydrateSecrets as r, paramManifest as s, configOf as t, SecretBox as u };
+export { number as a, string as c, inputManifest as i, hydrate as n, param as o, hydrateSync as r, paramManifest as s, configOf as t };
 
-//# sourceMappingURL=dist-B0axxnBf.mjs.map
+//# sourceMappingURL=dist-BdvFDCLV.mjs.map

package/dist/dist-BdvFDCLV.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"dist-BdvFDCLV.mjs","names":[],"sources":["../../../0-framework/1-core/core/dist/index.mjs"],"sourcesContent":["import { _ as LoadError, a as isNode, c as isSecretSource, d as paramSource, f as provisionNeed, g as service, h as secretSource, i as freezeNode, l as module, m as secret, n as ResourceNodeBase, o as isParamSource, p as resource, r as dependency, s as isProvisionNeed, t as Load, u as paramNeed } from \"./graph-DgbALPDo.mjs\";\nimport { SecretBox, isSecretString } from \"@internal/foundation/secret\";\n//#region src/config.ts\n/**\n* A data-only descriptor of a param's schema for introspection — the\n* validator's vendor tag, never the schema's own `validate`. `configOf`\n* reports it where the old model reported `type: 'string' | 'number'`, so the\n* config surface stays enumerable without leaking a function. Nothing consumes\n* more than the vendor tag yet; a richer projection (e.g. a JSON-Schema export\n* when the vendor offers one) is an additive change if a consumer needs it.\n*/\nfunction projectSchema(schema) {\n\treturn { vendor: schema[\"~standard\"].vendor };\n}\n/**\n* Enumerates every config param the service declares: each input's connection\n* params, then the service's own params. Pure — reads `root.inputs`/`params`\n* directly, executes nothing but the (also pure) schema projection. Deliberately\n* does not go through `Load`: a service's connection-end inputs are legitimately\n* unwired from its own point of view (wiring is an enclosing module's concern),\n* and this introspects one service's declared shape regardless of how — or\n* whether — it composes into a larger graph.\n*/\nfunction configOf(root) {\n\tconst entries = [];\n\tfor (const [input, value] of Object.entries(root.inputs)) {\n\t\tif (typeof value !== \"object\" || value === null) continue;\n\t\tfor (const [name, param] of Object.entries(value.connection.params)) entries.push({\n\t\t\towner: { input },\n\t\t\tname,\n\t\t\tschema: projectSchema(param.schema),\n\t\t\toptional: param.optional === true,\n\t\t\tdefault: param.default\n\t\t});\n\t}\n\tfor (const [name, param] of Object.entries(root.params)) entries.push({\n\t\towner: \"service\",\n\t\tname,\n\t\tschema: projectSchema(param.schema),\n\t\toptional: param.optional === true,\n\t\tdefault: param.default\n\t});\n\treturn entries;\n}\n/**\n* The app's input manifest: every service input binding a `provision()` call\n* supplied (ADR-0042). Pure graph introspection, TARGET-AGNOSTIC — a deploy\n* target's recursive descent classifies the binding's leaves (its preflight\n* verifies each `envSecret` leaf's platform var exists before deploy; the\n* values are provisioned out-of-band).\n*/\nfunction inputManifest(graph) {\n\treturn graph.inputBindings;\n}\n/**\n* The app's param-binding manifest: every param a `provision()` call bound —\n* literal or an opaque, target-defined `ParamSource` — at the address that\n* declared it. The param sibling of `provisionManifest`, for a deploy\n* target's own preflight to consume. Pure graph introspection,\n* TARGET-AGNOSTIC; a param this manifest omits simply falls back to its own\n* `default` at `buildConfig`.\n*/\nfunction paramManifest(graph) {\n\treturn graph.params;\n}\nfunction scalarSchema(name, check) {\n\treturn { \"~standard\": {\n\t\tversion: 1,\n\t\tvendor: \"@prisma/composer\",\n\t\tvalidate: (value) => check(value) ? { value } : { issues: [{ message: `expected ${name}, got ${typeof value}` }] }\n\t} };\n}\nconst stringSchema = scalarSchema(\"string\", (v) => typeof v === \"string\");\nconst numberSchema = scalarSchema(\"number\", (v) => typeof v === \"number\" && Number.isFinite(v));\nfunction withFacets(schema, opts) {\n\treturn {\n\t\tschema,\n\t\t...opts.optional !== void 0 ? { optional: opts.optional } : {},\n\t\t...opts.default !== void 0 ? { default: opts.default } : {},\n\t\t...opts.provision !== void 0 ? { provision: opts.provision } : {}\n\t};\n}\n/** A string-valued param. */\nfunction string(opts = {}) {\n\treturn withFacets(stringSchema, opts);\n}\n/** A number-valued param. */\nfunction number(opts = {}) {\n\treturn withFacets(numberSchema, opts);\n}\n/** A param over any caller-supplied Standard Schema — a structured `jobs`, say. */\nfunction param(schema, opts = {}) {\n\treturn withFacets(schema, opts);\n}\n//#endregion\n//#region src/hydrate.ts\n/**\n* Given a service and a concrete typed Config, hydrate every input\n* (connection.hydrate with its typed value slice). A resource dep and a\n* connection dep hydrate through identical machinery — the loaded client is\n* indistinguishable. The service's own params ride alongside in\n* `config.service`; the node's `load()` merges the two.\n*/\nasync function hydrate(root, config) {\n\tconst deps = {};\n\tfor (const [name, inputNode] of Object.entries(root.inputs)) {\n\t\tconst values = config.inputs[name] ?? {};\n\t\tdeps[name] = await inputNode.connection.hydrate(values);\n\t}\n\treturn deps;\n}\n/**\n* Synchronous hydrate — what the node's `load()` uses so\n* `const { db } = service.load()` reads without `await`. Requires every\n* connection.hydrate to return synchronously; a Promise return is a loud error\n* naming the input (an async client factory must use the async `hydrate` path).\n*/\nfunction hydrateSync(root, config) {\n\tconst deps = {};\n\tfor (const [name, inputNode] of Object.entries(root.inputs)) {\n\t\tconst values = config.inputs[name] ?? {};\n\t\tconst client = inputNode.connection.hydrate(values);\n\t\tif (client instanceof Promise) throw new Error(`Connection hydrate for input \"${name}\" returned a Promise; load() requires a synchronous client factory.`);\n\t\tdeps[name] = client;\n\t}\n\treturn deps;\n}\n//#endregion\nexport { Load, LoadError, 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 };\n\n//# sourceMappingURL=index.mjs.map"],"mappings":";;;;;;;;;;;AAWA,SAAS,cAAc,QAAQ;CAC9B,OAAO,EAAE,QAAQ,OAAO,YAAY,CAAC,OAAO;AAC7C;;;;;;;;;;AAUA,SAAS,SAAS,MAAM;CACvB,MAAM,UAAU,CAAC;CACjB,KAAK,MAAM,CAAC,OAAO,UAAU,OAAO,QAAQ,KAAK,MAAM,GAAG;EACzD,IAAI,OAAO,UAAU,YAAY,UAAU,MAAM;EACjD,KAAK,MAAM,CAAC,MAAM,UAAU,OAAO,QAAQ,MAAM,WAAW,MAAM,GAAG,QAAQ,KAAK;GACjF,OAAO,EAAE,MAAM;GACf;GACA,QAAQ,cAAc,MAAM,MAAM;GAClC,UAAU,MAAM,aAAa;GAC7B,SAAS,MAAM;EAChB,CAAC;CACF;CACA,KAAK,MAAM,CAAC,MAAM,UAAU,OAAO,QAAQ,KAAK,MAAM,GAAG,QAAQ,KAAK;EACrE,OAAO;EACP;EACA,QAAQ,cAAc,MAAM,MAAM;EAClC,UAAU,MAAM,aAAa;EAC7B,SAAS,MAAM;CAChB,CAAC;CACD,OAAO;AACR;;;;;;;;AAQA,SAAS,cAAc,OAAO;CAC7B,OAAO,MAAM;AACd;;;;;;;;;AASA,SAAS,cAAc,OAAO;CAC7B,OAAO,MAAM;AACd;AACA,SAAS,aAAa,MAAM,OAAO;CAClC,OAAO,EAAE,aAAa;EACrB,SAAS;EACT,QAAQ;EACR,WAAW,UAAU,MAAM,KAAK,IAAI,EAAE,MAAM,IAAI,EAAE,QAAQ,CAAC,EAAE,SAAS,YAAY,KAAK,QAAQ,OAAO,QAAQ,CAAC,EAAE;CAClH,EAAE;AACH;AACA,MAAM,eAAe,aAAa,WAAW,MAAM,OAAO,MAAM,QAAQ;AACxE,MAAM,eAAe,aAAa,WAAW,MAAM,OAAO,MAAM,YAAY,OAAO,SAAS,CAAC,CAAC;AAC9F,SAAS,WAAW,QAAQ,MAAM;CACjC,OAAO;EACN;EACA,GAAG,KAAK,aAAa,KAAK,IAAI,EAAE,UAAU,KAAK,SAAS,IAAI,CAAC;EAC7D,GAAG,KAAK,YAAY,KAAK,IAAI,EAAE,SAAS,KAAK,QAAQ,IAAI,CAAC;EAC1D,GAAG,KAAK,cAAc,KAAK,IAAI,EAAE,WAAW,KAAK,UAAU,IAAI,CAAC;CACjE;AACD;;AAEA,SAAS,OAAO,OAAO,CAAC,GAAG;CAC1B,OAAO,WAAW,cAAc,IAAI;AACrC;;AAEA,SAAS,OAAO,OAAO,CAAC,GAAG;CAC1B,OAAO,WAAW,cAAc,IAAI;AACrC;;AAEA,SAAS,MAAM,QAAQ,OAAO,CAAC,GAAG;CACjC,OAAO,WAAW,QAAQ,IAAI;AAC/B;;;;;;;;AAUA,eAAe,QAAQ,MAAM,QAAQ;CACpC,MAAM,OAAO,CAAC;CACd,KAAK,MAAM,CAAC,MAAM,cAAc,OAAO,QAAQ,KAAK,MAAM,GAAG;EAC5D,MAAM,SAAS,OAAO,OAAO,SAAS,CAAC;EACvC,KAAK,QAAQ,MAAM,UAAU,WAAW,QAAQ,MAAM;CACvD;CACA,OAAO;AACR;;;;;;;AAOA,SAAS,YAAY,MAAM,QAAQ;CAClC,MAAM,OAAO,CAAC;CACd,KAAK,MAAM,CAAC,MAAM,cAAc,OAAO,QAAQ,KAAK,MAAM,GAAG;EAC5D,MAAM,SAAS,OAAO,OAAO,SAAS,CAAC;EACvC,MAAM,SAAS,UAAU,WAAW,QAAQ,MAAM;EAClD,IAAI,kBAAkB,SAAS,MAAM,IAAI,MAAM,iCAAiC,KAAK,oEAAoE;EACzJ,KAAK,QAAQ;CACd;CACA,OAAO;AACR"}

package/dist/{graph-B7NcPiOr-aSUOCGTH.d.mts → graph-DDpXh7S8-b-93BcHn.d.mts}

@@ -1,5 +1,5 @@
-import { V as ServiceNode, d as Graph, x as NodeId, y as ModuleNode } from "./graph-types-BgT9UEdm-Bz-_OcJH.mjs";
-//#region ../../0-framework/1-core/core/dist/graph-B7NcPiOr.d.mts
+import { U as ServiceNode, d as Graph, w as NodeId, x as ModuleNode } from "./graph-types-C3FOaaXm-C6_rGzfn.mjs";
+//#region ../../0-framework/1-core/core/dist/graph-DDpXh7S8.d.mts
 //#region src/graph.d.ts
 /**
  * Builds the in-memory graph from a root node. A service root walks its own
@@ -15,4 +15,4 @@ declare function Load(root: ServiceNode | ModuleNode, opts?: {
 }): Graph;
 //#endregion
 export { Load as t };
-//# sourceMappingURL=graph-B7NcPiOr-aSUOCGTH.d.mts.map
+//# sourceMappingURL=graph-DDpXh7S8-b-93BcHn.d.mts.map

package/dist/graph-DDpXh7S8-b-93BcHn.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph-DDpXh7S8-b-93BcHn.d.mts","names":[],"sources":["../../../0-framework/1-core/core/dist/graph-DDpXh7S8.d.mts"],"mappings":";;;;;;;;;;;;iBAWiB,KAAK,MAAM,cAAc,YAAY;EACpD,KAAK;IACH"}