@geekmidas/constructs 10.0.0-alpha.2 → 10.0.0-alpha.21

package/dist/SubscriberBuilder-Dptmo-1A.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SubscriberBuilder-Dptmo-1A.d.mts","names":[],"sources":["../src/subscribers/SubscriberBuilder.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/SubscriberBuilder-waNhzjSM.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SubscriberBuilder-waNhzjSM.d.cts","names":[],"sources":["../src/subscribers/SubscriberBuilder.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/Topic-19QeHBIR.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Topic-19QeHBIR.d.cts","names":[],"sources":["../src/topic/Topic.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;KAoBY,WAAA,GAAc,eAAe;AAAzC;;;;AAAgC,KAMpB,YANoB,CAAA,gBAMS,WANT,CAAA,GAAA,QAMpB,MACC,OADW,GAAA,MAAA,GACQ,kBADR,CAEtB,CAFsB,EAGtB,mBAHsB,CAGF,OAHE,CAGM,CAHN,CAAA,CAAA,CAAA,EAAA,CAAA,MAKhB,OALgB,GAAA,MAAA,CAAA;;;;;;;;;AAKT;AAYf;AAAkB,cAAL,KAAK,CAAA,cAAA,MAAA,GAAA,MAAA,EAAA,gBAED,WAFC,GAEa,WAFb,CAAA,SAGR,SAAA,CAHQ;EAAA,SAED,IAAA,EA2BO,KA3BP;EAAW;;;;;EAIe,SAuBnB,YAAA,EAMQ,OANR;EAAK,YAMG,EAAA,OAAA;EAAO,OAC7B,OAAA,CAAA,GAAA,EAAA,OAAA,CAAA,EAAA,GAAA,IA9B4B,KA8B5B,CAAA,MAAA,EA9B0C,WA8B1C,CAAA;EAAuB;;;;;;EA2DJ,SAA3B,EAAA,EAAA,MAAA;EAAc;;;;EAYa,iBAA3B,aAAA;EAAc,WAFE,CAAA,IAAA,EA5EM,KA4EN;EAAO;AAtGN;;;;gBAgCa,kBACtB;;;;;;;;aAeE;;2BAmBc;;;;;;;;;;;;;;;;;;;;iBAuBV,QACd,aAAa,QACb,eAAe,aAAa;mBAUZ,WACb,kBACH,eAAe,aAAa"}

package/dist/Topic-DuFeqkBh.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Topic-DuFeqkBh.d.mts","names":[],"sources":["../src/topic/Topic.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;KAoBY,WAAA,GAAc,eAAe;AAAzC;;;;AAAgC,KAMpB,YANoB,CAAA,gBAMS,WANT,CAAA,GAAA,QAMpB,MACC,OADW,GAAA,MAAA,GACQ,kBADR,CAEtB,CAFsB,EAGtB,mBAHsB,CAGF,OAHE,CAGM,CAHN,CAAA,CAAA,CAAA,EAAA,CAAA,MAKhB,OALgB,GAAA,MAAA,CAAA;;;;;;;;;AAKT;AAYf;AAAkB,cAAL,KAAK,CAAA,cAAA,MAAA,GAAA,MAAA,EAAA,gBAED,WAFC,GAEa,WAFb,CAAA,SAGR,SAAA,CAHQ;EAAA,SAED,IAAA,EA2BO,KA3BP;EAAW;;;;;EAIe,SAuBnB,YAAA,EAMQ,OANR;EAAK,YAMG,EAAA,OAAA;EAAO,OAC7B,OAAA,CAAA,GAAA,EAAA,OAAA,CAAA,EAAA,GAAA,IA9B4B,KA8B5B,CAAA,MAAA,EA9B0C,WA8B1C,CAAA;EAAuB;;;;;;EA2DJ,SAA3B,EAAA,EAAA,MAAA;EAAc;;;;EAYa,iBAA3B,aAAA;EAAc,WAFE,CAAA,IAAA,EA5EM,KA4EN;EAAO;AAtGN;;;;gBAgCa,kBACtB;;;;;;;;aAeE;;2BAmBc;;;;;;;;;;;;;;;;;;;;iBAuBV,QACd,aAAa,QACb,eAAe,aAAa;mBAUZ,WACb,kBACH,eAAe,aAAa"}

