@geekmidas/constructs 7.0.1 → 10.0.0-alpha.0

package/dist/clone-DblgEZZa.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"clone-DblgEZZa.mjs","names":["instance: T","delta: Record<string, unknown>"],"sources":["../src/clone.ts"],"sourcesContent":["/**\n * Cloning a builder, without enumerating its fields.\n *\n * The builders were mutable singletons that reset themselves by listing every\n * field at the end of `.handle()`. Two things followed from that, and both were\n * real:\n *\n * A configured base could not be reused. `const fn = f.logger(log)` handed back\n * `f` itself, and the first `.handle()` reset `_logger` to the default — so the\n * second handler built from that base silently logged somewhere else. Every\n * field in the reset block behaved the same way, which made\n * `f.logger(l).timeout(60_000)` a base that worked exactly once.\n *\n * And a field left out of the reset list leaked into the next handler instead.\n * `_constructs` was left out, so a function was granted a bucket a *previous*\n * function had declared — an over-grant in the field a deploy reads to size an\n * IAM policy.\n *\n * Both are the same defect: a hand-maintained list of fields that has to be\n * edited every time a field is added, and is silent when it isn't. So this\n * copies whatever the instance actually has, and the list stops existing. The\n * prototype is carried over, so `instanceof` and every method still resolve,\n * and the constructor is deliberately not re-run — this copies state rather\n * than initialising it.\n *\n * Fields must be replaced rather than mutated in place: a clone and its parent\n * share whatever array a field points at, so `_events.push(…)` would be seen by\n * both. Every builder assigns a fresh array instead, which is what makes\n * sharing the reference safe.\n */\nexport function cloneWith<T extends object>(\n\tinstance: T,\n\tdelta: Record<string, unknown>,\n): T {\n\tconst next = Object.create(Object.getPrototypeOf(instance)) as T;\n\n\treturn Object.assign(next, instance, delta);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,SAAgB,UACfA,UACAC,OACI;CACJ,MAAM,OAAO,OAAO,OAAO,OAAO,eAAe,SAAS,CAAC;AAE3D,QAAO,OAAO,OAAO,MAAM,UAAU,MAAM;AAC3C"}

package/dist/clone-Dy0cR2SZ.cjs

@@ -0,0 +1,45 @@
+
+//#region src/clone.ts
+/**
+* Cloning a builder, without enumerating its fields.
+*
+* The builders were mutable singletons that reset themselves by listing every
+* field at the end of `.handle()`. Two things followed from that, and both were
+* real:
+*
+* A configured base could not be reused. `const fn = f.logger(log)` handed back
+* `f` itself, and the first `.handle()` reset `_logger` to the default — so the
+* second handler built from that base silently logged somewhere else. Every
+* field in the reset block behaved the same way, which made
+* `f.logger(l).timeout(60_000)` a base that worked exactly once.
+*
+* And a field left out of the reset list leaked into the next handler instead.
+* `_constructs` was left out, so a function was granted a bucket a *previous*
+* function had declared — an over-grant in the field a deploy reads to size an
+* IAM policy.
+*
+* Both are the same defect: a hand-maintained list of fields that has to be
+* edited every time a field is added, and is silent when it isn't. So this
+* copies whatever the instance actually has, and the list stops existing. The
+* prototype is carried over, so `instanceof` and every method still resolve,
+* and the constructor is deliberately not re-run — this copies state rather
+* than initialising it.
+*
+* Fields must be replaced rather than mutated in place: a clone and its parent
+* share whatever array a field points at, so `_events.push(…)` would be seen by
+* both. Every builder assigns a fresh array instead, which is what makes
+* sharing the reference safe.
+*/
+function cloneWith(instance, delta) {
+	const next = Object.create(Object.getPrototypeOf(instance));
+	return Object.assign(next, instance, delta);
+}
+
+//#endregion
+Object.defineProperty(exports, 'cloneWith', {
+  enumerable: true,
+  get: function () {
+    return cloneWith;
+  }
+});
+//# sourceMappingURL=clone-Dy0cR2SZ.cjs.map

package/dist/clone-Dy0cR2SZ.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"clone-Dy0cR2SZ.cjs","names":["instance: T","delta: Record<string, unknown>"],"sources":["../src/clone.ts"],"sourcesContent":["/**\n * Cloning a builder, without enumerating its fields.\n *\n * The builders were mutable singletons that reset themselves by listing every\n * field at the end of `.handle()`. Two things followed from that, and both were\n * real:\n *\n * A configured base could not be reused. `const fn = f.logger(log)` handed back\n * `f` itself, and the first `.handle()` reset `_logger` to the default — so the\n * second handler built from that base silently logged somewhere else. Every\n * field in the reset block behaved the same way, which made\n * `f.logger(l).timeout(60_000)` a base that worked exactly once.\n *\n * And a field left out of the reset list leaked into the next handler instead.\n * `_constructs` was left out, so a function was granted a bucket a *previous*\n * function had declared — an over-grant in the field a deploy reads to size an\n * IAM policy.\n *\n * Both are the same defect: a hand-maintained list of fields that has to be\n * edited every time a field is added, and is silent when it isn't. So this\n * copies whatever the instance actually has, and the list stops existing. The\n * prototype is carried over, so `instanceof` and every method still resolve,\n * and the constructor is deliberately not re-run — this copies state rather\n * than initialising it.\n *\n * Fields must be replaced rather than mutated in place: a clone and its parent\n * share whatever array a field points at, so `_events.push(…)` would be seen by\n * both. Every builder assigns a fresh array instead, which is what makes\n * sharing the reference safe.\n */\nexport function cloneWith<T extends object>(\n\tinstance: T,\n\tdelta: Record<string, unknown>,\n): T {\n\tconst next = Object.create(Object.getPrototypeOf(instance)) as T;\n\n\treturn Object.assign(next, instance, delta);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,SAAgB,UACfA,UACAC,OACI;CACJ,MAAM,OAAO,OAAO,OAAO,OAAO,eAAe,SAAS,CAAC;AAE3D,QAAO,OAAO,OAAO,MAAM,UAAU,MAAM;AAC3C"}

package/dist/construct-interface-BfjcOD_E.cjs

