@geekmidas/constructs 9.0.2 → 10.0.0-alpha.1

package/dist/rest-api.mjs

@@ -0,0 +1,186 @@
+import "./Construct-CdhThxDI.mjs";
+import { edgeTo } from "./construct-interface-Z4CpS8tK.mjs";
+import "./functions-Cpff1uZH.mjs";
+import { EndpointFactory } from "./EndpointFactory-BejSTzbB.mjs";
+import "./clone-DblgEZZa.mjs";
+import "./Endpoint-BTj58Gob.mjs";
+import { envParserFor } from "./surfaceEnv-C3Ktahea.mjs";
+import { canonicalId, provideKey } from "@geekmidas/manifest";
+import { DEFAULT_LOGGER } from "@geekmidas/logger/console";
+
+//#region src/rest-api.ts
+/**
+* What is *not* here, and why.
+*
+* `dependsOn`, `database`, `auditor` and `publisher` all inject a capability
+* into a handler. Putting one on the surface hands it to every route the
+* surface serves — a health check gets the database because a report needed it
+* — which is the thing least privilege forbids and the reason `.calls()` is not
+* spelled `dependsOn`. They belong to the endpoint, or to a factory branched
+* from `api.endpoints` for a group of endpoints that genuinely share them.
+*
+* `auth` is not here either: `.auth(construct)` already declares it, and a
+* second way to say the same thing is the duplication this whole model removes.
+*
+* What is left is what the *process* is rather than what a route may reach.
+*/
+var RestApi = class RestApi {
+	id;
+	/**
+	* Declared once and read by both `declare()` and anything that consumes this
+	* surface, so what the target publishes and what a consumer reads cannot
+	* drift.
+	*/
+	keys;
+	/**
+	* The logger every endpoint on this surface runs with.
+	*
+	* Always defined — the surface's own if it was given one, the console
+	* logger otherwise — so nothing downstream has to decide what to do about a
+	* missing one. The generated entry reads it from here.
+	*/
+	logger;
+	/**
+	* The environment parser every endpoint on this surface runs with.
+	*
+	* Always defined, and normally the default: `process.env` merged with the
+	* credentials `gkm dev`/`gkm exec` injected. That is what every
+	* application's own `config/env.ts` was — boilerplate identical in every
+	* project, and mandatory, which is a poor combination.
+	*/
+	envParser;
+	/** The Telescope instance, when this surface was given one. */
+	telescope;
+	constructor(id, config, dependencies = [], authenticator) {
+		this.config = config;
+		this.dependencies = dependencies;
+		this.authenticator = authenticator;
+		const canonical = canonicalId(id);
+		this.id = canonical;
+		this.keys = {
+			url: provideKey(canonical, "url"),
+			trustedOrigins: provideKey(canonical, "trustedOrigins"),
+			cookieDomain: provideKey(canonical, "cookieDomain")
+		};
+		this.logger = config.logger ?? DEFAULT_LOGGER;
+		this.telescope = config.telescope;
+		this.envParser = envParserFor(config.envParser ? {
+			id: canonical,
+			envParser: config.envParser
+		} : void 0);
+		this.endpoints = new EndpointFactory({
+			defaultLogger: this.logger,
+			...config.authorizers ? { availableAuthorizers: config.authorizers.map((name) => ({ name })) } : {},
+			...config.defaultAuthorizer && config.defaultAuthorizer !== "none" ? { defaultAuthorizerName: config.defaultAuthorizer } : {},
+			surface: {
+				id: this.id,
+				envParser: this.envParser
+			}
+		});
+	}
+	/**
+	* This surface's endpoint factory.
+	*
+	* `api.get('/users')` is the short form and covers most routes. Reach for
+	* this one when a *group* of endpoints shares something a single route would
+	* otherwise repeat — a database, an auditor, a publisher:
+	*
+	* ```ts
+	* const audited = api.endpoints.database(db).auditor(AuditStore);
+	* export const createUser = audited.post('/users').handle(...);
+	* ```
+	*
+	* A factory branched from here keeps the surface, so its endpoints still
+	* know which API serves them. That is deliberately narrower than putting the
+	* same thing in the surface's own config: a group opts in, where a surface
+	* would grant it to every route it serves.
+	*/
+	endpoints;
+	/** `api.get('/users')` — sugar for `api.endpoints.get('/users')`. */
+	get(path) {
+		return this.endpoints.get(path);
+	}
+	post(path) {
+		return this.endpoints.post(path);
+	}
+	put(path) {
+		return this.endpoints.put(path);
+	}
+	patch(path) {
+		return this.endpoints.patch(path);
+	}
+	delete(path) {
+		return this.endpoints.delete(path);
+	}
+	options(path) {
+		return this.endpoints.options(path);
+	}
+	/**
+	* What authenticates this surface.
+	*
+	* An edge like `.calls()` — the auth server learns this origin, and the two
+	* share a cookie domain — but a named one, because *who authenticates me* is
+	* a different fact from *who I happen to call*, and only one of them decides
+	* what a request is allowed to be. A surface with two of the first is a
+	* mistake; two of the second is Tuesday.
+	*
+	* It records the id, not a client. Every endpoint consumes the same thing —
+	* `verify(request) → Session | null` — and that is what every provider
+	* shares, whether the server is mounted in this process, deployed beside it,
+	* or an OIDC issuer somebody else runs.
+	*/
+	auth(construct) {
+		return new RestApi(this.id, this.config, [...this.dependencies, edgeTo(construct)], construct.id);
+	}
+	/**
+	* Other surfaces this one calls.
+	*
+	* **Not `.dependsOn()`, and the difference matters.** An endpoint's
+	* `.dependsOn()` injects a client into that handler and grants it exactly
+	* what it named. This grants nothing and injects nothing: it records that
+	* this API calls another surface, which is what puts this API's origin on
+	* that surface's trusted-origin list.
+	*
+	* Spelling it `dependsOn` would invite the thing least privilege forbids —
+	* every route on the surface receiving whatever the surface named.
+	*
+	* Immutable, like every other builder here.
+	*/
+	calls(constructs) {
+		return new RestApi(this.id, this.config, [...this.dependencies, ...constructs.map(edgeTo)], this.authenticator);
+	}
+	/**
+	* One surface node, with its endpoints left to the build.
+	*
+	* The three provided keys are one fact about this surface and two about its
+	* callers. Declaring the caller-derived pair here rather than having the
+	* target invent them is what makes the contract checkable: a target that
+	* resolves no origins is caught against this list instead of being noticed
+	* when a browser is refused in production.
+	*/
+	declare() {
+		return [{
+			kind: "rest-api",
+			id: this.id,
+			app: {
+				...this.config.app,
+				...this.config.telescope ? { telescope: true } : {}
+			},
+			...this.config.cors ? { cors: this.config.cors } : {},
+			...this.authenticator ? { auth: this.authenticator } : {},
+			endpoints: [],
+			...this.dependencies.length ? { calls: this.dependencies } : {},
+			...this.config.authorizers?.length ? { authorizers: this.config.authorizers } : {},
+			defaultAuthorizer: this.config.defaultAuthorizer,
+			provides: [
+				this.keys.url,
+				this.keys.trustedOrigins,
+				this.keys.cookieDomain
+			]
+		}];
+	}
+};
+
+//#endregion
+export { RestApi };
+//# sourceMappingURL=rest-api.mjs.map