package/dist/auth.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"auth.d.cts","names":[],"sources":["../src/auth.ts"],"sourcesContent":[],"mappings":";;;;;;;;;AA+FgC,KApDpB,UAAA,GAAa,UAoDO,CAAA,OApDW,UAoDX,CAAA;;AACF,KAlDlB,iBAAA,GAAoB,IAkDF,CAjD7B,UAiD6B,CAAA,OAjDX,UAiDW,CAAA,CAAA,CAAA,CAAA,EAAA,UAAA,GAAA,QAAA,GAAA,UAAA,GAAA,SAAA,CAAA;AAEhB,UA/CG,gBA+CH,CAAA,kBA/CsC,UA+CtC,CAAA,CAAA;EAAK;;;;;;;EAkBkC,QAA1B,EAzDhB,SAyDgB;EAAgB;;;;;;EAgHwB,QAAnB,CAAA,EAAA,MAAA;EAAO;AApIjC;;;;;;QAtBf;;;;;;;;;;YAWH,+BAES,2BACJ,oBAAoB,QAAQ;;cAKxB,4DAEM,aAAa,uBACnB,UAAU,OAAO;;eAEhB;oBACK,QAAQ,aAAa,QAAQ;;;;;;;kBAgB1C,cAAc,gBACO,iBAAiB;;;;;;;;;;;;;;;aAuChC;;;;;;;sBAyCD,yBACP,cAAc;;;;;;;;;;;;;;;;;;;;kBA+BK,yBAAyB;SAAe"}

package/dist/auth.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"auth.d.mts","names":[],"sources":["../src/auth.ts"],"sourcesContent":[],"mappings":";;;;;;;;;AA+FgC,KApDpB,UAAA,GAAa,UAoDO,CAAA,OApDW,UAoDX,CAAA;;AACF,KAlDlB,iBAAA,GAAoB,IAkDF,CAjD7B,UAiD6B,CAAA,OAjDX,UAiDW,CAAA,CAAA,CAAA,CAAA,EAAA,UAAA,GAAA,QAAA,GAAA,UAAA,GAAA,SAAA,CAAA;AAEhB,UA/CG,gBA+CH,CAAA,kBA/CsC,UA+CtC,CAAA,CAAA;EAAK;;;;;;;EAkBkC,QAA1B,EAzDhB,SAyDgB;EAAgB;;;;;;EAgHwB,QAAnB,CAAA,EAAA,MAAA;EAAO;AApIjC;;;;;;QAtBf;;;;;;;;;;YAWH,+BAES,2BACJ,oBAAoB,QAAQ;;cAKxB,4DAEM,aAAa,uBACnB,UAAU,OAAO;;eAEhB;oBACK,QAAQ,aAAa,QAAQ;;;;;;;kBAgB1C,cAAc,gBACO,iBAAiB;;;;;;;;;;;;;;;aAuChC;;;;;;;sBAyCD,yBACP,cAAc;;;;;;;;;;;;;;;;;;;;kBA+BK,yBAAyB;SAAe"}

package/dist/cache-0ANvRQnD.mjs