@@ -0,0 +1,117 @@
+
+//#region src/construct-interface.ts
+/**
+* The edge that points at a construct.
+*
+* A construct's *canonical* node is the one carrying its own id — the others are
+* things it owns rather than things it is, like the signing secret beside an
+* auth server — so the kind an edge records is read off that node instead of
+* being written down beside it. Hand-written kinds are the same fact stated
+* twice, and the copy is what goes stale when a construct changes what it
+* declares.
+*
+* @throws {NotAConstruct} when the value declares nothing under its own id.
+*/
+function edgeTo(construct) {
+	const canonical = construct.declare().find((declaration) => declaration.id === construct.id);
+	if (!canonical) throw new NotAConstruct(construct);
+	return {
+		target: construct.id,
+		kind: canonical.kind
+	};
+}
+/**
+* The services of a list of constructs, at runtime.
+*
+* @throws {NotAConstruct} when handed something else. The type already refuses
+* it, but a JavaScript caller gets no such warning, and a `Service` slipping
+* through would fail later as an undefined key in the handler.
+*/
+function servicesOf(constructs) {
+	return constructs.map((construct) => {
+		if (!isConsumable(construct)) throw new NotAConstruct(construct);
+		return construct.service;
+	});
+}
+/**
+* The other half of `servicesOf`: the same edge, as the manifest records it.
+*
+* `.dependsOn()` used to keep only the services, which is what a handler runs
+* with — and an id cannot be recovered from a service name reliably, so the
+* edges were gone by the time the build could read them. Both halves are taken
+* from one call now, and `existing` is folded in so repeated `.dependsOn()`
+* calls accumulate the way `.services()` already does.
+*/
+function idsOf(constructs, existing = []) {
+	return [...new Set([...existing, ...constructs.map(({ id }) => id)])];
+}
+/** Something that is not a construct was passed to `.dependsOn()`. */
+var NotAConstruct = class extends Error {
+	constructor(value) {
+		const name = typeof value === "object" && value !== null && "serviceName" in value ? `the service '${String(value.serviceName)}'` : `a ${typeof value}`;
+		super(`.dependsOn() takes constructs, and was given ${name}. Pass it to .services([…]) instead, or lift it with Construct.fromService().`);
+		this.value = value;
+		this.name = "NotAConstruct";
+	}
+};
+/**
+* Whether a value is a construct rather than a bare `Service`.
+*
+* Structural rather than `instanceof`: a construct from a second copy of
+* `@geekmidas/constructs` — a linked workspace, two versions in a lockfile — is
+* still a construct, and `instanceof` is exactly the check that says otherwise.
+*/
+function isConsumable(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const candidate = value;
+	return typeof candidate.id === "string" && typeof candidate.declare === "function" && typeof candidate.service?.serviceName === "string";
+}
+/**
+* The service behind either face.
+*
+* `.database()` and the publisher slots take a construct now; they took a
+* `Service` before and still do, because a hand-written one is exactly what
+* `Construct.fromService` exists to lift and not everything has been lifted.
+*/
+function serviceOf(source) {
+	return isConsumable(source) ? source.service : source;
+}
+
+//#endregion
+Object.defineProperty(exports, 'NotAConstruct', {
+  enumerable: true,
+  get: function () {
+    return NotAConstruct;
+  }
+});
+Object.defineProperty(exports, 'edgeTo', {
+  enumerable: true,
+  get: function () {
+    return edgeTo;
+  }
+});
+Object.defineProperty(exports, 'idsOf', {
+  enumerable: true,
+  get: function () {
+    return idsOf;
+  }
+});
+Object.defineProperty(exports, 'isConsumable', {
+  enumerable: true,
+  get: function () {
+    return isConsumable;
+  }
+});
+Object.defineProperty(exports, 'serviceOf', {
+  enumerable: true,
+  get: function () {
+    return serviceOf;
+  }
+});
+Object.defineProperty(exports, 'servicesOf', {
+  enumerable: true,
+  get: function () {
+    return servicesOf;
+  }
+});
+//# sourceMappingURL=construct-interface-BfjcOD_E.cjs.map

