@prisma/composer-prisma-cloud 0.1.0 → 0.2.0

package/dist/streams/streams-service.mjs

@@ -0,0 +1,811 @@
+import { dependency, hydrateSecrets, hydrateSync, number, provisionNeed, resource, service, string } from "@prisma/composer";
+import { blindCast } from "@prisma/composer/casts";
+import { RPC_PEER_KEY } from "@prisma/composer/service-rpc";
+import { type } from "arktype";
+import node from "@prisma/composer/node";
+blindCast(Symbol.for("prisma:prisma-cloud-secret-source"));
+/**
+* Walks a node's own params, then each dependency input's connection params —
+* the same enumeration order `configOf` uses, but carrying the raw
+* `ConfigParam` (with its `serialize`/`deserialize`) instead of a pure-data
+* projection.
+*/
+function paramEntries(node) {
+	const entries = [];
+	for (const [input, value] of Object.entries(node.inputs)) {
+		if (typeof value !== "object" || value === null) continue;
+		const params = blindCast(value).connection.params;
+		for (const [name, param] of Object.entries(params)) entries.push({
+			owner: { input },
+			name,
+			param
+		});
+	}
+	for (const [name, param] of Object.entries(node.params)) entries.push({
+		owner: "service",
+		name,
+		param
+	});
+	return entries;
+}
+const configKey = (address, d) => {
+	const segments = address.split(".").filter((s) => s.length > 0);
+	const owner = d.owner === "service" ? [] : [d.owner.input];
+	return [
+		"COMPOSER",
+		...segments,
+		...owner,
+		d.name
+	].join("_").toUpperCase();
+};
+/**
+* Typed value → its stored string. Service-own literals are JSON-encoded; a
+* dependency-input value is a provisioning ref at deploy (and a resolved
+* string at boot) and passes through untouched — LANDMINE: JSON-encoding it
+* would break the ordering edge Alchemy resolves through it.
+*/
+function encode(owner, value) {
+	return owner === "service" ? JSON.stringify(value) : blindCast(value);
+}
+/** Reverses `encode`: JSON-parse a service-own value, take a dependency-input value raw. */
+function decode(owner, raw) {
+	return owner === "service" ? JSON.parse(raw) : raw;
+}
+const PARAM_POINTER_PREFIX = "@composer-param-pointer:";
+/** True iff `raw` is a param pointer row (as opposed to a JSON-encoded literal). */
+const isParamPointerRow = (raw) => raw.startsWith(PARAM_POINTER_PREFIX);
+/** Reverses `encodeParamPointer`: the platform var NAME a pointer row points to. */
+const decodeParamPointer = (raw) => raw.slice(24);
+function coerce(raw, d, key) {
+	if (!(raw !== void 0 && raw !== "")) {
+		if (d.param.default !== void 0) return d.param.default;
+		if (d.param.optional === true) return void 0;
+		throw new Error(`missing required config param "${d.name}" (env ${key})`);
+	}
+	if (d.owner === "service" && isParamPointerRow(raw)) return coerceEnvSourcedParam(raw, d, key);
+	try {
+		return standardValidateSync(d.param.schema, decode(d.owner, raw));
+	} catch (cause) {
+		const message = cause instanceof Error ? cause.message : String(cause);
+		throw new Error(`invalid value for config param "${d.name}" (env ${key}): ${message}`);
+	}
+}
+/**
+* Boot resolution for an env-sourced param: double-lookup (pointer → platform
+* var), then the param's own schema on the raw string — no JSON decode, and
+* no redaction (it's config, not a secret). An UNSET platform var is a loud
+* boot failure naming both the param and the platform var; an EMPTY string is
+* not special-cased here — it reaches the schema like any other value, so it
+* passes iff the schema accepts it (deliberately unlike a literal param's own
+* ""-means-absent rule, and unlike a secret's non-empty requirement).
+*/
+function coerceEnvSourcedParam(raw, d, key) {
+	const platformVar = decodeParamPointer(raw);
+	const value = process.env[platformVar];
+	if (value === void 0) throw new Error(`env-sourced config param "${d.name}" (env ${key} → ${platformVar}) is unset: the platform variable "${platformVar}" was not injected — the deploy did not provision it.`);
+	try {
+		return standardValidateSync(d.param.schema, value);
+	} catch (cause) {
+		const message = cause instanceof Error ? cause.message : String(cause);
+		throw new Error(`invalid value for env-sourced config param "${d.name}" (env ${key} → ${platformVar}): ${message}`);
+	}
+}
+/**
+* Boot: read each declared param from env by its key, reverse the param's own
+* serialization (missing/invalid fails loudly), assemble the typed Config.
+* Secrets ride a separate channel (deserializeSecrets), not this one.
+*/
+const deserialize = (node, address) => {
+	const service = {};
+	const inputs = {};
+	for (const d of paramEntries(node)) {
+		const key = configKey(address, d);
+		const value = coerce(process.env[key], d, key);
+		if (d.owner === "service") service[d.name] = value;
+		else {
+			let bucket = inputs[d.owner.input];
+			if (bucket === void 0) {
+				bucket = {};
+				inputs[d.owner.input] = bucket;
+			}
+			bucket[d.name] = value;
+		}
+	}
+	return {
+		service,
+		inputs
+	};
+};
+/**
+* run()'s setup step: write the resolved config to the environment under
+* address-free keys (configKey("", d) + each serialize suffix), which load()
+* reads back with no address. Uses env, not a module variable, because a
+* framework may fork worker processes that inherit env but not memory.
+* Writes only these keys; nothing else is touched.
+*/
+const stash = (node, config) => {
+	for (const d of paramEntries(node)) {
+		const value = d.owner === "service" ? config.service[d.name] : config.inputs[d.owner.input]?.[d.name];
+		if (value === void 0) continue;
+		process.env[configKey("", d)] = encode(d.owner, value);
+	}
+};
+/** The pointer-row key for a secret slot: COMPOSER_<addr>_<slot> (secrets are service-level). */
+const secretKey = (address, slot) => configKey(address, {
+	owner: "service",
+	name: slot
+});
+/**
+* Boot: resolve every secret slot to its value by double-lookup — read the
+* pointer key (the platform NAME), then read that platform var. A missing
+* pointer or a missing/empty platform value is a loud failure naming both keys.
+* Returns a plain Record for core's `hydrateSecrets` to box.
+*/
+const deserializeSecrets = (node, address) => {
+	const values = {};
+	for (const slot of Object.keys(node.secretSlots)) {
+		const key = secretKey(address, slot);
+		const name = process.env[key];
+		if (name === void 0 || name === "") throw new Error(`missing secret pointer for slot "${slot}" (env ${key}) — the deploy did not write it.`);
+		const value = process.env[name];
+		if (value === void 0 || value === "") throw new Error(`secret "${slot}" is not provisioned (env ${key} → ${name}): the platform var "${name}" is unset or empty.`);
+		values[slot] = value;
+	}
+	return values;
+};
+/**
+* run()'s setup step for secrets: re-emit each slot's pointer NAME under its
+* address-free key, so the address-free `deserializeSecrets` double-looks-up
+* identically. Never the value — the value stays only in the platform var.
+*/
+const stashSecrets = (node, address) => {
+	for (const slot of Object.keys(node.secretSlots)) {
+		const name = process.env[secretKey(address, slot)];
+		if (name === void 0) continue;
+		process.env[secretKey("", slot)] = name;
+	}
+};
+/**
+* Boot: for each reserved provider param, read its address-scoped row through
+* the same `coerce` a declared param uses (JSON-decode, schema-validate), and
+* re-emit it address-free — `stash`'s counterpart for this separate
+* declaration space. A param is declared optional here unconditionally: an
+* absent row means "never provisioned" (local dev, tests, a provider with no
+* registered value for this deploy), never a boot failure, so nothing is
+* stashed and the runtime reader that owns this slot falls back to its own
+* pass-through behavior.
+*/
+function stashProviderParams(entries, address) {
+	for (const entry of entries) {
+		const d = {
+			owner: "service",
+			name: entry.name,
+			param: {
+				schema: entry.schema,
+				optional: true
+			}
+		};
+		const key = configKey(address, d);
+		const value = coerce(process.env[key], d, key);
+		if (value === void 0) continue;
+		process.env[configKey("", d)] = encode("service", value);
+	}
+}
+/** Synchronous Standard Schema validation — see the matching note in core's `config.ts`. */
+function standardValidateSync(schema, value) {
+	const result = schema["~standard"].validate(value);
+	if (result instanceof Promise) throw new Error("config param schema validation must be synchronous — async Standard Schema validators are not supported for config params");
+	if (result.issues !== void 0) throw new Error(`config param validation failed: ${result.issues.map((issue) => issue.message).join("; ")}`);
+	return result.value;
+}
+//#endregion
+//#region ../../1-prisma-cloud/1-extensions/target/dist/provisioned-edges-DIQAR4q4.mjs
+/**
+* RPC's reserved provider param (ADR-0030/ADR-0031): the declaration —
+* name + schema + brand — for the accepted-keys set a provider stores, shared
+* by `control.ts` (which registers the deploy-side `value(refs)` that mints
+* and aggregates it — see its `rpcAcceptedKeysValue`) and `compute.ts` (which
+* validates and stashes it at boot), so writer and reader cannot drift.
+* Finding the edges themselves is `provisioned-edges.ts`'s generic,
+* brand-blind scan — RPC is not special-cased anywhere in this target.
+*
+* This module is reachable from the RUNTIME/authoring side — it must never
+* import `@internal/lowering` or `effect`, or those tokens leak into a user
+* service's bundle (the deploy-side `value(refs)` lives in control.ts, the
+* control-plane-only entry).
+*/
+/**
+* The reserved provider param for RPC's accepted-keys set: the var name is
+* `RPC_ACCEPTED_KEYS`, derived through `configKey` at both ends
+* (`configKey(address, …)` at deploy, `configKey('', …)` at boot — the
+* address-free form is `@internal/service-rpc`'s `RPC_ACCEPTED_KEYS_ENV`). `brand` is
+* `RPC_PEER_KEY`, the same brand `perBindingToken()`'s need carries — control.ts
+* looks its `value(refs)` up by this field.
+*/
+const RPC_ACCEPTED_KEYS_PARAM = {
+	name: "RPC_ACCEPTED_KEYS",
+	schema: type("string[]"),
+	brand: RPC_PEER_KEY
+};
+/** ADR-0031's need brand for the streams module's bearer key — control.ts registers the provisioner under this. */
+const STREAMS_API_KEY = Symbol.for("prisma:streams/api-key");
+/**
+* The provisioning need `durableStreams()`'s `apiKey` param declares: an
+* unguessable value the target mints ONCE PER PROVIDER (not per edge) —
+* `@prisma/streams-server` authenticates a single `API_KEY`, so every
+* consumer of one streams module must present the same value. Per-provider
+* cardinality is provisioner policy (ADR-0031), invisible to core.
+*/
+const streamsApiKeyNeed = () => provisionNeed(STREAMS_API_KEY);
+/**
+* The reserved provider param for the streams bearer key: the var name is
+* `STREAMS_API_KEY`. `brand` is `STREAMS_API_KEY` itself (the same symbol
+* `streamsApiKeyNeed()`'s need carries) — control.ts looks its `value(refs)`
+* up by this field.
+*/
+const STREAMS_API_KEY_PARAM = {
+	name: "STREAMS_API_KEY",
+	schema: type("string"),
+	brand: STREAMS_API_KEY
+};
+configKey("", {
+	owner: "service",
+	name: STREAMS_API_KEY_PARAM.name
+});
+const RESERVED_PROVIDER_PARAMS = [RPC_ACCEPTED_KEYS_PARAM, STREAMS_API_KEY_PARAM];
+blindCast(Symbol.for("prisma:prisma-cloud-param-source"));
+Object.freeze({
+	kind: "s3",
+	__cmp: {
+		url: "",
+		bucket: "",
+		accessKeyId: "",
+		secretAccessKey: ""
+	},
+	satisfies: (required) => required.kind === "s3"
+});
+const reservedParams = { port: number({ default: 3e3 }) };
+/**
+* A Prisma Compute service — declarations only (deps + params + build + the
+* ports it exposes), no descriptor. `params` merges with the reserved
+* `ReservedParams` (`port`); a user param whose name collides with a reserved
+* one fails at authoring, the same way a colliding dependency name does.
+* Returns the extension's runnable/loadable node:
+*   · run(address, boot) — the process controller: deserialize the platform
+*     environment (keyed off `address`, the extension's ONE env read) into a
+*     typed Config, re-emit it under address-free process-local stash keys,
+*     then call boot() to start the app's entry.
+*   · load() / config() — called from inside the app's entry: read the stash;
+*     load() hydrates + memoizes the deps, config() returns the typed params.
+*     Separate accessors so a dep and a param never share a namespace (ADR-0021).
+*
+* `service()`'s underlying node carries `extension: '@prisma/composer-prisma-cloud'` —
+* the control-plane registry key `prisma-composer deploy` resolves through the
+* app's `prisma-composer.config.ts` (ADR-0017). This module loads nothing at
+* deploy time; nodes are pure data.
+*/
+const compute = (def) => {
+	const userParams = def.params ?? blindCast({});
+	for (const reserved of Object.keys(reservedParams)) {
+		if (reserved in def.deps) throw new Error(`compute(): dependency "${reserved}" collides with the reserved service param of the same name — rename the dependency.`);
+		if (reserved in userParams) throw new Error(`compute(): param "${reserved}" collides with the reserved service param of the same name — rename the param.`);
+	}
+	const params = blindCast({
+		...userParams,
+		...reservedParams
+	});
+	const node = service({
+		name: def.name,
+		extension: "@prisma/composer-prisma-cloud",
+		type: "compute",
+		inputs: def.deps,
+		params,
+		...def.secrets !== void 0 ? { secrets: def.secrets } : {},
+		build: def.build,
+		...def.expose !== void 0 ? { expose: def.expose } : {}
+	});
+	let resolved;
+	let loadedDeps;
+	let loadedParams;
+	let loadedSecrets;
+	function processConfig() {
+		if (resolved === void 0) resolved = deserialize(node, "");
+		return resolved;
+	}
+	const runnable = {
+		...node,
+		async run(address, boot) {
+			const config = deserialize(node, address);
+			stash(node, config);
+			stashProviderParams(RESERVED_PROVIDER_PARAMS, address);
+			stashSecrets(node, address);
+			const port = config.service["port"];
+			if (typeof port === "number") process.env["PORT"] = String(port);
+			return boot();
+		},
+		load() {
+			if (loadedDeps === void 0) loadedDeps = blindCast(hydrateSync(node, processConfig()));
+			return loadedDeps;
+		},
+		config() {
+			if (loadedParams === void 0) loadedParams = blindCast(processConfig().service);
+			return loadedParams;
+		},
+		secrets() {
+			if (loadedSecrets === void 0) loadedSecrets = blindCast(hydrateSecrets(node, deserializeSecrets(node, "")));
+			return loadedSecrets;
+		}
+	};
+	return Object.freeze(blindCast(runnable));
+};
+/**
+* The contract a Postgres provides — and the contract its consumers require.
+* `satisfies` compares KIND, not identity: an extension module can be duplicated
+* across a workspace (same rationale as the Symbol.for node brand), and every
+* duplicate's contract must still satisfy. `__cmp` is the connection config a
+* postgres offers; core never inspects it.
+*/
+const postgresContract = Object.freeze({
+	kind: "postgres",
+	__cmp: { url: "" },
+	satisfies: (required) => required.kind === "postgres"
+});
+function postgres(opts) {
+	if (opts?.name !== void 0) return resource({
+		name: opts.name,
+		extension: "@prisma/composer-prisma-cloud",
+		provides: postgresContract
+	});
+	return dependency({
+		type: "postgres",
+		connection: {
+			params: { url: string() },
+			hydrate: (v) => v
+		},
+		required: postgresContract
+	});
+}
+/**
+* The contract the `s3-credentials` resource provides — a minted SigV4 key
+* pair. `satisfies` compares KIND only (mirrors `postgresContract`); `__cmp` is
+* the config the resource offers, which core never inspects.
+*/
+const credentialsContract = Object.freeze({
+	kind: "credentials",
+	__cmp: {
+		accessKeyId: "",
+		secretAccessKey: ""
+	},
+	satisfies: (required) => required.kind === "credentials"
+});
+function s3Credentials(opts) {
+	if (opts?.name !== void 0) return resource({
+		name: opts.name,
+		extension: "@prisma/composer-prisma-cloud",
+		provides: credentialsContract
+	});
+	return dependency({
+		type: "credentials",
+		connection: {
+			params: {
+				accessKeyId: string(),
+				secretAccessKey: string()
+			},
+			hydrate: (v) => v
+		},
+		required: credentialsContract
+	});
+}
+/**
+* The storage service authoring factory — a `compute` service routed to the
+* `s3-store` lowering instead of `compute`'s. It is exactly `compute`'s
+* runnable (run/load/config, deps, params, build, expose) with the routing
+* `type` overridden to `'s3-store'`: nothing at runtime keys off `type` (the
+* serializer keys off the deployment address and each param's owner/name, and
+* `load`/`config` off deps/params), so only the deploy-time descriptor lookup
+* sees the override and routes to the extended-output lowering (§ 5). The
+* return type is compute's exactly (including the reserved `port` param). The
+* storage module (D4b) calls this with its `db`/`credentials` deps, a `bucket`
+* param, and `expose: { store: s3Contract }`.
+*/
+function s3StoreService(def) {
+	const node = compute(def);
+	return Object.freeze(blindCast({
+		...node,
+		type: "s3-store"
+	}));
+}
+//#endregion
+//#region ../../1-prisma-cloud/2-shared-modules/storage/dist/storage-service-DSaZsAC4.mjs
+const s3Contract = Object.freeze({
+	kind: "s3",
+	__cmp: {
+		url: "",
+		bucket: "",
+		accessKeyId: "",
+		secretAccessKey: ""
+	},
+	satisfies: (required) => required.kind === "s3"
+});
+/**
+* A consumer's dependency on an S3-compatible store. No `region` in the
+* binding — the server accepts whatever region string the client signed.
+*/
+function s3() {
+	return dependency({
+		type: "s3",
+		connection: {
+			params: {
+				url: string(),
+				bucket: string(),
+				accessKeyId: string(),
+				secretAccessKey: string()
+			},
+			hydrate: (v) => v
+		},
+		required: s3Contract
+	});
+}
+/**
+* The storage service node (like cron's `scheduler.ts` + `scheduler-service.ts`
+* combined): `storageService` builds the `s3-store` service — a Postgres `db`
+* dependency, a minted `credentials` dependency, a `bucket` param, and the
+* `store` port exposing `s3Contract`. The deploy bootstrap runs the
+* default-exported bare node (`main.run(address, boot)`); the real bucket comes
+* from serialized config at runtime, so the default's `bucket` is only a
+* placeholder — exactly like `scheduler-service.ts` default-exports
+* `cronScheduler({ jobs: [] })`.
+*/
+function storageService(opts) {
+	return s3StoreService({
+		name: "storage",
+		deps: {
+			db: postgres(),
+			credentials: s3Credentials()
+		},
+		params: { bucket: string({ default: opts.bucket }) },
+		build: node({
+			module: new URL("./storage-service.mjs", import.meta.url).href,
+			entry: "./storage-entrypoint.mjs"
+		}),
+		expose: { store: s3Contract }
+	});
+}
+storageService({ bucket: "storage" });
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var require_reusify = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function reusify(Constructor) {
+		var head = new Constructor();
+		var tail = head;
+		function get() {
+			var current = head;
+			if (current.next) head = current.next;
+			else {
+				head = new Constructor();
+				tail = head;
+			}
+			current.next = null;
+			return current;
+		}
+		function release(obj) {
+			tail.next = obj;
+			tail = obj;
+		}
+		return {
+			get,
+			release
+		};
+	}
+	module.exports = reusify;
+}));
+(/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var reusify = require_reusify();
+	function fastqueue(context, worker, _concurrency) {
+		if (typeof context === "function") {
+			_concurrency = worker;
+			worker = context;
+			context = null;
+		}
+		if (!(_concurrency >= 1)) throw new Error("fastqueue concurrency must be equal to or greater than 1");
+		var cache = reusify(Task);
+		var queueHead = null;
+		var queueTail = null;
+		var _running = 0;
+		var errorHandler = null;
+		var self = {
+			push,
+			drain: noop,
+			saturated: noop,
+			pause,
+			paused: false,
+			get concurrency() {
+				return _concurrency;
+			},
+			set concurrency(value) {
+				if (!(value >= 1)) throw new Error("fastqueue concurrency must be equal to or greater than 1");
+				_concurrency = value;
+				if (self.paused) return;
+				for (; queueHead && _running < _concurrency;) {
+					_running++;
+					release();
+				}
+			},
+			running,
+			resume,
+			idle,
+			length,
+			getQueue,
+			unshift,
+			empty: noop,
+			kill,
+			killAndDrain,
+			error,
+			abort
+		};
+		return self;
+		function running() {
+			return _running;
+		}
+		function pause() {
+			self.paused = true;
+		}
+		function length() {
+			var current = queueHead;
+			var counter = 0;
+			while (current) {
+				current = current.next;
+				counter++;
+			}
+			return counter;
+		}
+		function getQueue() {
+			var current = queueHead;
+			var tasks = [];
+			while (current) {
+				tasks.push(current.value);
+				current = current.next;
+			}
+			return tasks;
+		}
+		function resume() {
+			if (!self.paused) return;
+			self.paused = false;
+			if (queueHead === null) {
+				_running++;
+				release();
+				return;
+			}
+			for (; queueHead && _running < _concurrency;) {
+				_running++;
+				release();
+			}
+		}
+		function idle() {
+			return _running === 0 && self.length() === 0;
+		}
+		function push(value, done) {
+			var current = cache.get();
+			current.context = context;
+			current.release = release;
+			current.value = value;
+			current.callback = done || noop;
+			current.errorHandler = errorHandler;
+			if (_running >= _concurrency || self.paused) if (queueTail) {
+				queueTail.next = current;
+				queueTail = current;
+			} else {
+				queueHead = current;
+				queueTail = current;
+				self.saturated();
+			}
+			else {
+				_running++;
+				worker.call(context, current.value, current.worked);
+			}
+		}
+		function unshift(value, done) {
+			var current = cache.get();
+			current.context = context;
+			current.release = release;
+			current.value = value;
+			current.callback = done || noop;
+			current.errorHandler = errorHandler;
+			if (_running >= _concurrency || self.paused) if (queueHead) {
+				current.next = queueHead;
+				queueHead = current;
+			} else {
+				queueHead = current;
+				queueTail = current;
+				self.saturated();
+			}
+			else {
+				_running++;
+				worker.call(context, current.value, current.worked);
+			}
+		}
+		function release(holder) {
+			if (holder) cache.release(holder);
+			var next = queueHead;
+			if (next && _running <= _concurrency) if (!self.paused) {
+				if (queueTail === queueHead) queueTail = null;
+				queueHead = next.next;
+				next.next = null;
+				worker.call(context, next.value, next.worked);
+				if (queueTail === null) self.empty();
+			} else _running--;
+			else if (--_running === 0) self.drain();
+		}
+		function kill() {
+			queueHead = null;
+			queueTail = null;
+			self.drain = noop;
+		}
+		function killAndDrain() {
+			queueHead = null;
+			queueTail = null;
+			self.drain();
+			self.drain = noop;
+		}
+		function abort() {
+			var current = queueHead;
+			queueHead = null;
+			queueTail = null;
+			while (current) {
+				var next = current.next;
+				var callback = current.callback;
+				var errorHandler = current.errorHandler;
+				var val = current.value;
+				var context = current.context;
+				current.value = null;
+				current.callback = noop;
+				current.errorHandler = null;
+				if (errorHandler) errorHandler(/* @__PURE__ */ new Error("abort"), val);
+				callback.call(context, /* @__PURE__ */ new Error("abort"));
+				current.release(current);
+				current = next;
+			}
+			self.drain = noop;
+		}
+		function error(handler) {
+			errorHandler = handler;
+		}
+	}
+	function noop() {}
+	function Task() {
+		this.value = null;
+		this.callback = noop;
+		this.next = null;
+		this.release = noop;
+		this.context = null;
+		this.errorHandler = null;
+		var self = this;
+		this.worked = function worked(err, result) {
+			var callback = self.callback;
+			var errorHandler = self.errorHandler;
+			var val = self.value;
+			self.value = null;
+			self.callback = noop;
+			if (self.errorHandler) errorHandler(err, val);
+			callback.call(self.context, err, result);
+			self.release(self);
+		};
+	}
+	function queueAsPromised(context, worker, _concurrency) {
+		if (typeof context === "function") {
+			_concurrency = worker;
+			worker = context;
+			context = null;
+		}
+		function asyncWrapper(arg, cb) {
+			worker.call(this, arg).then(function(res) {
+				cb(null, res);
+			}, cb);
+		}
+		var queue = fastqueue(context, asyncWrapper, _concurrency);
+		var pushCb = queue.push;
+		var unshiftCb = queue.unshift;
+		queue.push = push;
+		queue.unshift = unshift;
+		queue.drained = drained;
+		return queue;
+		function push(value) {
+			var p = new Promise(function(resolve, reject) {
+				pushCb(value, function(err, result) {
+					if (err) {
+						reject(err);
+						return;
+					}
+					resolve(result);
+				});
+			});
+			p.catch(noop);
+			return p;
+		}
+		function unshift(value) {
+			var p = new Promise(function(resolve, reject) {
+				unshiftCb(value, function(err, result) {
+					if (err) {
+						reject(err);
+						return;
+					}
+					resolve(result);
+				});
+			});
+			p.catch(noop);
+			return p;
+		}
+		function drained() {
+			return new Promise(function(resolve) {
+				process.nextTick(function() {
+					if (queue.idle()) resolve();
+					else {
+						var previousDrain = queue.drain;
+						queue.drain = function() {
+							if (typeof previousDrain === "function") previousDrain();
+							resolve();
+							queue.drain = previousDrain;
+						};
+					}
+				});
+			});
+		}
+	}
+	module.exports = fastqueue;
+	module.exports.promise = queueAsPromised;
+})))();
+/**
+* Default backoff options.
+*/
+const BackoffDefaults = {
+	initialDelay: 100,
+	maxDelay: 6e4,
+	multiplier: 1.3,
+	maxRetries: Infinity
+};
+({ ...BackoffDefaults });
+({ ...BackoffDefaults });
+/**
+* The `streams()` module's own exposed port: a general streams provider,
+* satisfied by kind alone — the `postgresContract` pattern. The module
+* cannot know its eventual consumers' stream names (different consumers of
+* one module each name their own), and the server genuinely serves any
+* stream, so what a consumer requires of its provider is only "is a streams
+* provider". That is exactly what this wide type says, and the empty def
+* map is a legitimate `StreamDefs` value — a placeholder nobody reads, like
+* postgres's `{ url: '' }`. Consumers keep their literal handle typing from
+* `durableStreams(contract)`'s generic parameter, which is independent of
+* the wiring-compatibility type here.
+*/
+const streamsProviderContract = Object.freeze({
+	kind: "streams",
+	__cmp: {},
+	satisfies: (required) => required.kind === "streams"
+});
+string(), string({ provision: streamsApiKeyNeed() });
+/**
+* The streams service node: a plain `compute` service — the contract binding's
+* `url` is a producer output compute's deploy already carries, and its
+* `apiKey` is minted by the target's registered provisioner (ADR-0031), so
+* nothing is left for a bespoke lowering to extend. It declares the `store`
+* dependency (`s3()`, the storage module's port) and the `streams` expose; the
+* bearer key reaches this service through the target's reserved provider
+* param, not through a dependency. The deploy bootstrap runs the
+* default-exported bare node; the real wiring arrives through serialized
+* config at runtime — exactly like `storage-service.ts`.
+*/
+function streamsService() {
+	return compute({
+		name: "streams",
+		deps: { store: s3() },
+		build: node({
+			module: new URL("./streams-service.mjs", import.meta.url).href,
+			entry: "./streams-entrypoint.mjs"
+		}),
+		expose: { streams: streamsProviderContract }
+	});
+}
+var streams_service_default = streamsService();
+//#endregion
+export { streams_service_default as default, streamsService };
+
+//# sourceMappingURL=streams-service.mjs.map