@@ -1,51 +0,0 @@
-import { canonicalId, provideKey, serviceKey } from "@geekmidas/manifest";
-import { createCacheClient } from "@geekmidas/cache";
-
-//#region src/cache.ts
-var Cache$1 = class {
-	id;
-	service;
-	/**
-	* Declared once and read by both `declare()` and `connect()`, so the key the
-	* target publishes and the key the client reads cannot drift.
-	*/
-	key;
-	constructor(id, options = {}) {
-		this.options = options;
-		const canonical = canonicalId(id);
-		this.id = canonical;
-		this.key = provideKey(canonical, "url");
-		this.service = {
-			serviceName: serviceKey(canonical),
-			register: (options$1) => this.connect(options$1)
-		};
-	}
-	declare() {
-		return [{
-			kind: "cache",
-			id: this.id,
-			...this.options.of ? { of: this.options.of } : {},
-			...this.options.table ? { table: this.options.table } : {},
-			provides: [this.key]
-		}];
-	}
-	/**
-	* Builds the client from the single URL the target supplied.
-	*
-	* Any credential travels in that URL's userinfo rather than in a second key,
-	* for the same reason a Postgres password does: an address and the thing that
-	* opens it are one fact, and splitting them is one more thing to keep in step.
-	*
-	* The scheme selects the driver, so this construct imports no provider and
-	* an app that caches in Postgres never resolves a Redis client. Whoever
-	* assembles the application registers the drivers its target needs.
-	*/
-	async connect({ envParser }) {
-		const { url } = envParser.create((get) => ({ url: get(this.key).string() })).parse();
-		return createCacheClient(url);
-	}
-};
-
-//#endregion
-export { Cache$1 as Cache };
-//# sourceMappingURL=cache-0ANvRQnD.mjs.map