package/dist/construct-interface-BfjcOD_E.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"construct-interface-BfjcOD_E.cjs","names":["construct: Declarable","constructs: T","constructs: readonly Consumable[]","existing: readonly string[]","value: unknown","source: Consumable<TName, TClient> | Service<TName, TClient>"],"sources":["../src/construct-interface.ts"],"sourcesContent":["/**\n * The construct contract.\n *\n * A construct is three things at once — an infrastructure requirement at build\n * time, a runtime capability, and something other code can consume — which is\n * what forces exactly these three members.\n *\n * An **interface**, not a base class: `Endpoint`, `Cron`, `Queue`, and `Topic`\n * can satisfy it without inheritance surgery, a lifted `Service` can satisfy it\n * as a plain object, and `.dependsOn()` gets its enforcement structurally — a\n * `Service` (`{ serviceName, register }`) simply does not match\n * `{ id, declare, service }`, with no `instanceof` anywhere.\n *\n * Lives in its own module while the existing abstract `Construct` class is\n * still in use; it takes that name once the class is gone.\n */\n\nimport type { Declaration, Dependency } from '@geekmidas/manifest';\nimport type { Service } from '@geekmidas/services';\n\n/**\n * @typeParam TName - the construct's canonical id, PascalCase. Keeping it a\n * literal is what lets the service key be `Uncapitalize<TName>` — a TypeScript\n * intrinsic, so no custom transform needs a runtime twin.\n * @typeParam TClient - what consuming this construct hands you. `never` means it\n * owns no address and cannot be consumed: a `Cron` is fired by a schedule and a\n * `Subscriber` is reached through its topic, so `.dependsOn()` on either is a\n * compile error rather than a stub that throws.\n */\nexport interface Construct<TName extends string = string, TClient = never> {\n\t/** Canonical, PascalCase, unique within the manifest. */\n\treadonly id: TName;\n\n\t/**\n\t * The build-time face: what this construct contributes to the manifest.\n\t *\n\t * Returns an array because some constructs contribute more than one node — a\n\t * queue declares the queue and its worker, a database declares its migrator\n\t * and seeder. Most return one.\n\t */\n\tdeclare(): Declaration[];\n\n\t/**\n\t * The consumable face — the address this construct owns, as a client.\n\t *\n\t * A field assigned once rather than a getter. `Construct.getEnvironment`\n\t * caches by service *object*, and `Topic.publisher` returns a fresh literal\n\t * on every access, so that cache never hits for topics or queues today.\n\t */\n\treadonly service: [TClient] extends [never]\n\t\t? never\n\t\t: Service<Uncapitalize<TName>, TClient>;\n}\n\n/**\n * The build-time face alone — an id and what it contributes to the manifest.\n *\n * Weaker than {@link Consumable} on purpose. An edge is not always an\n * injection: a site depending on an API needs that API's *address at build\n * time* and has no service record to put a client into, so requiring one would\n * make the weakest kind of edge impossible to express with the strongest\n * interface. Discovery asks this same question and nothing more.\n */\nexport interface Declarable<TName extends string = string> {\n\treadonly id: TName;\n\tdeclare(): Declaration[];\n}\n\n/**\n * The edge that points at a construct.\n *\n * A construct's *canonical* node is the one carrying its own id — the others are\n * things it owns rather than things it is, like the signing secret beside an\n * auth server — so the kind an edge records is read off that node instead of\n * being written down beside it. Hand-written kinds are the same fact stated\n * twice, and the copy is what goes stale when a construct changes what it\n * declares.\n *\n * @throws {NotAConstruct} when the value declares nothing under its own id.\n */\nexport function edgeTo(construct: Declarable): Dependency {\n\tconst canonical = construct\n\t\t.declare()\n\t\t.find((declaration) => declaration.id === construct.id);\n\n\tif (!canonical) throw new NotAConstruct(construct);\n\n\treturn { target: construct.id, kind: canonical.kind };\n}\n\n/** What consuming a construct hands you. */\nexport type Infer<C> =\n\tC extends Construct<string, infer TClient> ? TClient : never;\n\n/** A construct's canonical id. */\nexport type NameOf<C> =\n\tC extends Construct<infer TName, unknown> ? TName : never;\n\n/**\n * What `.dependsOn([…])` accepts: a construct that owns a client.\n *\n * Structural, and deliberately narrower than {@link Construct} — it is the\n * face a *consumer* needs, so the builders can accept a database, a bucket, a\n * mail sender, a queue, or a topic without importing any of them. A plain\n * `Service` is not one of these, which is the point: constructs-only confines\n * env sniffing to `.services()` and the explicit lift, so retiring that method\n * retires implicit inference with it.\n */\nexport interface Consumable<TName extends string = string, TClient = unknown> {\n\treadonly id: TName;\n\treadonly service: Service<Uncapitalize<TName>, TClient>;\n\tdeclare(): Declaration[];\n}\n\n/**\n * The services a list of constructs dissolves into.\n *\n * A mapped tuple, so `[db, uploads]` types as `[Service<'orders', Kysely<DB>>,\n * Service<'uploads', StorageClient>]` and the handler's service record gains\n * both keys — the same machinery `.services()` already uses, which is why\n * `dependsOn` needs no type plumbing of its own.\n */\nexport type ServicesOf<T extends readonly Consumable[]> = {\n\t[K in keyof T]: T[K]['service'];\n};\n\n/**\n * The services of a list of constructs, at runtime.\n *\n * @throws {NotAConstruct} when handed something else. The type already refuses\n * it, but a JavaScript caller gets no such warning, and a `Service` slipping\n * through would fail later as an undefined key in the handler.\n */\nexport function servicesOf<const T extends readonly Consumable[]>(\n\tconstructs: T,\n): ServicesOf<T> {\n\treturn constructs.map((construct) => {\n\t\tif (!isConsumable(construct)) throw new NotAConstruct(construct);\n\n\t\treturn construct.service;\n\t}) as ServicesOf<T>;\n}\n\n/**\n * The other half of `servicesOf`: the same edge, as the manifest records it.\n *\n * `.dependsOn()` used to keep only the services, which is what a handler runs\n * with — and an id cannot be recovered from a service name reliably, so the\n * edges were gone by the time the build could read them. Both halves are taken\n * from one call now, and `existing` is folded in so repeated `.dependsOn()`\n * calls accumulate the way `.services()` already does.\n */\nexport function idsOf(\n\tconstructs: readonly Consumable[],\n\texisting: readonly string[] = [],\n): string[] {\n\treturn [...new Set([...existing, ...constructs.map(({ id }) => id)])];\n}\n\n/** Something that is not a construct was passed to `.dependsOn()`. */\nexport class NotAConstruct extends Error {\n\tconstructor(readonly value: unknown) {\n\t\tconst name =\n\t\t\ttypeof value === 'object' && value !== null && 'serviceName' in value\n\t\t\t\t? `the service '${String((value as { serviceName: unknown }).serviceName)}'`\n\t\t\t\t: `a ${typeof value}`;\n\n\t\tsuper(\n\t\t\t`.dependsOn() takes constructs, and was given ${name}. ` +\n\t\t\t\t`Pass it to .services([…]) instead, or lift it with ` +\n\t\t\t\t`Construct.fromService().`,\n\t\t);\n\t\tthis.name = 'NotAConstruct';\n\t}\n}\n\n/**\n * Whether a value is a construct rather than a bare `Service`.\n *\n * Structural rather than `instanceof`: a construct from a second copy of\n * `@geekmidas/constructs` — a linked workspace, two versions in a lockfile — is\n * still a construct, and `instanceof` is exactly the check that says otherwise.\n */\nexport function isConsumable(value: unknown): value is Consumable {\n\tif (typeof value !== 'object' || value === null) return false;\n\n\tconst candidate = value as Partial<Consumable>;\n\n\treturn (\n\t\ttypeof candidate.id === 'string' &&\n\t\ttypeof candidate.declare === 'function' &&\n\t\ttypeof (candidate.service as Service | undefined)?.serviceName === 'string'\n\t);\n}\n\n/**\n * The service behind either face.\n *\n * `.database()` and the publisher slots take a construct now; they took a\n * `Service` before and still do, because a hand-written one is exactly what\n * `Construct.fromService` exists to lift and not everything has been lifted.\n */\nexport function serviceOf<TName extends string, TClient>(\n\tsource: Consumable<TName, TClient> | Service<TName, TClient>,\n): Service<TName, TClient> {\n\t// A construct's service key is `Uncapitalize<TName>` and the slot is typed\n\t// by `TName`; the two describe the same key, and only the cast says so.\n\treturn isConsumable(source)\n\t\t? (source.service as unknown as Service<TName, TClient>)\n\t\t: (source as Service<TName, TClient>);\n}\n"],"mappings":";;;;;;;;;;;;;;AAgFA,SAAgB,OAAOA,WAAmC;CACzD,MAAM,YAAY,UAChB,SAAS,CACT,KAAK,CAAC,gBAAgB,YAAY,OAAO,UAAU,GAAG;AAExD,MAAK,UAAW,OAAM,IAAI,cAAc;AAExC,QAAO;EAAE,QAAQ,UAAU;EAAI,MAAM,UAAU;CAAM;AACrD;;;;;;;;AA6CD,SAAgB,WACfC,YACgB;AAChB,QAAO,WAAW,IAAI,CAAC,cAAc;AACpC,OAAK,aAAa,UAAU,CAAE,OAAM,IAAI,cAAc;AAEtD,SAAO,UAAU;CACjB,EAAC;AACF;;;;;;;;;;AAWD,SAAgB,MACfC,YACAC,WAA8B,CAAE,GACrB;AACX,QAAO,CAAC,GAAG,IAAI,IAAI,CAAC,GAAG,UAAU,GAAG,WAAW,IAAI,CAAC,EAAE,IAAI,KAAK,GAAG,AAAC,EAAE;AACrE;;AAGD,IAAa,gBAAb,cAAmC,MAAM;CACxC,YAAqBC,OAAgB;EACpC,MAAM,cACE,UAAU,YAAY,UAAU,QAAQ,iBAAiB,SAC5D,eAAe,OAAQ,MAAmC,YAAY,CAAC,MACvE,WAAW,MAAM;AAEtB,SACE,+CAA+C,KAAK,+EAGrD;EAVmB;AAWpB,OAAK,OAAO;CACZ;AACD;;;;;;;;AASD,SAAgB,aAAaA,OAAqC;AACjE,YAAW,UAAU,YAAY,UAAU,KAAM,QAAO;CAExD,MAAM,YAAY;AAElB,eACQ,UAAU,OAAO,mBACjB,UAAU,YAAY,qBACrB,UAAU,SAAiC,gBAAgB;AAEpE;;;;;;;;AASD,SAAgB,UACfC,QAC0B;AAG1B,QAAO,aAAa,OAAO,GACvB,OAAO,UACP;AACJ"}