package/dist/rest-api.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"rest-api.mjs","names":["id: ConstructName<TName>","config: RestApiConfig<TAuthorizers>","dependencies: readonly Dependency[]","authenticator?: string","path: TPath","construct: Declarable","constructs: readonly Declarable[]"],"sources":["../src/rest-api.ts"],"sourcesContent":["/**\n * `RestApi` — the application's own HTTP surface, declared.\n *\n * Everything an app serves already existed; what did not exist was a *node* for\n * it. Without one, three things that are properties of the graph had to be\n * written down somewhere else: which origins the API accepts, which origins the\n * auth server trusts, and which URL a frontend is built against. All three were\n * being derived by walking the workspace config for ports — a second mechanism,\n * running beside the graph and answering the same question worse, since it can\n * only ever describe what this repo happens to run.\n *\n * With the surface declared, all three become one edge read backwards: a\n * consumer depends on the API, and *that* is the CORS entry, the trusted origin,\n * and the build-time URL. Nothing enumerates its own callers.\n *\n * ```ts\n * export const api = new RestApi('Api', {\n *   authorizers: ['session'],\n *   defaultAuthorizer: 'session',\n * });\n * ```\n */\n\nimport type { EnvironmentParser } from '@geekmidas/envkit';\nimport type { Logger } from '@geekmidas/logger';\nimport { DEFAULT_LOGGER } from '@geekmidas/logger/console';\nimport {\n\ttype AppSpec,\n\ttype ConstructName,\n\tcanonicalId,\n\ttype Declaration,\n\ttype Dependency,\n\tprovideKey,\n} from '@geekmidas/manifest';\nimport type { Telescope } from '@geekmidas/telescope';\nimport { type Declarable, edgeTo } from './construct-interface';\nimport type { BuiltInSecuritySchemeId } from './endpoints/Authorizer';\nimport { EndpointFactory } from './endpoints/EndpointFactory';\nimport { envParserFor } from './endpoints/surfaceEnv';\n\nexport interface RestApiConfig<\n\t// `readonly []` rather than `readonly string[]`: a surface that declares no\n\t// authorizers of its own should narrow `defaultAuthorizer` to the built-ins\n\t// and `'none'`, not widen it back to any string.\n\tTAuthorizers extends readonly string[] = readonly [],\n> {\n\t/**\n\t * The app that serves this surface: where its source lives, which globs\n\t * find its code, how it is run.\n\t *\n\t * What makes a surface a deploy unit rather than something a deploy has to\n\t * be told about separately: one `RestApi` is one server. A `StaticSite` says\n\t * the same thing, and the two are the same kind of statement.\n\t *\n\t * Normally omitted. One RestApi is one server, always — there is no mode in\n\t * which a surface shares somebody else's container, because a surface that\n\t * gets its process by inference gets it from whatever happened to reference\n\t * it, and that was the thing worth removing.\n\t *\n\t * So this is an override and nothing else. Everything in it follows from\n\t * this construct's id — `apps/<kebab-id>` where that directory exists, the\n\t * conventional code directories under it, a port assigned in a stable\n\t * order. Write one when the layout genuinely differs:\n\t * `app: { path: 'services/api' }`.\n\t */\n\tapp?: AppSpec;\n\t/**\n\t * CORS tunables. The *origins* are never here — they are read off the\n\t * constructs that declared an edge to this surface, which is the whole point\n\t * of declaring one. These are the parts a graph cannot answer.\n\t */\n\tcors?: {\n\t\tmaxAge?: number;\n\t\tcredentials?: boolean;\n\t\tallowHeaders?: readonly string[];\n\t\texposeHeaders?: readonly string[];\n\t};\n\t/**\n\t * The authorizer names this surface exposes. Names only — what verifies a\n\t * request legitimately differs between local and deployed, so the mechanism\n\t * belongs to the target and never to portable code.\n\t */\n\tauthorizers?: TAuthorizers;\n\t/**\n\t * The authorizer applied to an endpoint that names none.\n\t *\n\t * Required, and `'none'` is a valid answer that has to be typed out. The\n\t * alternative is an API that ships open because a field was left off, which\n\t * is the one default worth refusing to have.\n\t *\n\t * It was called `default`, which said what it was to the type and nothing\n\t * to the reader: next to `authorizers: ['iam']`, a bare `default: 'none'`\n\t * could be defaulting the runtime or the target. The manifest has always\n\t * called it `defaultAuthorizer` and the factory `defaultAuthorizerName`;\n\t * this is the same fact under the same name.\n\t *\n\t * Typed from `authorizers`, so it can only name one this surface exposes —\n\t * plus a built-in scheme, and `'none'`. It was a bare `string`, which let\n\t * `defaultAuthorizer: 'jwtt'` compile and every endpoint on the surface\n\t * default to an authorizer that does not exist.\n\t */\n\tdefaultAuthorizer: TAuthorizers[number] | BuiltInSecuritySchemeId | 'none';\n\t/**\n\t * The logger every endpoint on this surface runs with.\n\t *\n\t * The actual logger, not a path to one. It used to be named in config as\n\t * `logger: './config/logger'`, because the build wrote an import into each\n\t * generated handler and a generator can print a specifier but not an object.\n\t * Endpoints built from the surface carry it, so there is nothing to print\n\t * and nothing to keep in step with a moved file.\n\t */\n\tlogger?: Logger;\n\t/**\n\t * The environment parser every endpoint on this surface runs with.\n\t *\n\t * Same reason as `logger`, and the same field it replaces —\n\t * `envParser: './config/env#envParser'`, a module path with an export name\n\t * appended, parsed by us, checked by nothing.\n\t */\n\tenvParser?: EnvironmentParser<{}>;\n\t/**\n\t * The Telescope instance this surface's entry mounts.\n\t *\n\t * The actual instance, for the reason `logger` is: it used to be named as\n\t * `telescope: './config/telescope#telescope'`, a module path the build\n\t * printed an import for. The entry already imports the surface.\n\t */\n\ttelescope?: Telescope;\n}\n\n/**\n * What is *not* here, and why.\n *\n * `dependsOn`, `database`, `auditor` and `publisher` all inject a capability\n * into a handler. Putting one on the surface hands it to every route the\n * surface serves — a health check gets the database because a report needed it\n * — which is the thing least privilege forbids and the reason `.calls()` is not\n * spelled `dependsOn`. They belong to the endpoint, or to a factory branched\n * from `api.endpoints` for a group of endpoints that genuinely share them.\n *\n * `auth` is not here either: `.auth(construct)` already declares it, and a\n * second way to say the same thing is the duplication this whole model removes.\n *\n * What is left is what the *process* is rather than what a route may reach.\n */\n\nexport class RestApi<\n\tTName extends string = string,\n\tconst TAuthorizers extends readonly string[] = readonly [],\n> implements Declarable<TName>\n{\n\treadonly id: TName;\n\n\t/**\n\t * Declared once and read by both `declare()` and anything that consumes this\n\t * surface, so what the target publishes and what a consumer reads cannot\n\t * drift.\n\t */\n\treadonly keys: {\n\t\turl: string;\n\t\ttrustedOrigins: string;\n\t\tcookieDomain: string;\n\t};\n\n\t/**\n\t * The logger every endpoint on this surface runs with.\n\t *\n\t * Always defined — the surface's own if it was given one, the console\n\t * logger otherwise — so nothing downstream has to decide what to do about a\n\t * missing one. The generated entry reads it from here.\n\t */\n\treadonly logger: Logger;\n\n\t/**\n\t * The environment parser every endpoint on this surface runs with.\n\t *\n\t * Always defined, and normally the default: `process.env` merged with the\n\t * credentials `gkm dev`/`gkm exec` injected. That is what every\n\t * application's own `config/env.ts` was — boilerplate identical in every\n\t * project, and mandatory, which is a poor combination.\n\t */\n\treadonly envParser: EnvironmentParser<{}>;\n\n\t/** The Telescope instance, when this surface was given one. */\n\treadonly telescope?: Telescope;\n\n\tconstructor(\n\t\tid: ConstructName<TName>,\n\t\tprivate readonly config: RestApiConfig<TAuthorizers>,\n\t\t/** Internal: how `.calls()` carries edges into the copy it returns. */\n\t\tprivate readonly dependencies: readonly Dependency[] = [],\n\t\t/** Internal: how `.auth()` carries the authenticator into its copy. */\n\t\tprivate readonly authenticator?: string,\n\t) {\n\t\tconst canonical = canonicalId(id as string);\n\n\t\tthis.id = canonical as TName;\n\n\t\tthis.keys = {\n\t\t\turl: provideKey(canonical, 'url'),\n\t\t\ttrustedOrigins: provideKey(canonical, 'trustedOrigins'),\n\t\t\tcookieDomain: provideKey(canonical, 'cookieDomain'),\n\t\t};\n\n\t\tthis.logger = config.logger ?? DEFAULT_LOGGER;\n\t\tthis.telescope = config.telescope;\n\t\tthis.envParser = envParserFor(\n\t\t\tconfig.envParser\n\t\t\t\t? { id: canonical, envParser: config.envParser }\n\t\t\t\t: undefined,\n\t\t);\n\n\t\tthis.endpoints = new EndpointFactory({\n\t\t\tdefaultLogger: this.logger,\n\t\t\t...(config.authorizers\n\t\t\t\t? {\n\t\t\t\t\t\tavailableAuthorizers: config.authorizers.map((name) => ({ name })),\n\t\t\t\t\t}\n\t\t\t\t: {}),\n\t\t\t// `'none'` reaches the factory as no default at all, which is what\n\t\t\t// public means to an endpoint that names no authorizer.\n\t\t\t...(config.defaultAuthorizer && config.defaultAuthorizer !== 'none'\n\t\t\t\t? { defaultAuthorizerName: config.defaultAuthorizer }\n\t\t\t\t: {}),\n\t\t\tsurface: { id: this.id, envParser: this.envParser },\n\t\t});\n\t}\n\n\t/**\n\t * This surface's endpoint factory.\n\t *\n\t * `api.get('/users')` is the short form and covers most routes. Reach for\n\t * this one when a *group* of endpoints shares something a single route would\n\t * otherwise repeat — a database, an auditor, a publisher:\n\t *\n\t * ```ts\n\t * const audited = api.endpoints.database(db).auditor(AuditStore);\n\t * export const createUser = audited.post('/users').handle(...);\n\t * ```\n\t *\n\t * A factory branched from here keeps the surface, so its endpoints still\n\t * know which API serves them. That is deliberately narrower than putting the\n\t * same thing in the surface's own config: a group opts in, where a surface\n\t * would grant it to every route it serves.\n\t */\n\treadonly endpoints: EndpointFactory<[], '', Logger>;\n\n\t/** `api.get('/users')` — sugar for `api.endpoints.get('/users')`. */\n\tget<TPath extends string>(path: TPath) {\n\t\treturn this.endpoints.get(path);\n\t}\n\n\tpost<TPath extends string>(path: TPath) {\n\t\treturn this.endpoints.post(path);\n\t}\n\n\tput<TPath extends string>(path: TPath) {\n\t\treturn this.endpoints.put(path);\n\t}\n\n\tpatch<TPath extends string>(path: TPath) {\n\t\treturn this.endpoints.patch(path);\n\t}\n\n\tdelete<TPath extends string>(path: TPath) {\n\t\treturn this.endpoints.delete(path);\n\t}\n\n\toptions<TPath extends string>(path: TPath) {\n\t\treturn this.endpoints.options(path);\n\t}\n\n\t/**\n\t * What authenticates this surface.\n\t *\n\t * An edge like `.calls()` — the auth server learns this origin, and the two\n\t * share a cookie domain — but a named one, because *who authenticates me* is\n\t * a different fact from *who I happen to call*, and only one of them decides\n\t * what a request is allowed to be. A surface with two of the first is a\n\t * mistake; two of the second is Tuesday.\n\t *\n\t * It records the id, not a client. Every endpoint consumes the same thing —\n\t * `verify(request) → Session | null` — and that is what every provider\n\t * shares, whether the server is mounted in this process, deployed beside it,\n\t * or an OIDC issuer somebody else runs.\n\t */\n\tauth(construct: Declarable): RestApi<TName, TAuthorizers> {\n\t\treturn new RestApi<TName, TAuthorizers>(\n\t\t\tthis.id as ConstructName<TName>,\n\t\t\tthis.config,\n\t\t\t[...this.dependencies, edgeTo(construct)],\n\t\t\tconstruct.id,\n\t\t);\n\t}\n\n\t/**\n\t * Other surfaces this one calls.\n\t *\n\t * **Not `.dependsOn()`, and the difference matters.** An endpoint's\n\t * `.dependsOn()` injects a client into that handler and grants it exactly\n\t * what it named. This grants nothing and injects nothing: it records that\n\t * this API calls another surface, which is what puts this API's origin on\n\t * that surface's trusted-origin list.\n\t *\n\t * Spelling it `dependsOn` would invite the thing least privilege forbids —\n\t * every route on the surface receiving whatever the surface named.\n\t *\n\t * Immutable, like every other builder here.\n\t */\n\tcalls(constructs: readonly Declarable[]): RestApi<TName, TAuthorizers> {\n\t\treturn new RestApi<TName, TAuthorizers>(\n\t\t\tthis.id as ConstructName<TName>,\n\t\t\tthis.config,\n\t\t\t[...this.dependencies, ...constructs.map(edgeTo)],\n\t\t\tthis.authenticator,\n\t\t);\n\t}\n\n\t/**\n\t * One surface node, with its endpoints left to the build.\n\t *\n\t * The three provided keys are one fact about this surface and two about its\n\t * callers. Declaring the caller-derived pair here rather than having the\n\t * target invent them is what makes the contract checkable: a target that\n\t * resolves no origins is caught against this list instead of being noticed\n\t * when a browser is refused in production.\n\t */\n\tdeclare(): Declaration[] {\n\t\treturn [\n\t\t\t{\n\t\t\t\tkind: 'rest-api',\n\t\t\t\tid: this.id,\n\t\t\t\tapp: {\n\t\t\t\t\t...this.config.app,\n\t\t\t\t\t...(this.config.telescope ? { telescope: true } : {}),\n\t\t\t\t},\n\t\t\t\t...(this.config.cors ? { cors: this.config.cors } : {}),\n\t\t\t\t...(this.authenticator ? { auth: this.authenticator } : {}),\n\t\t\t\t// Filled by the build, which already generates one handler per\n\t\t\t\t// endpoint and knows the path it wrote it to. A surface that\n\t\t\t\t// enumerates its own routes statically — an auth server's single\n\t\t\t\t// wildcard — puts them here instead.\n\t\t\t\tendpoints: [],\n\t\t\t\t...(this.dependencies.length ? { calls: this.dependencies } : {}),\n\t\t\t\t...(this.config.authorizers?.length\n\t\t\t\t\t? { authorizers: this.config.authorizers }\n\t\t\t\t\t: {}),\n\t\t\t\tdefaultAuthorizer: this.config.defaultAuthorizer,\n\t\t\t\tprovides: [\n\t\t\t\t\tthis.keys.url,\n\t\t\t\t\tthis.keys.trustedOrigins,\n\t\t\t\t\tthis.keys.cookieDomain,\n\t\t\t\t],\n\t\t\t},\n\t\t];\n\t}\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAkJA,IAAa,UAAb,MAAa,QAIb;CACC,AAAS;;;;;;CAOT,AAAS;;;;;;;;CAaT,AAAS;;;;;;;;;CAUT,AAAS;;CAGT,AAAS;CAET,YACCA,IACiBC,QAEAC,eAAsC,CAAE,GAExCC,eAChB;EALgB;EAEA;EAEA;EAEjB,MAAM,YAAY,YAAY,GAAa;AAE3C,OAAK,KAAK;AAEV,OAAK,OAAO;GACX,KAAK,WAAW,WAAW,MAAM;GACjC,gBAAgB,WAAW,WAAW,iBAAiB;GACvD,cAAc,WAAW,WAAW,eAAe;EACnD;AAED,OAAK,SAAS,OAAO,UAAU;AAC/B,OAAK,YAAY,OAAO;AACxB,OAAK,YAAY,aAChB,OAAO,YACJ;GAAE,IAAI;GAAW,WAAW,OAAO;EAAW,WAEjD;AAED,OAAK,YAAY,IAAI,gBAAgB;GACpC,eAAe,KAAK;GACpB,GAAI,OAAO,cACR,EACA,sBAAsB,OAAO,YAAY,IAAI,CAAC,UAAU,EAAE,KAAM,GAAE,CAClE,IACA,CAAE;GAGL,GAAI,OAAO,qBAAqB,OAAO,sBAAsB,SAC1D,EAAE,uBAAuB,OAAO,kBAAmB,IACnD,CAAE;GACL,SAAS;IAAE,IAAI,KAAK;IAAI,WAAW,KAAK;GAAW;EACnD;CACD;;;;;;;;;;;;;;;;;;CAmBD,AAAS;;CAGT,IAA0BC,MAAa;AACtC,SAAO,KAAK,UAAU,IAAI,KAAK;CAC/B;CAED,KAA2BA,MAAa;AACvC,SAAO,KAAK,UAAU,KAAK,KAAK;CAChC;CAED,IAA0BA,MAAa;AACtC,SAAO,KAAK,UAAU,IAAI,KAAK;CAC/B;CAED,MAA4BA,MAAa;AACxC,SAAO,KAAK,UAAU,MAAM,KAAK;CACjC;CAED,OAA6BA,MAAa;AACzC,SAAO,KAAK,UAAU,OAAO,KAAK;CAClC;CAED,QAA8BA,MAAa;AAC1C,SAAO,KAAK,UAAU,QAAQ,KAAK;CACnC;;;;;;;;;;;;;;;CAgBD,KAAKC,WAAqD;AACzD,SAAO,IAAI,QACV,KAAK,IACL,KAAK,QACL,CAAC,GAAG,KAAK,cAAc,OAAO,UAAU,AAAC,GACzC,UAAU;CAEX;;;;;;;;;;;;;;;CAgBD,MAAMC,YAAiE;AACtE,SAAO,IAAI,QACV,KAAK,IACL,KAAK,QACL,CAAC,GAAG,KAAK,cAAc,GAAG,WAAW,IAAI,OAAO,AAAC,GACjD,KAAK;CAEN;;;;;;;;;;CAWD,UAAyB;AACxB,SAAO,CACN;GACC,MAAM;GACN,IAAI,KAAK;GACT,KAAK;IACJ,GAAG,KAAK,OAAO;IACf,GAAI,KAAK,OAAO,YAAY,EAAE,WAAW,KAAM,IAAG,CAAE;GACpD;GACD,GAAI,KAAK,OAAO,OAAO,EAAE,MAAM,KAAK,OAAO,KAAM,IAAG,CAAE;GACtD,GAAI,KAAK,gBAAgB,EAAE,MAAM,KAAK,cAAe,IAAG,CAAE;GAK1D,WAAW,CAAE;GACb,GAAI,KAAK,aAAa,SAAS,EAAE,OAAO,KAAK,aAAc,IAAG,CAAE;GAChE,GAAI,KAAK,OAAO,aAAa,SAC1B,EAAE,aAAa,KAAK,OAAO,YAAa,IACxC,CAAE;GACL,mBAAmB,KAAK,OAAO;GAC/B,UAAU;IACT,KAAK,KAAK;IACV,KAAK,KAAK;IACV,KAAK,KAAK;GACV;EACD,CACD;CACD;AACD"}