package/dist/cache-0ANvRQnD.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"cache-0ANvRQnD.mjs","names":["Cache","id: ConstructName<TName>","options: CacheOptions","options"],"sources":["../src/cache.ts"],"sourcesContent":["/**\n * `Cache` — a declared key/value cache.\n *\n * The same three-package meeting point as `ObjectStorage` and `Email`: it\n * implements the construct contract, derives its env key through\n * `@geekmidas/manifest`, and hands back a `@geekmidas/cache` client.\n *\n * It names no provider — and unlike `Email`, it cannot name one protocol\n * either. Every mail backend speaks SMTP, so an `smtp://` URL is true of all of\n * them; cache backends genuinely differ, because Upstash speaks HTTP, a Redis\n * speaks its wire protocol, and a table in Postgres speaks SQL. So the scheme in\n * the URL picks the driver, exactly as it does for object storage, and which\n * drivers exist is the generated entry point's decision.\n *\n * The backend is chosen at deploy, not here. An app caching in Postgres and an\n * app caching in Upstash are the same application code.\n */\n\nimport { type Cache as CacheClient, createCacheClient } from '@geekmidas/cache';\nimport {\n\ttype ConstructName,\n\tcanonicalId,\n\ttype Declaration,\n\tprovideKey,\n\tserviceKey,\n} from '@geekmidas/manifest';\nimport type { Service, ServiceRegisterOptions } from '@geekmidas/services';\nimport type { Construct } from './construct-interface';\n\nexport interface CacheOptions {\n\t/**\n\t * The database this cache lives in.\n\t *\n\t * Set by `database.cache()` rather than written by hand — the point of the\n\t * method is that the parent's id comes from the parent rather than from a\n\t * string somebody has to keep in step.\n\t */\n\tof?: string;\n\t/** The table entries are kept in. Defaults to `cache`. */\n\ttable?: string;\n}\n\nexport class Cache<TName extends string = string>\n\timplements Construct<TName, CacheClient>\n{\n\treadonly id: TName;\n\treadonly service: Service<Uncapitalize<TName>, CacheClient>;\n\n\t/**\n\t * Declared once and read by both `declare()` and `connect()`, so the key the\n\t * target publishes and the key the client reads cannot drift.\n\t */\n\tprivate readonly key: string;\n\n\tconstructor(\n\t\tid: ConstructName<TName>,\n\t\tprivate readonly options: CacheOptions = {},\n\t) {\n\t\tconst canonical = canonicalId(id as string);\n\n\t\tthis.id = canonical as TName;\n\t\tthis.key = provideKey(canonical, 'url');\n\n\t\t// A field, not a getter: consumers cache services by object identity.\n\t\tthis.service = {\n\t\t\tserviceName: serviceKey(canonical) as Uncapitalize<TName>,\n\t\t\tregister: (options) => this.connect(options),\n\t\t};\n\t}\n\n\tdeclare(): Declaration[] {\n\t\treturn [\n\t\t\t{\n\t\t\t\tkind: 'cache',\n\t\t\t\tid: this.id,\n\t\t\t\t...(this.options.of ? { of: this.options.of } : {}),\n\t\t\t\t...(this.options.table ? { table: this.options.table } : {}),\n\t\t\t\tprovides: [this.key],\n\t\t\t},\n\t\t];\n\t}\n\n\t/**\n\t * Builds the client from the single URL the target supplied.\n\t *\n\t * Any credential travels in that URL's userinfo rather than in a second key,\n\t * for the same reason a Postgres password does: an address and the thing that\n\t * opens it are one fact, and splitting them is one more thing to keep in step.\n\t *\n\t * The scheme selects the driver, so this construct imports no provider and\n\t * an app that caches in Postgres never resolves a Redis client. Whoever\n\t * assembles the application registers the drivers its target needs.\n\t */\n\tprivate async connect({\n\t\tenvParser,\n\t}: ServiceRegisterOptions): Promise<CacheClient> {\n\t\tconst { url } = envParser\n\t\t\t.create((get) => ({ url: get(this.key).string() }))\n\t\t\t.parse();\n\n\t\treturn createCacheClient(url);\n\t}\n}\n"],"mappings":";;;;AA0CA,IAAaA,UAAb,MAEA;CACC,AAAS;CACT,AAAS;;;;;CAMT,AAAiB;CAEjB,YACCC,IACiBC,UAAwB,CAAE,GAC1C;EADgB;EAEjB,MAAM,YAAY,YAAY,GAAa;AAE3C,OAAK,KAAK;AACV,OAAK,MAAM,WAAW,WAAW,MAAM;AAGvC,OAAK,UAAU;GACd,aAAa,WAAW,UAAU;GAClC,UAAU,CAACC,cAAY,KAAK,QAAQA,UAAQ;EAC5C;CACD;CAED,UAAyB;AACxB,SAAO,CACN;GACC,MAAM;GACN,IAAI,KAAK;GACT,GAAI,KAAK,QAAQ,KAAK,EAAE,IAAI,KAAK,QAAQ,GAAI,IAAG,CAAE;GAClD,GAAI,KAAK,QAAQ,QAAQ,EAAE,OAAO,KAAK,QAAQ,MAAO,IAAG,CAAE;GAC3D,UAAU,CAAC,KAAK,GAAI;EACpB,CACD;CACD;;;;;;;;;;;;CAaD,MAAc,QAAQ,EACrB,WACwB,EAAwB;EAChD,MAAM,EAAE,KAAK,GAAG,UACd,OAAO,CAAC,SAAS,EAAE,KAAK,IAAI,KAAK,IAAI,CAAC,QAAQ,CAAE,GAAE,CAClD,OAAO;AAET,SAAO,kBAAkB,IAAI;CAC7B;AACD"}

package/dist/cache-3WSvAulx.cjs