package/dist/construct-interface-BqwRNYA2.d.mts

@@ -0,0 +1,131 @@
+import { Declaration, Dependency } from "@geekmidas/manifest";
+import { Service } from "@geekmidas/services";
+
+//#region src/construct-interface.d.ts
+
+/**
+ * @typeParam TName - the construct's canonical id, PascalCase. Keeping it a
+ * literal is what lets the service key be `Uncapitalize<TName>` — a TypeScript
+ * intrinsic, so no custom transform needs a runtime twin.
+ * @typeParam TClient - what consuming this construct hands you. `never` means it
+ * owns no address and cannot be consumed: a `Cron` is fired by a schedule and a
+ * `Subscriber` is reached through its topic, so `.dependsOn()` on either is a
+ * compile error rather than a stub that throws.
+ */
+interface Construct<TName extends string = string, TClient = never> {
+  /** Canonical, PascalCase, unique within the manifest. */
+  readonly id: TName;
+  /**
+   * The build-time face: what this construct contributes to the manifest.
+   *
+   * Returns an array because some constructs contribute more than one node — a
+   * queue declares the queue and its worker, a database declares its migrator
+   * and seeder. Most return one.
+   */
+  declare(): Declaration[];
+  /**
+   * The consumable face — the address this construct owns, as a client.
+   *
+   * A field assigned once rather than a getter. `Construct.getEnvironment`
+   * caches by service *object*, and `Topic.publisher` returns a fresh literal
+   * on every access, so that cache never hits for topics or queues today.
+   */
+  readonly service: [TClient] extends [never] ? never : Service<Uncapitalize<TName>, TClient>;
+}
+/**
+ * The build-time face alone — an id and what it contributes to the manifest.
+ *
+ * Weaker than {@link Consumable} on purpose. An edge is not always an
+ * injection: a site depending on an API needs that API's *address at build
+ * time* and has no service record to put a client into, so requiring one would
+ * make the weakest kind of edge impossible to express with the strongest
+ * interface. Discovery asks this same question and nothing more.
+ */
+interface Declarable<TName extends string = string> {
+  readonly id: TName;
+  declare(): Declaration[];
+}
+/**
+ * The edge that points at a construct.
+ *
+ * A construct's *canonical* node is the one carrying its own id — the others are
+ * things it owns rather than things it is, like the signing secret beside an
+ * auth server — so the kind an edge records is read off that node instead of
+ * being written down beside it. Hand-written kinds are the same fact stated
+ * twice, and the copy is what goes stale when a construct changes what it
+ * declares.
+ *
+ * @throws {NotAConstruct} when the value declares nothing under its own id.
+ */
+declare function edgeTo(construct: Declarable): Dependency;
+/** What consuming a construct hands you. */
+type Infer<C> = C extends Construct<string, infer TClient> ? TClient : never;
+/** A construct's canonical id. */
+type NameOf<C> = C extends Construct<infer TName, unknown> ? TName : never;
+/**
+ * What `.dependsOn([…])` accepts: a construct that owns a client.
+ *
+ * Structural, and deliberately narrower than {@link Construct} — it is the
+ * face a *consumer* needs, so the builders can accept a database, a bucket, a
+ * mail sender, a queue, or a topic without importing any of them. A plain
+ * `Service` is not one of these, which is the point: constructs-only confines
+ * env sniffing to `.services()` and the explicit lift, so retiring that method
+ * retires implicit inference with it.
+ */
+interface Consumable<TName extends string = string, TClient = unknown> {
+  readonly id: TName;
+  readonly service: Service<Uncapitalize<TName>, TClient>;
+  declare(): Declaration[];
+}
+/**
+ * The services a list of constructs dissolves into.
+ *
+ * A mapped tuple, so `[db, uploads]` types as `[Service<'orders', Kysely<DB>>,
+ * Service<'uploads', StorageClient>]` and the handler's service record gains
+ * both keys — the same machinery `.services()` already uses, which is why
+ * `dependsOn` needs no type plumbing of its own.
+ */
+type ServicesOf<T extends readonly Consumable[]> = { [K in keyof T]: T[K]['service'] };
+/**
+ * The services of a list of constructs, at runtime.
+ *
+ * @throws {NotAConstruct} when handed something else. The type already refuses
+ * it, but a JavaScript caller gets no such warning, and a `Service` slipping
+ * through would fail later as an undefined key in the handler.
+ */
+declare function servicesOf<const T extends readonly Consumable[]>(constructs: T): ServicesOf<T>;
+/**
+ * The other half of `servicesOf`: the same edge, as the manifest records it.
+ *
+ * `.dependsOn()` used to keep only the services, which is what a handler runs
+ * with — and an id cannot be recovered from a service name reliably, so the
+ * edges were gone by the time the build could read them. Both halves are taken
+ * from one call now, and `existing` is folded in so repeated `.dependsOn()`
+ * calls accumulate the way `.services()` already does.
+ */
+declare function idsOf(constructs: readonly Consumable[], existing?: readonly string[]): string[];
+/** Something that is not a construct was passed to `.dependsOn()`. */
+declare class NotAConstruct extends Error {
+  readonly value: unknown;
+  constructor(value: unknown);
+}
+/**
+ * Whether a value is a construct rather than a bare `Service`.
+ *
+ * Structural rather than `instanceof`: a construct from a second copy of
+ * `@geekmidas/constructs` — a linked workspace, two versions in a lockfile — is
+ * still a construct, and `instanceof` is exactly the check that says otherwise.
+ */
+declare function isConsumable(value: unknown): value is Consumable;
+/**
+ * The service behind either face.
+ *
+ * `.database()` and the publisher slots take a construct now; they took a
+ * `Service` before and still do, because a hand-written one is exactly what
+ * `Construct.fromService` exists to lift and not everything has been lifted.
+ */
+declare function serviceOf<TName extends string, TClient>(source: Consumable<TName, TClient> | Service<TName, TClient>): Service<TName, TClient>;
+//# sourceMappingURL=construct-interface.d.ts.map
+//#endregion
+export { Construct, Consumable, Declarable, Infer, NameOf, NotAConstruct, ServicesOf, edgeTo, idsOf, isConsumable, serviceOf, servicesOf };
+//# sourceMappingURL=construct-interface-BqwRNYA2.d.mts.map