package/dist/site.cjs

@@ -0,0 +1,48 @@
+const require_chunk = require('./chunk-DWy1uDak.cjs');
+const require_construct_interface = require('./construct-interface-BfjcOD_E.cjs');
+const __geekmidas_manifest = require_chunk.__toESM(require("@geekmidas/manifest"));
+
+//#region src/site.ts
+var StaticSite = class StaticSite {
+	id;
+	keys;
+	constructor(id, config = {}, dependencies = []) {
+		this.config = config;
+		this.dependencies = dependencies;
+		this.id = (0, __geekmidas_manifest.canonicalId)(id);
+		this.keys = { url: (0, __geekmidas_manifest.provideKey)(this.id, "url") };
+	}
+	/**
+	* What this site calls.
+	*
+	* Immutable, like every other builder here: it returns a new site rather than
+	* mutating this one, so a module that exports both a base and a variant of it
+	* cannot have the second silently change the first.
+	*
+	* Takes {@link Declarable} rather than {@link Consumable} because a site's
+	* edge is a build-time link and not a service injection — requiring a client
+	* would exclude exactly the surfaces a frontend actually depends on.
+	*/
+	dependsOn(constructs) {
+		return new StaticSite(this.id, this.config, [...this.dependencies, ...constructs.map(require_construct_interface.edgeTo)]);
+	}
+	declare() {
+		return [{
+			kind: "site",
+			id: this.id,
+			variant: this.config.variant ?? "static",
+			app: {
+				...this.config.path ? { path: this.config.path } : {},
+				...this.config.port ? { port: this.config.port } : {},
+				...this.config.config ? { config: this.config.config } : {}
+			},
+			...this.config.root ? { root: true } : {},
+			dependencies: this.dependencies,
+			provides: [this.keys.url]
+		}];
+	}
+};
+
+//#endregion
+exports.StaticSite = StaticSite;
+//# sourceMappingURL=site.cjs.map