@@ -1,57 +0,0 @@
-const require_chunk = require('./chunk-DWy1uDak.cjs');
-const __geekmidas_manifest = require_chunk.__toESM(require("@geekmidas/manifest"));
-const __geekmidas_cache = require_chunk.__toESM(require("@geekmidas/cache"));
-
-//#region src/cache.ts
-var Cache = class {
-	id;
-	service;
-	/**
-	* Declared once and read by both `declare()` and `connect()`, so the key the
-	* target publishes and the key the client reads cannot drift.
-	*/
-	key;
-	constructor(id, options = {}) {
-		this.options = options;
-		const canonical = (0, __geekmidas_manifest.canonicalId)(id);
-		this.id = canonical;
-		this.key = (0, __geekmidas_manifest.provideKey)(canonical, "url");
-		this.service = {
-			serviceName: (0, __geekmidas_manifest.serviceKey)(canonical),
-			register: (options$1) => this.connect(options$1)
-		};
-	}
-	declare() {
-		return [{
-			kind: "cache",
-			id: this.id,
-			...this.options.of ? { of: this.options.of } : {},
-			...this.options.table ? { table: this.options.table } : {},
-			provides: [this.key]
-		}];
-	}
-	/**
-	* Builds the client from the single URL the target supplied.
-	*
-	* Any credential travels in that URL's userinfo rather than in a second key,
-	* for the same reason a Postgres password does: an address and the thing that
-	* opens it are one fact, and splitting them is one more thing to keep in step.
-	*
-	* The scheme selects the driver, so this construct imports no provider and
-	* an app that caches in Postgres never resolves a Redis client. Whoever
-	* assembles the application registers the drivers its target needs.
-	*/
-	async connect({ envParser }) {
-		const { url } = envParser.create((get) => ({ url: get(this.key).string() })).parse();
-		return (0, __geekmidas_cache.createCacheClient)(url);
-	}
-};
-
-//#endregion
-Object.defineProperty(exports, 'Cache', {
-  enumerable: true,
-  get: function () {
-    return Cache;
-  }
-});
-//# sourceMappingURL=cache-3WSvAulx.cjs.map