package/dist/construct-interface-BqwRNYA2.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"construct-interface-BqwRNYA2.d.mts","names":[],"sources":["../src/construct-interface.ts"],"sourcesContent":[],"mappings":";;;;;AAiEuB;AAevB;;;;AAAyD;AAWzD;;;AACW,UA/DM,SA+DN,CAAA,cAAA,MAAA,GAAA,MAAA,EAAA,UAAA,KAAA,CAAA,CAAA;EAAS;EAAiC,SAAA,EAAA,EA7DvC,KA6DuC;EAGzC;;;;;AACsC;AAYlD;EAA2B,OAAA,EAAA,EApEf,WAoEe,EAAA;EAAA;;;;;;AAGJ;EAWX,SAAA,OAAU,EAAA,CAzEF,OAyEE,CAAA,SAAA,CAAA,KAAA,CAAA,GAAA,KAAA,GAvElB,OAuEkB,CAvEV,YAuEU,CAvEG,KAuEH,CAAA,EAvEW,OAuEX,CAAA;;;;;;AACF;AAUpB;;;;AAEc,UAxEG,UAwEH,CAAA,cAAA,MAAA,GAAA,MAAA,CAAA,CAAA;EAAC,SAAZ,EAAA,EAvEW,KAuEX;EAAU,OAAA,EAAA,EAtED,WAsEC,EAAA;AAiBb;AAQA;AAuBA;AAmBA;;;;;;;;;;AAEG,iBA5Ha,MAAA,CA4Hb,SAAA,EA5H+B,UA4H/B,CAAA,EA5H4C,UA4H5C;AAAO;KAjHE,WACX,UAAU,mCAAmC;;KAGlC,YACX,UAAU,kCAAkC;;;;;;;;;;;UAY5B;eACH;oBACK,QAAQ,aAAa,QAAQ;aACpC;;;;;;;;;;KAWA,8BAA8B,8BAC7B,IAAI,EAAE;;;;;;;;iBAUH,oCAAoC,0BACvC,IACV,WAAW;;;;;;;;;;iBAiBE,KAAA,sBACM;;cAOT,aAAA,SAAsB,KAAK;;;;;;;;;;;iBAuBxB,YAAA,2BAAuC;;;;;;;;iBAmBvC,iDACP,WAAW,OAAO,WAAW,QAAQ,OAAO,WAClD,QAAQ,OAAO"}

package/dist/construct-interface-D2nNkHUN.d.cts

@@ -0,0 +1,131 @@
+import { Service } from "@geekmidas/services";
+import { Declaration, Dependency } from "@geekmidas/manifest";
+
+//#region src/construct-interface.d.ts
+
+/**
+ * @typeParam TName - the construct's canonical id, PascalCase. Keeping it a
+ * literal is what lets the service key be `Uncapitalize<TName>` — a TypeScript
+ * intrinsic, so no custom transform needs a runtime twin.
+ * @typeParam TClient - what consuming this construct hands you. `never` means it
+ * owns no address and cannot be consumed: a `Cron` is fired by a schedule and a
+ * `Subscriber` is reached through its topic, so `.dependsOn()` on either is a
+ * compile error rather than a stub that throws.
+ */
+interface Construct<TName extends string = string, TClient = never> {
+  /** Canonical, PascalCase, unique within the manifest. */
+  readonly id: TName;
+  /**
+   * The build-time face: what this construct contributes to the manifest.
+   *
+   * Returns an array because some constructs contribute more than one node — a
+   * queue declares the queue and its worker, a database declares its migrator
+   * and seeder. Most return one.
+   */
+  declare(): Declaration[];
+  /**
+   * The consumable face — the address this construct owns, as a client.
+   *
+   * A field assigned once rather than a getter. `Construct.getEnvironment`
+   * caches by service *object*, and `Topic.publisher` returns a fresh literal
+   * on every access, so that cache never hits for topics or queues today.
+   */
+  readonly service: [TClient] extends [never] ? never : Service<Uncapitalize<TName>, TClient>;
+}
+/**
+ * The build-time face alone — an id and what it contributes to the manifest.
+ *
+ * Weaker than {@link Consumable} on purpose. An edge is not always an
+ * injection: a site depending on an API needs that API's *address at build
+ * time* and has no service record to put a client into, so requiring one would
+ * make the weakest kind of edge impossible to express with the strongest
+ * interface. Discovery asks this same question and nothing more.
+ */
+interface Declarable<TName extends string = string> {
+  readonly id: TName;
+  declare(): Declaration[];
+}
+/**
+ * The edge that points at a construct.
+ *
+ * A construct's *canonical* node is the one carrying its own id — the others are
+ * things it owns rather than things it is, like the signing secret beside an
+ * auth server — so the kind an edge records is read off that node instead of
+ * being written down beside it. Hand-written kinds are the same fact stated
+ * twice, and the copy is what goes stale when a construct changes what it
+ * declares.
+ *
+ * @throws {NotAConstruct} when the value declares nothing under its own id.
+ */
+declare function edgeTo(construct: Declarable): Dependency;
+/** What consuming a construct hands you. */
+type Infer<C> = C extends Construct<string, infer TClient> ? TClient : never;
+/** A construct's canonical id. */
+type NameOf<C> = C extends Construct<infer TName, unknown> ? TName : never;
+/**
+ * What `.dependsOn([…])` accepts: a construct that owns a client.
+ *
+ * Structural, and deliberately narrower than {@link Construct} — it is the
+ * face a *consumer* needs, so the builders can accept a database, a bucket, a
+ * mail sender, a queue, or a topic without importing any of them. A plain
+ * `Service` is not one of these, which is the point: constructs-only confines
+ * env sniffing to `.services()` and the explicit lift, so retiring that method
+ * retires implicit inference with it.
+ */
+interface Consumable<TName extends string = string, TClient = unknown> {
+  readonly id: TName;
+  readonly service: Service<Uncapitalize<TName>, TClient>;
+  declare(): Declaration[];
+}
+/**
+ * The services a list of constructs dissolves into.
+ *
+ * A mapped tuple, so `[db, uploads]` types as `[Service<'orders', Kysely<DB>>,
+ * Service<'uploads', StorageClient>]` and the handler's service record gains
+ * both keys — the same machinery `.services()` already uses, which is why
+ * `dependsOn` needs no type plumbing of its own.
+ */
+type ServicesOf<T extends readonly Consumable[]> = { [K in keyof T]: T[K]['service'] };
+/**
+ * The services of a list of constructs, at runtime.
+ *
+ * @throws {NotAConstruct} when handed something else. The type already refuses
+ * it, but a JavaScript caller gets no such warning, and a `Service` slipping
+ * through would fail later as an undefined key in the handler.
+ */
+declare function servicesOf<const T extends readonly Consumable[]>(constructs: T): ServicesOf<T>;
+/**
+ * The other half of `servicesOf`: the same edge, as the manifest records it.
+ *
+ * `.dependsOn()` used to keep only the services, which is what a handler runs
+ * with — and an id cannot be recovered from a service name reliably, so the
+ * edges were gone by the time the build could read them. Both halves are taken
+ * from one call now, and `existing` is folded in so repeated `.dependsOn()`
+ * calls accumulate the way `.services()` already does.
+ */
+declare function idsOf(constructs: readonly Consumable[], existing?: readonly string[]): string[];
+/** Something that is not a construct was passed to `.dependsOn()`. */
+declare class NotAConstruct extends Error {
+  readonly value: unknown;
+  constructor(value: unknown);
+}
+/**
+ * Whether a value is a construct rather than a bare `Service`.
+ *
+ * Structural rather than `instanceof`: a construct from a second copy of
+ * `@geekmidas/constructs` — a linked workspace, two versions in a lockfile — is
+ * still a construct, and `instanceof` is exactly the check that says otherwise.
+ */
+declare function isConsumable(value: unknown): value is Consumable;
+/**
+ * The service behind either face.
+ *
+ * `.database()` and the publisher slots take a construct now; they took a
+ * `Service` before and still do, because a hand-written one is exactly what
+ * `Construct.fromService` exists to lift and not everything has been lifted.
+ */
+declare function serviceOf<TName extends string, TClient>(source: Consumable<TName, TClient> | Service<TName, TClient>): Service<TName, TClient>;
+//# sourceMappingURL=construct-interface.d.ts.map
+//#endregion
+export { Construct, Consumable, Declarable, Infer, NameOf, NotAConstruct, ServicesOf, edgeTo, idsOf, isConsumable, serviceOf, servicesOf };
+//# sourceMappingURL=construct-interface-D2nNkHUN.d.cts.map