package/dist/site.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"site.cjs","names":["id: ConstructName<TName>","config: StaticSiteConfig","dependencies: readonly Dependency[]","constructs: readonly Declarable[]","edgeTo"],"sources":["../src/site.ts"],"sourcesContent":["/**\n * `StaticSite` — a frontend, declared like anything else.\n *\n * The point is not that a site needs provisioning; it is that a site is the\n * *consumer* whose edges make four hand-maintained lists derivable. Declaring it\n * is what turns \"which origins does the API allow\" from something a person keeps\n * in step into something the graph already knows.\n *\n * ```ts\n * export const console = new StaticSite('Console', { path: 'apps/console' })\n *   .dependsOn([api, auth]);\n * ```\n *\n * It has no `.service`. A site is not a process that registers clients — it is\n * built, and the values it needs are inlined or fetched by its own framework —\n * so the edge is {@link Declarable} rather than {@link Consumable}, and the\n * asymmetry is the honest one: a site consumes addresses, not connections.\n *\n * Only the static variant ships. SSR deploy shapes are unstable and each one is\n * its own maintenance, so they follow rather than arrive together; Expo and\n * mobile are out of scope entirely, because an app store is not infrastructure\n * and there is no URL to hand anyone.\n */\n\nimport {\n\ttype ConstructName,\n\tcanonicalId,\n\ttype Declaration,\n\ttype Dependency,\n\tprovideKey,\n\ttype SiteDeclaration,\n} from '@geekmidas/manifest';\nimport { type Declarable, edgeTo } from './construct-interface';\n\n/**\n * A site's config is flat, where a surface's nests its `app`.\n *\n * Not an inconsistency: a `RestApi` may or may not have a process of its own,\n * so \"what the surface is\" and \"how its process is built\" are separable there\n * and worth separating. A site *is* its app — there is nothing to separate it\n * from, and `{ app: { path } }` would be a wrapper around the only thing in it.\n *\n * Every field is optional, so `new StaticSite('Web')` is a complete site.\n */\nexport interface StaticSiteConfig {\n\t/**\n\t * Where its source lives, relative to the workspace root.\n\t *\n\t * Optional, and normally omitted: `apps/<kebab-id>` where that directory\n\t * exists, and the workspace root otherwise. `StaticSite('Web')` means\n\t * `apps/web`, which is the thing the id already said.\n\t *\n\t * Worth writing only when the layout differs — `path: 'sites/marketing'`.\n\t */\n\tpath?: string;\n\t/**\n\t * The port it answers on locally.\n\t *\n\t * Normally omitted: ports are assigned in a stable order, so adding a site\n\t * does not renumber the ones already running.\n\t */\n\tport?: number;\n\t/**\n\t * Modules to import when sniffing which env vars this site reads.\n\t *\n\t * A frontend's values are inlined at build time, so the build has to know\n\t * which ones it reads before it reads them.\n\t */\n\tconfig?: { client?: string; server?: string };\n\t/**\n\t * Whether the base domain points at this site.\n\t *\n\t * A project with one site needs this no more than a project with one\n\t * database needs to say which database. It matters when there are several\n\t * and none is called `web`: the base domain then belongs to whichever site\n\t * says so, rather than to whichever file the glob happened to reach first.\n\t */\n\troot?: boolean;\n\t/**\n\t * Which framework builds it.\n\t *\n\t * It selects how values are delivered — `VITE_`, `NEXT_PUBLIC_`, a fetched\n\t * `config.json` — and never which values there are. One neutral name from the\n\t * construct, one serialisation per framework, the same rule as everywhere\n\t * else.\n\t */\n\tvariant?: SiteDeclaration['variant'];\n}\n\nexport class StaticSite<TName extends string = string>\n\timplements Declarable<TName>\n{\n\treadonly id: TName;\n\treadonly keys: { url: string };\n\n\tconstructor(\n\t\tid: ConstructName<TName>,\n\t\tprivate readonly config: StaticSiteConfig = {},\n\t\t/**\n\t\t * Internal: how `.dependsOn()` carries edges into the copy it returns.\n\t\t * Written as a parameter rather than a mutable field so the builder can\n\t\t * stay immutable without a clone method, the same shape\n\t\t * `KyselyDatabase` uses for its derived forms.\n\t\t */\n\t\tprivate readonly dependencies: readonly Dependency[] = [],\n\t) {\n\t\tthis.id = canonicalId(id as string) as TName;\n\t\tthis.keys = { url: provideKey(this.id, 'url') };\n\t}\n\n\t/**\n\t * What this site calls.\n\t *\n\t * Immutable, like every other builder here: it returns a new site rather than\n\t * mutating this one, so a module that exports both a base and a variant of it\n\t * cannot have the second silently change the first.\n\t *\n\t * Takes {@link Declarable} rather than {@link Consumable} because a site's\n\t * edge is a build-time link and not a service injection — requiring a client\n\t * would exclude exactly the surfaces a frontend actually depends on.\n\t */\n\tdependsOn(constructs: readonly Declarable[]): StaticSite<TName> {\n\t\treturn new StaticSite<TName>(this.id as ConstructName<TName>, this.config, [\n\t\t\t...this.dependencies,\n\t\t\t...constructs.map(edgeTo),\n\t\t]);\n\t}\n\n\tdeclare(): Declaration[] {\n\t\treturn [\n\t\t\t{\n\t\t\t\tkind: 'site',\n\t\t\t\tid: this.id,\n\t\t\t\tvariant: this.config.variant ?? 'static',\n\t\t\t\tapp: {\n\t\t\t\t\t...(this.config.path ? { path: this.config.path } : {}),\n\t\t\t\t\t...(this.config.port ? { port: this.config.port } : {}),\n\t\t\t\t\t...(this.config.config ? { config: this.config.config } : {}),\n\t\t\t\t},\n\t\t\t\t...(this.config.root ? { root: true } : {}),\n\t\t\t\tdependencies: this.dependencies,\n\t\t\t\tprovides: [this.keys.url],\n\t\t\t},\n\t\t];\n\t}\n}\n"],"mappings":";;;;;AAyFA,IAAa,aAAb,MAAa,WAEb;CACC,AAAS;CACT,AAAS;CAET,YACCA,IACiBC,SAA2B,CAAE,GAO7BC,eAAsC,CAAE,GACxD;EARgB;EAOA;AAEjB,OAAK,KAAK,sCAAY,GAAa;AACnC,OAAK,OAAO,EAAE,KAAK,qCAAW,KAAK,IAAI,MAAM,CAAE;CAC/C;;;;;;;;;;;;CAaD,UAAUC,YAAsD;AAC/D,SAAO,IAAI,WAAkB,KAAK,IAA4B,KAAK,QAAQ,CAC1E,GAAG,KAAK,cACR,GAAG,WAAW,IAAIC,mCAAO,AACzB;CACD;CAED,UAAyB;AACxB,SAAO,CACN;GACC,MAAM;GACN,IAAI,KAAK;GACT,SAAS,KAAK,OAAO,WAAW;GAChC,KAAK;IACJ,GAAI,KAAK,OAAO,OAAO,EAAE,MAAM,KAAK,OAAO,KAAM,IAAG,CAAE;IACtD,GAAI,KAAK,OAAO,OAAO,EAAE,MAAM,KAAK,OAAO,KAAM,IAAG,CAAE;IACtD,GAAI,KAAK,OAAO,SAAS,EAAE,QAAQ,KAAK,OAAO,OAAQ,IAAG,CAAE;GAC5D;GACD,GAAI,KAAK,OAAO,OAAO,EAAE,MAAM,KAAM,IAAG,CAAE;GAC1C,cAAc,KAAK;GACnB,UAAU,CAAC,KAAK,KAAK,GAAI;EACzB,CACD;CACD;AACD"}