package/dist/cache-3WSvAulx.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"cache-3WSvAulx.cjs","names":["id: ConstructName<TName>","options: CacheOptions","options"],"sources":["../src/cache.ts"],"sourcesContent":["/**\n * `Cache` — a declared key/value cache.\n *\n * The same three-package meeting point as `ObjectStorage` and `Email`: it\n * implements the construct contract, derives its env key through\n * `@geekmidas/manifest`, and hands back a `@geekmidas/cache` client.\n *\n * It names no provider — and unlike `Email`, it cannot name one protocol\n * either. Every mail backend speaks SMTP, so an `smtp://` URL is true of all of\n * them; cache backends genuinely differ, because Upstash speaks HTTP, a Redis\n * speaks its wire protocol, and a table in Postgres speaks SQL. So the scheme in\n * the URL picks the driver, exactly as it does for object storage, and which\n * drivers exist is the generated entry point's decision.\n *\n * The backend is chosen at deploy, not here. An app caching in Postgres and an\n * app caching in Upstash are the same application code.\n */\n\nimport { type Cache as CacheClient, createCacheClient } from '@geekmidas/cache';\nimport {\n\ttype ConstructName,\n\tcanonicalId,\n\ttype Declaration,\n\tprovideKey,\n\tserviceKey,\n} from '@geekmidas/manifest';\nimport type { Service, ServiceRegisterOptions } from '@geekmidas/services';\nimport type { Construct } from './construct-interface';\n\nexport interface CacheOptions {\n\t/**\n\t * The database this cache lives in.\n\t *\n\t * Set by `database.cache()` rather than written by hand — the point of the\n\t * method is that the parent's id comes from the parent rather than from a\n\t * string somebody has to keep in step.\n\t */\n\tof?: string;\n\t/** The table entries are kept in. Defaults to `cache`. */\n\ttable?: string;\n}\n\nexport class Cache<TName extends string = string>\n\timplements Construct<TName, CacheClient>\n{\n\treadonly id: TName;\n\treadonly service: Service<Uncapitalize<TName>, CacheClient>;\n\n\t/**\n\t * Declared once and read by both `declare()` and `connect()`, so the key the\n\t * target publishes and the key the client reads cannot drift.\n\t */\n\tprivate readonly key: string;\n\n\tconstructor(\n\t\tid: ConstructName<TName>,\n\t\tprivate readonly options: CacheOptions = {},\n\t) {\n\t\tconst canonical = canonicalId(id as string);\n\n\t\tthis.id = canonical as TName;\n\t\tthis.key = provideKey(canonical, 'url');\n\n\t\t// A field, not a getter: consumers cache services by object identity.\n\t\tthis.service = {\n\t\t\tserviceName: serviceKey(canonical) as Uncapitalize<TName>,\n\t\t\tregister: (options) => this.connect(options),\n\t\t};\n\t}\n\n\tdeclare(): Declaration[] {\n\t\treturn [\n\t\t\t{\n\t\t\t\tkind: 'cache',\n\t\t\t\tid: this.id,\n\t\t\t\t...(this.options.of ? { of: this.options.of } : {}),\n\t\t\t\t...(this.options.table ? { table: this.options.table } : {}),\n\t\t\t\tprovides: [this.key],\n\t\t\t},\n\t\t];\n\t}\n\n\t/**\n\t * Builds the client from the single URL the target supplied.\n\t *\n\t * Any credential travels in that URL's userinfo rather than in a second key,\n\t * for the same reason a Postgres password does: an address and the thing that\n\t * opens it are one fact, and splitting them is one more thing to keep in step.\n\t *\n\t * The scheme selects the driver, so this construct imports no provider and\n\t * an app that caches in Postgres never resolves a Redis client. Whoever\n\t * assembles the application registers the drivers its target needs.\n\t */\n\tprivate async connect({\n\t\tenvParser,\n\t}: ServiceRegisterOptions): Promise<CacheClient> {\n\t\tconst { url } = envParser\n\t\t\t.create((get) => ({ url: get(this.key).string() }))\n\t\t\t.parse();\n\n\t\treturn createCacheClient(url);\n\t}\n}\n"],"mappings":";;;;;AA0CA,IAAa,QAAb,MAEA;CACC,AAAS;CACT,AAAS;;;;;CAMT,AAAiB;CAEjB,YACCA,IACiBC,UAAwB,CAAE,GAC1C;EADgB;EAEjB,MAAM,YAAY,sCAAY,GAAa;AAE3C,OAAK,KAAK;AACV,OAAK,MAAM,qCAAW,WAAW,MAAM;AAGvC,OAAK,UAAU;GACd,aAAa,qCAAW,UAAU;GAClC,UAAU,CAACC,cAAY,KAAK,QAAQA,UAAQ;EAC5C;CACD;CAED,UAAyB;AACxB,SAAO,CACN;GACC,MAAM;GACN,IAAI,KAAK;GACT,GAAI,KAAK,QAAQ,KAAK,EAAE,IAAI,KAAK,QAAQ,GAAI,IAAG,CAAE;GAClD,GAAI,KAAK,QAAQ,QAAQ,EAAE,OAAO,KAAK,QAAQ,MAAO,IAAG,CAAE;GAC3D,UAAU,CAAC,KAAK,GAAI;EACpB,CACD;CACD;;;;;;;;;;;;CAaD,MAAc,QAAQ,EACrB,WACwB,EAAwB;EAChD,MAAM,EAAE,KAAK,GAAG,UACd,OAAO,CAAC,SAAS,EAAE,KAAK,IAAI,KAAK,IAAI,CAAC,QAAQ,CAAE,GAAE,CAClD,OAAO;AAET,SAAO,yCAAkB,IAAI;CAC7B;AACD"}

package/dist/cache-BrRz3fEB.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cache-BrRz3fEB.d.mts","names":[],"sources":["../src/cache.ts"],"sourcesContent":[],"mappings":";;;;;;;AA2CqB,UAdJ,YAAA,CAcI;;;;;;;;;;;;cADR,kDACD,UAAU,OAAO;;eAEf;oBACK,QAAQ,aAAa,QAAQ;;;;;;kBAS1C,cAAc,kBACQ;aAchB"}