package/dist/construct-interface-D2nNkHUN.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"construct-interface-D2nNkHUN.d.cts","names":[],"sources":["../src/construct-interface.ts"],"sourcesContent":[],"mappings":";;;;;AAiEuB;AAevB;;;;AAAyD;AAWzD;;;AACW,UA/DM,SA+DN,CAAA,cAAA,MAAA,GAAA,MAAA,EAAA,UAAA,KAAA,CAAA,CAAA;EAAS;EAAiC,SAAA,EAAA,EA7DvC,KA6DuC;EAGzC;;;;;AACsC;AAYlD;EAA2B,OAAA,EAAA,EApEf,WAoEe,EAAA;EAAA;;;;;;AAGJ;EAWX,SAAA,OAAU,EAAA,CAzEF,OAyEE,CAAA,SAAA,CAAA,KAAA,CAAA,GAAA,KAAA,GAvElB,OAuEkB,CAvEV,YAuEU,CAvEG,KAuEH,CAAA,EAvEW,OAuEX,CAAA;;;;;;AACF;AAUpB;;;;AAEc,UAxEG,UAwEH,CAAA,cAAA,MAAA,GAAA,MAAA,CAAA,CAAA;EAAC,SAAZ,EAAA,EAvEW,KAuEX;EAAU,OAAA,EAAA,EAtED,WAsEC,EAAA;AAiBb;AAQA;AAuBA;AAmBA;;;;;;;;;;AAEG,iBA5Ha,MAAA,CA4Hb,SAAA,EA5H+B,UA4H/B,CAAA,EA5H4C,UA4H5C;AAAO;KAjHE,WACX,UAAU,mCAAmC;;KAGlC,YACX,UAAU,kCAAkC;;;;;;;;;;;UAY5B;eACH;oBACK,QAAQ,aAAa,QAAQ;aACpC;;;;;;;;;;KAWA,8BAA8B,8BAC7B,IAAI,EAAE;;;;;;;;iBAUH,oCAAoC,0BACvC,IACV,WAAW;;;;;;;;;;iBAiBE,KAAA,sBACM;;cAOT,aAAA,SAAsB,KAAK;;;;;;;;;;;iBAuBxB,YAAA,2BAAuC;;;;;;;;iBAmBvC,iDACP,WAAW,OAAO,WAAW,QAAQ,OAAO,WAClD,QAAQ,OAAO"}

package/dist/construct-interface-Z4CpS8tK.mjs

@@ -0,0 +1,81 @@
+//#region src/construct-interface.ts
+/**
+* The edge that points at a construct.
+*
+* A construct's *canonical* node is the one carrying its own id — the others are
+* things it owns rather than things it is, like the signing secret beside an
+* auth server — so the kind an edge records is read off that node instead of
+* being written down beside it. Hand-written kinds are the same fact stated
+* twice, and the copy is what goes stale when a construct changes what it
+* declares.
+*
+* @throws {NotAConstruct} when the value declares nothing under its own id.
+*/
+function edgeTo(construct) {
+	const canonical = construct.declare().find((declaration) => declaration.id === construct.id);
+	if (!canonical) throw new NotAConstruct(construct);
+	return {
+		target: construct.id,
+		kind: canonical.kind
+	};
+}
+/**
+* The services of a list of constructs, at runtime.
+*
+* @throws {NotAConstruct} when handed something else. The type already refuses
+* it, but a JavaScript caller gets no such warning, and a `Service` slipping
+* through would fail later as an undefined key in the handler.
+*/
+function servicesOf(constructs) {
+	return constructs.map((construct) => {
+		if (!isConsumable(construct)) throw new NotAConstruct(construct);
+		return construct.service;
+	});
+}
+/**
+* The other half of `servicesOf`: the same edge, as the manifest records it.
+*
+* `.dependsOn()` used to keep only the services, which is what a handler runs
+* with — and an id cannot be recovered from a service name reliably, so the
+* edges were gone by the time the build could read them. Both halves are taken
+* from one call now, and `existing` is folded in so repeated `.dependsOn()`
+* calls accumulate the way `.services()` already does.
+*/
+function idsOf(constructs, existing = []) {
+	return [...new Set([...existing, ...constructs.map(({ id }) => id)])];
+}
+/** Something that is not a construct was passed to `.dependsOn()`. */
+var NotAConstruct = class extends Error {
+	constructor(value) {
+		const name = typeof value === "object" && value !== null && "serviceName" in value ? `the service '${String(value.serviceName)}'` : `a ${typeof value}`;
+		super(`.dependsOn() takes constructs, and was given ${name}. Pass it to .services([…]) instead, or lift it with Construct.fromService().`);
+		this.value = value;
+		this.name = "NotAConstruct";
+	}
+};
+/**
+* Whether a value is a construct rather than a bare `Service`.
+*
+* Structural rather than `instanceof`: a construct from a second copy of
+* `@geekmidas/constructs` — a linked workspace, two versions in a lockfile — is
+* still a construct, and `instanceof` is exactly the check that says otherwise.
+*/
+function isConsumable(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const candidate = value;
+	return typeof candidate.id === "string" && typeof candidate.declare === "function" && typeof candidate.service?.serviceName === "string";
+}
+/**
+* The service behind either face.
+*
+* `.database()` and the publisher slots take a construct now; they took a
+* `Service` before and still do, because a hand-written one is exactly what
+* `Construct.fromService` exists to lift and not everything has been lifted.
+*/
+function serviceOf(source) {
+	return isConsumable(source) ? source.service : source;
+}
+
+//#endregion
+export { NotAConstruct, edgeTo, idsOf, isConsumable, serviceOf, servicesOf };
+//# sourceMappingURL=construct-interface-Z4CpS8tK.mjs.map