package/dist/site.d.cts

@@ -0,0 +1,101 @@
+import { Declarable } from "./construct-interface-D2nNkHUN.cjs";
+import { ConstructName, Declaration, Dependency, SiteDeclaration } from "@geekmidas/manifest";
+
+//#region src/site.d.ts
+
+/**
+ * A site's config is flat, where a surface's nests its `app`.
+ *
+ * Not an inconsistency: a `RestApi` may or may not have a process of its own,
+ * so "what the surface is" and "how its process is built" are separable there
+ * and worth separating. A site *is* its app — there is nothing to separate it
+ * from, and `{ app: { path } }` would be a wrapper around the only thing in it.
+ *
+ * Every field is optional, so `new StaticSite('Web')` is a complete site.
+ */
+interface StaticSiteConfig {
+  /**
+   * Where its source lives, relative to the workspace root.
+   *
+   * Optional, and normally omitted: `apps/<kebab-id>` where that directory
+   * exists, and the workspace root otherwise. `StaticSite('Web')` means
+   * `apps/web`, which is the thing the id already said.
+   *
+   * Worth writing only when the layout differs — `path: 'sites/marketing'`.
+   */
+  path?: string;
+  /**
+   * The port it answers on locally.
+   *
+   * Normally omitted: ports are assigned in a stable order, so adding a site
+   * does not renumber the ones already running.
+   */
+  port?: number;
+  /**
+   * Modules to import when sniffing which env vars this site reads.
+   *
+   * A frontend's values are inlined at build time, so the build has to know
+   * which ones it reads before it reads them.
+   */
+  config?: {
+    client?: string;
+    server?: string;
+  };
+  /**
+   * Whether the base domain points at this site.
+   *
+   * A project with one site needs this no more than a project with one
+   * database needs to say which database. It matters when there are several
+   * and none is called `web`: the base domain then belongs to whichever site
+   * says so, rather than to whichever file the glob happened to reach first.
+   */
+  root?: boolean;
+  /**
+   * Which framework builds it.
+   *
+   * It selects how values are delivered — `VITE_`, `NEXT_PUBLIC_`, a fetched
+   * `config.json` — and never which values there are. One neutral name from the
+   * construct, one serialisation per framework, the same rule as everywhere
+   * else.
+   */
+  variant?: SiteDeclaration['variant'];
+}
+declare class StaticSite<TName extends string = string> implements Declarable<TName> {
+  private readonly config;
+  /**
+   * Internal: how `.dependsOn()` carries edges into the copy it returns.
+   * Written as a parameter rather than a mutable field so the builder can
+   * stay immutable without a clone method, the same shape
+   * `KyselyDatabase` uses for its derived forms.
+   */
+  private readonly dependencies;
+  readonly id: TName;
+  readonly keys: {
+    url: string;
+  };
+  constructor(id: ConstructName<TName>, config?: StaticSiteConfig,
+  /**
+   * Internal: how `.dependsOn()` carries edges into the copy it returns.
+   * Written as a parameter rather than a mutable field so the builder can
+   * stay immutable without a clone method, the same shape
+   * `KyselyDatabase` uses for its derived forms.
+   */
+  dependencies?: readonly Dependency[]);
+  /**
+   * What this site calls.
+   *
+   * Immutable, like every other builder here: it returns a new site rather than
+   * mutating this one, so a module that exports both a base and a variant of it
+   * cannot have the second silently change the first.
+   *
+   * Takes {@link Declarable} rather than {@link Consumable} because a site's
+   * edge is a build-time link and not a service injection — requiring a client
+   * would exclude exactly the surfaces a frontend actually depends on.
+   */
+  dependsOn(constructs: readonly Declarable[]): StaticSite<TName>;
+  declare(): Declaration[];
+}
+//# sourceMappingURL=site.d.ts.map
+//#endregion
+export { StaticSite, StaticSiteConfig };
+//# sourceMappingURL=site.d.cts.map