package/dist/cache-BtZY_tHe.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cache-BtZY_tHe.d.cts","names":[],"sources":["../src/cache.ts"],"sourcesContent":[],"mappings":";;;;;;;AA2CqB,UAdJ,YAAA,CAcI;;;;;;;;;;;;cADR,kDACD,UAAU,OAAO;;eAEf;oBACK,QAAQ,aAAa,QAAQ;;;;;;kBAS1C,cAAc,kBACQ;aAchB"}

package/dist/clone-DblgEZZa.mjs.map

@@ -1 +0,0 @@
-{"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.map

@@ -1 +0,0 @@
-{"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

@@ -1,117 +0,0 @@
-
-//#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

@@ -1 +0,0 @@
-{"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-D9d4Gm4p.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"construct-interface-D9d4Gm4p.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

@@ -1,81 +0,0 @@
-//#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

@@ -1 +0,0 @@
-{"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-g5GM5pwR.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"construct-interface-g5GM5pwR.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/database/kysely.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"kysely.d.cts","names":[],"sources":["../../src/database/kysely.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;AAqGM,UA7DW,qBAAA,SAA8B,IA6DzC,CA7D8C,YA6D9C,EAAA,SAAA,CAAA,CAAA;EAAa;;;;;;;EAyGoB,MACnB,CAAA,EAAA,MAAA;EAAM;;;;;;;EAoBC,KAAE,CAAA,EAAA,OAAA;EAAO;;;;;;;AA9If;AA4OrB;;EAA4B,OACZ,CAAA,EA/PL,eA+PK;;;UA3PN,WAAA,CA0P+C;EAAI,IAAA,EAAA,iBAAA,GAAA,iBAAA;;;;;;;;;;;cA7OhD,uEACD,UAAU,OAAO,OAAO;;eAEtB;oBACK,QAAQ,aAAa,QAAQ,OAAO;;;;;;;;;;kBAajD,cAAc,kBACQ,qCACZ;aAyBJ;;;;;;;;;;;;;YAqDD,iBAAiB,OAAO;;;;;;;;;;;;;;;;;;mCAyBD,mBAC5B,cAAc;;MAEhB,MAAM;;;;;;;;;+CAgBJ,cAAc,oBACT,wBACP,eAAe,UAAU;;;;;;;;;;;;;eAoBf,WAAW,aAAa,eAAe,OAAO;;;;;;;;;;;;;;;;;;;;KA0EhD,6CAA6C,KACxD,eAAe,IAAI"}

package/dist/database/kysely.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"kysely.d.mts","names":[],"sources":["../../src/database/kysely.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;AAqGM,UA7DW,qBAAA,SAA8B,IA6DzC,CA7D8C,YA6D9C,EAAA,SAAA,CAAA,CAAA;EAAa;;;;;;;EAyGoB,MACnB,CAAA,EAAA,MAAA;EAAM;;;;;;;EAoBC,KAAE,CAAA,EAAA,OAAA;EAAO;;;;;;;AA9If;AA4OrB;;EAA4B,OACZ,CAAA,EA/PL,eA+PK;;;UA3PN,WAAA,CA0P+C;EAAI,IAAA,EAAA,iBAAA,GAAA,iBAAA;;;;;;;;;;;cA7OhD,uEACD,UAAU,OAAO,OAAO;;eAEtB;oBACK,QAAQ,aAAa,QAAQ,OAAO;;;;;;;;;;kBAajD,cAAc,kBACQ,qCACZ;aAyBJ;;;;;;;;;;;;;YAqDD,iBAAiB,OAAO;;;;;;;;;;;;;;;;;;mCAyBD,mBAC5B,cAAc;;MAEhB,MAAM;;;;;;;;;+CAgBJ,cAAc,oBACT,wBACP,eAAe,UAAU;;;;;;;;;;;;;eAoBf,WAAW,aAAa,eAAe,OAAO;;;;;;;;;;;;;;;;;;;;KA0EhD,6CAA6C,KACxD,eAAe,IAAI"}