package/dist/construct-interface-Z4CpS8tK.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"construct-interface-Z4CpS8tK.mjs","names":["construct: Declarable","constructs: T","constructs: readonly Consumable[]","existing: readonly string[]","value: unknown","source: Consumable<TName, TClient> | Service<TName, TClient>"],"sources":["../src/construct-interface.ts"],"sourcesContent":["/**\n * The construct contract.\n *\n * A construct is three things at once — an infrastructure requirement at build\n * time, a runtime capability, and something other code can consume — which is\n * what forces exactly these three members.\n *\n * An **interface**, not a base class: `Endpoint`, `Cron`, `Queue`, and `Topic`\n * can satisfy it without inheritance surgery, a lifted `Service` can satisfy it\n * as a plain object, and `.dependsOn()` gets its enforcement structurally — a\n * `Service` (`{ serviceName, register }`) simply does not match\n * `{ id, declare, service }`, with no `instanceof` anywhere.\n *\n * Lives in its own module while the existing abstract `Construct` class is\n * still in use; it takes that name once the class is gone.\n */\n\nimport type { Declaration, Dependency } from '@geekmidas/manifest';\nimport type { Service } from '@geekmidas/services';\n\n/**\n * @typeParam TName - the construct's canonical id, PascalCase. Keeping it a\n * literal is what lets the service key be `Uncapitalize<TName>` — a TypeScript\n * intrinsic, so no custom transform needs a runtime twin.\n * @typeParam TClient - what consuming this construct hands you. `never` means it\n * owns no address and cannot be consumed: a `Cron` is fired by a schedule and a\n * `Subscriber` is reached through its topic, so `.dependsOn()` on either is a\n * compile error rather than a stub that throws.\n */\nexport interface Construct<TName extends string = string, TClient = never> {\n\t/** Canonical, PascalCase, unique within the manifest. */\n\treadonly id: TName;\n\n\t/**\n\t * The build-time face: what this construct contributes to the manifest.\n\t *\n\t * Returns an array because some constructs contribute more than one node — a\n\t * queue declares the queue and its worker, a database declares its migrator\n\t * and seeder. Most return one.\n\t */\n\tdeclare(): Declaration[];\n\n\t/**\n\t * The consumable face — the address this construct owns, as a client.\n\t *\n\t * A field assigned once rather than a getter. `Construct.getEnvironment`\n\t * caches by service *object*, and `Topic.publisher` returns a fresh literal\n\t * on every access, so that cache never hits for topics or queues today.\n\t */\n\treadonly service: [TClient] extends [never]\n\t\t? never\n\t\t: Service<Uncapitalize<TName>, TClient>;\n}\n\n/**\n * The build-time face alone — an id and what it contributes to the manifest.\n *\n * Weaker than {@link Consumable} on purpose. An edge is not always an\n * injection: a site depending on an API needs that API's *address at build\n * time* and has no service record to put a client into, so requiring one would\n * make the weakest kind of edge impossible to express with the strongest\n * interface. Discovery asks this same question and nothing more.\n */\nexport interface Declarable<TName extends string = string> {\n\treadonly id: TName;\n\tdeclare(): Declaration[];\n}\n\n/**\n * The edge that points at a construct.\n *\n * A construct's *canonical* node is the one carrying its own id — the others are\n * things it owns rather than things it is, like the signing secret beside an\n * auth server — so the kind an edge records is read off that node instead of\n * being written down beside it. Hand-written kinds are the same fact stated\n * twice, and the copy is what goes stale when a construct changes what it\n * declares.\n *\n * @throws {NotAConstruct} when the value declares nothing under its own id.\n */\nexport function edgeTo(construct: Declarable): Dependency {\n\tconst canonical = construct\n\t\t.declare()\n\t\t.find((declaration) => declaration.id === construct.id);\n\n\tif (!canonical) throw new NotAConstruct(construct);\n\n\treturn { target: construct.id, kind: canonical.kind };\n}\n\n/** What consuming a construct hands you. */\nexport type Infer<C> =\n\tC extends Construct<string, infer TClient> ? TClient : never;\n\n/** A construct's canonical id. */\nexport type NameOf<C> =\n\tC extends Construct<infer TName, unknown> ? TName : never;\n\n/**\n * What `.dependsOn([…])` accepts: a construct that owns a client.\n *\n * Structural, and deliberately narrower than {@link Construct} — it is the\n * face a *consumer* needs, so the builders can accept a database, a bucket, a\n * mail sender, a queue, or a topic without importing any of them. A plain\n * `Service` is not one of these, which is the point: constructs-only confines\n * env sniffing to `.services()` and the explicit lift, so retiring that method\n * retires implicit inference with it.\n */\nexport interface Consumable<TName extends string = string, TClient = unknown> {\n\treadonly id: TName;\n\treadonly service: Service<Uncapitalize<TName>, TClient>;\n\tdeclare(): Declaration[];\n}\n\n/**\n * The services a list of constructs dissolves into.\n *\n * A mapped tuple, so `[db, uploads]` types as `[Service<'orders', Kysely<DB>>,\n * Service<'uploads', StorageClient>]` and the handler's service record gains\n * both keys — the same machinery `.services()` already uses, which is why\n * `dependsOn` needs no type plumbing of its own.\n */\nexport type ServicesOf<T extends readonly Consumable[]> = {\n\t[K in keyof T]: T[K]['service'];\n};\n\n/**\n * The services of a list of constructs, at runtime.\n *\n * @throws {NotAConstruct} when handed something else. The type already refuses\n * it, but a JavaScript caller gets no such warning, and a `Service` slipping\n * through would fail later as an undefined key in the handler.\n */\nexport function servicesOf<const T extends readonly Consumable[]>(\n\tconstructs: T,\n): ServicesOf<T> {\n\treturn constructs.map((construct) => {\n\t\tif (!isConsumable(construct)) throw new NotAConstruct(construct);\n\n\t\treturn construct.service;\n\t}) as ServicesOf<T>;\n}\n\n/**\n * The other half of `servicesOf`: the same edge, as the manifest records it.\n *\n * `.dependsOn()` used to keep only the services, which is what a handler runs\n * with — and an id cannot be recovered from a service name reliably, so the\n * edges were gone by the time the build could read them. Both halves are taken\n * from one call now, and `existing` is folded in so repeated `.dependsOn()`\n * calls accumulate the way `.services()` already does.\n */\nexport function idsOf(\n\tconstructs: readonly Consumable[],\n\texisting: readonly string[] = [],\n): string[] {\n\treturn [...new Set([...existing, ...constructs.map(({ id }) => id)])];\n}\n\n/** Something that is not a construct was passed to `.dependsOn()`. */\nexport class NotAConstruct extends Error {\n\tconstructor(readonly value: unknown) {\n\t\tconst name =\n\t\t\ttypeof value === 'object' && value !== null && 'serviceName' in value\n\t\t\t\t? `the service '${String((value as { serviceName: unknown }).serviceName)}'`\n\t\t\t\t: `a ${typeof value}`;\n\n\t\tsuper(\n\t\t\t`.dependsOn() takes constructs, and was given ${name}. ` +\n\t\t\t\t`Pass it to .services([…]) instead, or lift it with ` +\n\t\t\t\t`Construct.fromService().`,\n\t\t);\n\t\tthis.name = 'NotAConstruct';\n\t}\n}\n\n/**\n * Whether a value is a construct rather than a bare `Service`.\n *\n * Structural rather than `instanceof`: a construct from a second copy of\n * `@geekmidas/constructs` — a linked workspace, two versions in a lockfile — is\n * still a construct, and `instanceof` is exactly the check that says otherwise.\n */\nexport function isConsumable(value: unknown): value is Consumable {\n\tif (typeof value !== 'object' || value === null) return false;\n\n\tconst candidate = value as Partial<Consumable>;\n\n\treturn (\n\t\ttypeof candidate.id === 'string' &&\n\t\ttypeof candidate.declare === 'function' &&\n\t\ttypeof (candidate.service as Service | undefined)?.serviceName === 'string'\n\t);\n}\n\n/**\n * The service behind either face.\n *\n * `.database()` and the publisher slots take a construct now; they took a\n * `Service` before and still do, because a hand-written one is exactly what\n * `Construct.fromService` exists to lift and not everything has been lifted.\n */\nexport function serviceOf<TName extends string, TClient>(\n\tsource: Consumable<TName, TClient> | Service<TName, TClient>,\n): Service<TName, TClient> {\n\t// A construct's service key is `Uncapitalize<TName>` and the slot is typed\n\t// by `TName`; the two describe the same key, and only the cast says so.\n\treturn isConsumable(source)\n\t\t? (source.service as unknown as Service<TName, TClient>)\n\t\t: (source as Service<TName, TClient>);\n}\n"],"mappings":";;;;;;;;;;;;;AAgFA,SAAgB,OAAOA,WAAmC;CACzD,MAAM,YAAY,UAChB,SAAS,CACT,KAAK,CAAC,gBAAgB,YAAY,OAAO,UAAU,GAAG;AAExD,MAAK,UAAW,OAAM,IAAI,cAAc;AAExC,QAAO;EAAE,QAAQ,UAAU;EAAI,MAAM,UAAU;CAAM;AACrD;;;;;;;;AA6CD,SAAgB,WACfC,YACgB;AAChB,QAAO,WAAW,IAAI,CAAC,cAAc;AACpC,OAAK,aAAa,UAAU,CAAE,OAAM,IAAI,cAAc;AAEtD,SAAO,UAAU;CACjB,EAAC;AACF;;;;;;;;;;AAWD,SAAgB,MACfC,YACAC,WAA8B,CAAE,GACrB;AACX,QAAO,CAAC,GAAG,IAAI,IAAI,CAAC,GAAG,UAAU,GAAG,WAAW,IAAI,CAAC,EAAE,IAAI,KAAK,GAAG,AAAC,EAAE;AACrE;;AAGD,IAAa,gBAAb,cAAmC,MAAM;CACxC,YAAqBC,OAAgB;EACpC,MAAM,cACE,UAAU,YAAY,UAAU,QAAQ,iBAAiB,SAC5D,eAAe,OAAQ,MAAmC,YAAY,CAAC,MACvE,WAAW,MAAM;AAEtB,SACE,+CAA+C,KAAK,+EAGrD;EAVmB;AAWpB,OAAK,OAAO;CACZ;AACD;;;;;;;;AASD,SAAgB,aAAaA,OAAqC;AACjE,YAAW,UAAU,YAAY,UAAU,KAAM,QAAO;CAExD,MAAM,YAAY;AAElB,eACQ,UAAU,OAAO,mBACjB,UAAU,YAAY,qBACrB,UAAU,SAAiC,gBAAgB;AAEpE;;;;;;;;AASD,SAAgB,UACfC,QAC0B;AAG1B,QAAO,aAAa,OAAO,GACvB,OAAO,UACP;AACJ"}