package/dist/site.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"site.d.cts","names":[],"sources":["../src/site.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;UA4CiB,gBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YA0CN;;cAGE,qDACD,WAAW;;;;;;;;;eAET;;;;kBAIR,cAAc,iBACO;;;;;;;0BAOe;;;;;;;;;;;;iCAiBV,eAAe,WAAW;aAO9C"}

package/dist/site.d.mts

@@ -0,0 +1,101 @@
+import { Declarable } from "./construct-interface-BqwRNYA2.mjs";
+import { ConstructName, Declaration, Dependency, SiteDeclaration } from "@geekmidas/manifest";
+
+//#region src/site.d.ts
+
+/**
+ * A site's config is flat, where a surface's nests its `app`.
+ *
+ * Not an inconsistency: a `RestApi` may or may not have a process of its own,
+ * so "what the surface is" and "how its process is built" are separable there
+ * and worth separating. A site *is* its app — there is nothing to separate it
+ * from, and `{ app: { path } }` would be a wrapper around the only thing in it.
+ *
+ * Every field is optional, so `new StaticSite('Web')` is a complete site.
+ */
+interface StaticSiteConfig {
+  /**
+   * Where its source lives, relative to the workspace root.
+   *
+   * Optional, and normally omitted: `apps/<kebab-id>` where that directory
+   * exists, and the workspace root otherwise. `StaticSite('Web')` means
+   * `apps/web`, which is the thing the id already said.
+   *
+   * Worth writing only when the layout differs — `path: 'sites/marketing'`.
+   */
+  path?: string;
+  /**
+   * The port it answers on locally.
+   *
+   * Normally omitted: ports are assigned in a stable order, so adding a site
+   * does not renumber the ones already running.
+   */
+  port?: number;
+  /**
+   * Modules to import when sniffing which env vars this site reads.
+   *
+   * A frontend's values are inlined at build time, so the build has to know
+   * which ones it reads before it reads them.
+   */
+  config?: {
+    client?: string;
+    server?: string;
+  };
+  /**
+   * Whether the base domain points at this site.
+   *
+   * A project with one site needs this no more than a project with one
+   * database needs to say which database. It matters when there are several
+   * and none is called `web`: the base domain then belongs to whichever site
+   * says so, rather than to whichever file the glob happened to reach first.
+   */
+  root?: boolean;
+  /**
+   * Which framework builds it.
+   *
+   * It selects how values are delivered — `VITE_`, `NEXT_PUBLIC_`, a fetched
+   * `config.json` — and never which values there are. One neutral name from the
+   * construct, one serialisation per framework, the same rule as everywhere
+   * else.
+   */
+  variant?: SiteDeclaration['variant'];
+}
+declare class StaticSite<TName extends string = string> implements Declarable<TName> {
+  private readonly config;
+  /**
+   * Internal: how `.dependsOn()` carries edges into the copy it returns.
+   * Written as a parameter rather than a mutable field so the builder can
+   * stay immutable without a clone method, the same shape
+   * `KyselyDatabase` uses for its derived forms.
+   */
+  private readonly dependencies;
+  readonly id: TName;
+  readonly keys: {
+    url: string;
+  };
+  constructor(id: ConstructName<TName>, config?: StaticSiteConfig,
+  /**
+   * Internal: how `.dependsOn()` carries edges into the copy it returns.
+   * Written as a parameter rather than a mutable field so the builder can
+   * stay immutable without a clone method, the same shape
+   * `KyselyDatabase` uses for its derived forms.
+   */
+  dependencies?: readonly Dependency[]);
+  /**
+   * What this site calls.
+   *
+   * Immutable, like every other builder here: it returns a new site rather than
+   * mutating this one, so a module that exports both a base and a variant of it
+   * cannot have the second silently change the first.
+   *
+   * Takes {@link Declarable} rather than {@link Consumable} because a site's
+   * edge is a build-time link and not a service injection — requiring a client
+   * would exclude exactly the surfaces a frontend actually depends on.
+   */
+  dependsOn(constructs: readonly Declarable[]): StaticSite<TName>;
+  declare(): Declaration[];
+}
+//# sourceMappingURL=site.d.ts.map
+//#endregion
+export { StaticSite, StaticSiteConfig };
+//# sourceMappingURL=site.d.mts.map

package/dist/site.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"site.d.mts","names":[],"sources":["../src/site.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;UA4CiB,gBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YA0CN;;cAGE,qDACD,WAAW;;;;;;;;;eAET;;;;kBAIR,cAAc,iBACO;;;;;;;0BAOe;;;;;;;;;;;;iCAiBV,eAAe,WAAW;aAO9C"}

package/dist/site.mjs

@@ -0,0 +1,47 @@
+import { edgeTo } from "./construct-interface-Z4CpS8tK.mjs";
+import { canonicalId, provideKey } from "@geekmidas/manifest";
+
+//#region src/site.ts
+var StaticSite = class StaticSite {
+	id;
+	keys;
+	constructor(id, config = {}, dependencies = []) {
+		this.config = config;
+		this.dependencies = dependencies;
+		this.id = canonicalId(id);
+		this.keys = { url: provideKey(this.id, "url") };
+	}
+	/**
+	* What this site calls.
+	*
+	* Immutable, like every other builder here: it returns a new site rather than
+	* mutating this one, so a module that exports both a base and a variant of it
+	* cannot have the second silently change the first.
+	*
+	* Takes {@link Declarable} rather than {@link Consumable} because a site's
+	* edge is a build-time link and not a service injection — requiring a client
+	* would exclude exactly the surfaces a frontend actually depends on.
+	*/
+	dependsOn(constructs) {
+		return new StaticSite(this.id, this.config, [...this.dependencies, ...constructs.map(edgeTo)]);
+	}
+	declare() {
+		return [{
+			kind: "site",
+			id: this.id,
+			variant: this.config.variant ?? "static",
+			app: {
+				...this.config.path ? { path: this.config.path } : {},
+				...this.config.port ? { port: this.config.port } : {},
+				...this.config.config ? { config: this.config.config } : {}
+			},
+			...this.config.root ? { root: true } : {},
+			dependencies: this.dependencies,
+			provides: [this.keys.url]
+		}];
+	}
+};
+
+//#endregion
+export { StaticSite };
+//# sourceMappingURL=site.mjs.map

package/dist/site.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"site.mjs","names":["id: ConstructName<TName>","config: StaticSiteConfig","dependencies: readonly Dependency[]","constructs: readonly Declarable[]"],"sources":["../src/site.ts"],"sourcesContent":["/**\n * `StaticSite` — a frontend, declared like anything else.\n *\n * The point is not that a site needs provisioning; it is that a site is the\n * *consumer* whose edges make four hand-maintained lists derivable. Declaring it\n * is what turns \"which origins does the API allow\" from something a person keeps\n * in step into something the graph already knows.\n *\n * ```ts\n * export const console = new StaticSite('Console', { path: 'apps/console' })\n *   .dependsOn([api, auth]);\n * ```\n *\n * It has no `.service`. A site is not a process that registers clients — it is\n * built, and the values it needs are inlined or fetched by its own framework —\n * so the edge is {@link Declarable} rather than {@link Consumable}, and the\n * asymmetry is the honest one: a site consumes addresses, not connections.\n *\n * Only the static variant ships. SSR deploy shapes are unstable and each one is\n * its own maintenance, so they follow rather than arrive together; Expo and\n * mobile are out of scope entirely, because an app store is not infrastructure\n * and there is no URL to hand anyone.\n */\n\nimport {\n\ttype ConstructName,\n\tcanonicalId,\n\ttype Declaration,\n\ttype Dependency,\n\tprovideKey,\n\ttype SiteDeclaration,\n} from '@geekmidas/manifest';\nimport { type Declarable, edgeTo } from './construct-interface';\n\n/**\n * A site's config is flat, where a surface's nests its `app`.\n *\n * Not an inconsistency: a `RestApi` may or may not have a process of its own,\n * so \"what the surface is\" and \"how its process is built\" are separable there\n * and worth separating. A site *is* its app — there is nothing to separate it\n * from, and `{ app: { path } }` would be a wrapper around the only thing in it.\n *\n * Every field is optional, so `new StaticSite('Web')` is a complete site.\n */\nexport interface StaticSiteConfig {\n\t/**\n\t * Where its source lives, relative to the workspace root.\n\t *\n\t * Optional, and normally omitted: `apps/<kebab-id>` where that directory\n\t * exists, and the workspace root otherwise. `StaticSite('Web')` means\n\t * `apps/web`, which is the thing the id already said.\n\t *\n\t * Worth writing only when the layout differs — `path: 'sites/marketing'`.\n\t */\n\tpath?: string;\n\t/**\n\t * The port it answers on locally.\n\t *\n\t * Normally omitted: ports are assigned in a stable order, so adding a site\n\t * does not renumber the ones already running.\n\t */\n\tport?: number;\n\t/**\n\t * Modules to import when sniffing which env vars this site reads.\n\t *\n\t * A frontend's values are inlined at build time, so the build has to know\n\t * which ones it reads before it reads them.\n\t */\n\tconfig?: { client?: string; server?: string };\n\t/**\n\t * Whether the base domain points at this site.\n\t *\n\t * A project with one site needs this no more than a project with one\n\t * database needs to say which database. It matters when there are several\n\t * and none is called `web`: the base domain then belongs to whichever site\n\t * says so, rather than to whichever file the glob happened to reach first.\n\t */\n\troot?: boolean;\n\t/**\n\t * Which framework builds it.\n\t *\n\t * It selects how values are delivered — `VITE_`, `NEXT_PUBLIC_`, a fetched\n\t * `config.json` — and never which values there are. One neutral name from the\n\t * construct, one serialisation per framework, the same rule as everywhere\n\t * else.\n\t */\n\tvariant?: SiteDeclaration['variant'];\n}\n\nexport class StaticSite<TName extends string = string>\n\timplements Declarable<TName>\n{\n\treadonly id: TName;\n\treadonly keys: { url: string };\n\n\tconstructor(\n\t\tid: ConstructName<TName>,\n\t\tprivate readonly config: StaticSiteConfig = {},\n\t\t/**\n\t\t * Internal: how `.dependsOn()` carries edges into the copy it returns.\n\t\t * Written as a parameter rather than a mutable field so the builder can\n\t\t * stay immutable without a clone method, the same shape\n\t\t * `KyselyDatabase` uses for its derived forms.\n\t\t */\n\t\tprivate readonly dependencies: readonly Dependency[] = [],\n\t) {\n\t\tthis.id = canonicalId(id as string) as TName;\n\t\tthis.keys = { url: provideKey(this.id, 'url') };\n\t}\n\n\t/**\n\t * What this site calls.\n\t *\n\t * Immutable, like every other builder here: it returns a new site rather than\n\t * mutating this one, so a module that exports both a base and a variant of it\n\t * cannot have the second silently change the first.\n\t *\n\t * Takes {@link Declarable} rather than {@link Consumable} because a site's\n\t * edge is a build-time link and not a service injection — requiring a client\n\t * would exclude exactly the surfaces a frontend actually depends on.\n\t */\n\tdependsOn(constructs: readonly Declarable[]): StaticSite<TName> {\n\t\treturn new StaticSite<TName>(this.id as ConstructName<TName>, this.config, [\n\t\t\t...this.dependencies,\n\t\t\t...constructs.map(edgeTo),\n\t\t]);\n\t}\n\n\tdeclare(): Declaration[] {\n\t\treturn [\n\t\t\t{\n\t\t\t\tkind: 'site',\n\t\t\t\tid: this.id,\n\t\t\t\tvariant: this.config.variant ?? 'static',\n\t\t\t\tapp: {\n\t\t\t\t\t...(this.config.path ? { path: this.config.path } : {}),\n\t\t\t\t\t...(this.config.port ? { port: this.config.port } : {}),\n\t\t\t\t\t...(this.config.config ? { config: this.config.config } : {}),\n\t\t\t\t},\n\t\t\t\t...(this.config.root ? { root: true } : {}),\n\t\t\t\tdependencies: this.dependencies,\n\t\t\t\tprovides: [this.keys.url],\n\t\t\t},\n\t\t];\n\t}\n}\n"],"mappings":";;;;AAyFA,IAAa,aAAb,MAAa,WAEb;CACC,AAAS;CACT,AAAS;CAET,YACCA,IACiBC,SAA2B,CAAE,GAO7BC,eAAsC,CAAE,GACxD;EARgB;EAOA;AAEjB,OAAK,KAAK,YAAY,GAAa;AACnC,OAAK,OAAO,EAAE,KAAK,WAAW,KAAK,IAAI,MAAM,CAAE;CAC/C;;;;;;;;;;;;CAaD,UAAUC,YAAsD;AAC/D,SAAO,IAAI,WAAkB,KAAK,IAA4B,KAAK,QAAQ,CAC1E,GAAG,KAAK,cACR,GAAG,WAAW,IAAI,OAAO,AACzB;CACD;CAED,UAAyB;AACxB,SAAO,CACN;GACC,MAAM;GACN,IAAI,KAAK;GACT,SAAS,KAAK,OAAO,WAAW;GAChC,KAAK;IACJ,GAAI,KAAK,OAAO,OAAO,EAAE,MAAM,KAAK,OAAO,KAAM,IAAG,CAAE;IACtD,GAAI,KAAK,OAAO,OAAO,EAAE,MAAM,KAAK,OAAO,KAAM,IAAG,CAAE;IACtD,GAAI,KAAK,OAAO,SAAS,EAAE,QAAQ,KAAK,OAAO,OAAQ,IAAG,CAAE;GAC5D;GACD,GAAI,KAAK,OAAO,OAAO,EAAE,MAAM,KAAM,IAAG,CAAE;GAC1C,cAAc,KAAK;GACnB,UAAU,CAAC,KAAK,KAAK,GAAI;EACzB,CACD;CACD;AACD"}