package/dist/construct-interface.cjs

@@ -0,0 +1,8 @@
+const require_construct_interface = require('./construct-interface-BfjcOD_E.cjs');
+
+exports.NotAConstruct = require_construct_interface.NotAConstruct;
+exports.edgeTo = require_construct_interface.edgeTo;
+exports.idsOf = require_construct_interface.idsOf;
+exports.isConsumable = require_construct_interface.isConsumable;
+exports.serviceOf = require_construct_interface.serviceOf;
+exports.servicesOf = require_construct_interface.servicesOf;

package/dist/construct-interface.d.cts

@@ -0,0 +1,2 @@
+import { Construct, Consumable, Declarable, Infer, NameOf, NotAConstruct, ServicesOf, edgeTo, idsOf, isConsumable, serviceOf, servicesOf } from "./construct-interface-D2nNkHUN.cjs";
+export { Construct, Consumable, Declarable, Infer, NameOf, NotAConstruct, ServicesOf, edgeTo, idsOf, isConsumable, serviceOf, servicesOf };

package/dist/construct-interface.d.mts

@@ -0,0 +1,2 @@
+import { Construct, Consumable, Declarable, Infer, NameOf, NotAConstruct, ServicesOf, edgeTo, idsOf, isConsumable, serviceOf, servicesOf } from "./construct-interface-BqwRNYA2.mjs";
+export { Construct, Consumable, Declarable, Infer, NameOf, NotAConstruct, ServicesOf, edgeTo, idsOf, isConsumable, serviceOf, servicesOf };

package/dist/construct-interface.mjs

@@ -0,0 +1,3 @@
+import { NotAConstruct, edgeTo, idsOf, isConsumable, serviceOf, servicesOf } from "./construct-interface-Z4CpS8tK.mjs";
+
+export { NotAConstruct, edgeTo, idsOf, isConsumable, serviceOf, servicesOf };