package/dist/subscribers/index.cjs

@@ -1,15 +1,17 @@
-const require_Construct = require('../Construct-vXMZJgRp.cjs');
-const __geekmidas_logger_console = require_Construct.__toESM(require("@geekmidas/logger/console"));
+const require_chunk = require('../chunk-DWy1uDak.cjs');
+const require_construct_interface = require('../construct-interface-BfjcOD_E.cjs');
+const require_Construct = require('../Construct-roId57cU.cjs');
+const require_clone = require('../clone-Dy0cR2SZ.cjs');
+const __geekmidas_logger_console = require_chunk.__toESM(require("@geekmidas/logger/console"));
 
 //#region src/subscribers/Subscriber.ts
-const DEFAULT_LOGGER$1 = new __geekmidas_logger_console.ConsoleLogger();
 var Subscriber = class extends require_Construct.Construct {
 	__IS_SUBSCRIBER__ = true;
 	static isSubscriber(obj) {
 		return Boolean(obj && obj.__IS_SUBSCRIBER__ === true && obj.type === require_Construct.ConstructType.Subscriber);
 	}
-	constructor(handler, timeout = 3e4, _subscribedEvents, outputSchema, services = [], logger = DEFAULT_LOGGER$1, publisherService, topicName) {
-		super(require_Construct.ConstructType.Subscriber, logger, services, [], publisherService, outputSchema);
+	constructor(handler, timeout = 3e4, _subscribedEvents, outputSchema, services = [], logger = __geekmidas_logger_console.DEFAULT_LOGGER, publisherService, topicName, constructs = []) {
+		super(require_Construct.ConstructType.Subscriber, logger, services, [], publisherService, outputSchema, timeout, void 0, void 0, constructs);
 		this.handler = handler;
 		this.timeout = timeout;
 		this._subscribedEvents = _subscribedEvents;
@@ -31,6 +33,8 @@ var SubscriberBuilder = class {
 	_timeout;
 	outputSchema;
 	_services = [];
+	/** The construct ids `.dependsOn()` named — what the manifest records. */
+	_constructs = [];
 	_logger = __geekmidas_logger_console.DEFAULT_LOGGER;
 	_publisher;
 	_topicName;
@@ -49,43 +53,47 @@ var SubscriberBuilder = class {
 	* subscriber actually publishes follow-up events.
 	*/
 	topic(topic) {
-		this._topicName = topic.name;
-		return this;
+		return require_clone.cloneWith(this, { _topicName: topic.name });
 	}
 	timeout(timeout) {
-		this._timeout = timeout;
-		return this;
+		return require_clone.cloneWith(this, { _timeout: timeout });
 	}
 	output(schema) {
-		this.outputSchema = schema;
-		return this;
+		return require_clone.cloneWith(this, { outputSchema: schema });
+	}
+	/**
+	* Depend on constructs — a database, a bucket, a mail sender, a queue, a
+	* topic.
+	*
+	* It records the edge and dissolves each construct's client into the
+	* handler's service record under the construct's own id, so
+	* `.dependsOn([uploads])` is what makes `services.uploads` exist and type.
+	*
+	* Constructs only. A `Service` does not match the shape, which is what keeps
+	* env sniffing confined to `.services()` and the explicit lift.
+	*/
+	dependsOn(constructs) {
+		const services = require_construct_interface.servicesOf(constructs);
+		return require_clone.cloneWith(this, {
+			_services: [...this._services, ...services],
+			_constructs: require_construct_interface.idsOf(constructs, this._constructs)
+		});
 	}
 	services(services) {
-		this._services = [...this._services, ...services];
-		return this;
+		return require_clone.cloneWith(this, { _services: [...this._services, ...services] });
 	}
 	logger(logger) {
-		this._logger = logger;
-		return this;
+		return require_clone.cloneWith(this, { _logger: logger });
 	}
 	publisher(publisher) {
-		this._publisher = publisher;
-		return this;
+		return require_clone.cloneWith(this, { _publisher: publisher });
 	}
 	subscribe(event) {
 		const eventsToAdd = Array.isArray(event) ? event : [event];
-		this._subscribedEvents = [...this._subscribedEvents, ...eventsToAdd];
-		return this;
+		return require_clone.cloneWith(this, { _subscribedEvents: [...this._subscribedEvents, ...eventsToAdd] });
 	}
 	handle(fn) {
-		const subscriber = new Subscriber(fn, this._timeout, this._subscribedEvents, this.outputSchema, this._services, this._logger, this._publisher, this._topicName);
-		this._services = [];
-		this._logger = __geekmidas_logger_console.DEFAULT_LOGGER;
-		this._publisher = void 0;
-		this._topicName = void 0;
-		this._subscribedEvents = [];
-		this._timeout = 3e4;
-		this.outputSchema = void 0;
+		const subscriber = new Subscriber(fn, this._timeout, this._subscribedEvents, this.outputSchema, this._services, this._logger, this._publisher, this._topicName, this._constructs);
 		return subscriber;
 	}
 };