@geekmidas/constructs 10.0.0-alpha.1 → 10.0.0-alpha.100

package/dist/shutdown-BMJmAhSt.cjs

@@ -0,0 +1,38 @@
+//#region src/shutdown.ts
+const key = Symbol.for("@geekmidas/constructs/shutdown");
+const registry = globalThis;
+registry[key] ??= /* @__PURE__ */ new Set();
+const hooks = registry[key];
+/** Run `hook` when the server shuts down. Returns a function that removes it. */
+function onShutdown(hook) {
+	hooks.add(hook);
+	return () => hooks.delete(hook);
+}
+/**
+* Run every registered hook, together, and wait for them. A hook that fails is
+* reported to `onError` and does not stop the others.
+*/
+async function runShutdownHooks(onError = () => {}) {
+	await Promise.all([...hooks].map(async (hook) => {
+		try {
+			await hook();
+		} catch (error) {
+			onError(error);
+		}
+	}));
+}
+//#endregion
+Object.defineProperty(exports, "onShutdown", {
+	enumerable: true,
+	get: function() {
+		return onShutdown;
+	}
+});
+Object.defineProperty(exports, "runShutdownHooks", {
+	enumerable: true,
+	get: function() {
+		return runShutdownHooks;
+	}
+});
+
+//# sourceMappingURL=shutdown-BMJmAhSt.cjs.map

package/dist/shutdown-BMJmAhSt.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"shutdown-BMJmAhSt.cjs","names":[],"sources":["../src/shutdown.ts"],"sourcesContent":["/**\n * What a server releases when it stops: the connections constructs opened.\n *\n * A construct that holds something open — a database's pool — registers how to\n * close it here, and the generated server runs every hook once it has stopped\n * taking requests. Without that, a rolling deploy has the old task and the new\n * one both holding connections until the old process dies.\n *\n * Kept free of any driver import so the server entry can always import it,\n * whether or not the app has a database.\n */\n\ntype ShutdownHook = () => Promise<void> | void;\n\n// On globalThis, as Credentials are: a package loaded twice (ESM and CJS)\n// would otherwise keep two registries, and the server would run the empty one.\nconst key = Symbol.for('@geekmidas/constructs/shutdown');\nconst registry = globalThis as Record<symbol, Set<ShutdownHook> | undefined>;\nregistry[key] ??= new Set<ShutdownHook>();\nconst hooks = registry[key];\n\n/** Run `hook` when the server shuts down. Returns a function that removes it. */\nexport function onShutdown(hook: ShutdownHook): () => void {\n\thooks.add(hook);\n\treturn () => hooks.delete(hook);\n}\n\n/**\n * Run every registered hook, together, and wait for them. A hook that fails is\n * reported to `onError` and does not stop the others.\n */\nexport async function runShutdownHooks(\n\tonError: (error: unknown) => void = () => {},\n): Promise<void> {\n\tawait Promise.all(\n\t\t[...hooks].map(async (hook) => {\n\t\t\ttry {\n\t\t\t\tawait hook();\n\t\t\t} catch (error) {\n\t\t\t\tonError(error);\n\t\t\t}\n\t\t}),\n\t);\n}\n"],"mappings":";AAgBA,MAAM,MAAM,OAAO,IAAI,gCAAgC;AACvD,MAAM,WAAW;AACjB,SAAS,yBAAS,IAAI,IAAkB;AACxC,MAAM,QAAQ,SAAS;;AAGvB,SAAgB,WAAW,MAAgC;CAC1D,MAAM,IAAI,IAAI;CACd,aAAa,MAAM,OAAO,IAAI;AAC/B;;;;;AAMA,eAAsB,iBACrB,gBAA0C,CAAC,GAC3B;CAChB,MAAM,QAAQ,IACb,CAAC,GAAG,KAAK,CAAC,CAAC,IAAI,OAAO,SAAS;EAC9B,IAAI;GACH,MAAM,KAAK;EACZ,SAAS,OAAO;GACf,QAAQ,KAAK;EACd;CACD,CAAC,CACF;AACD"}

package/dist/shutdown-C7xa8x9S.mjs

@@ -0,0 +1,27 @@
+//#region src/shutdown.ts
+const key = Symbol.for("@geekmidas/constructs/shutdown");
+const registry = globalThis;
+registry[key] ??= /* @__PURE__ */ new Set();
+const hooks = registry[key];
+/** Run `hook` when the server shuts down. Returns a function that removes it. */
+function onShutdown(hook) {
+	hooks.add(hook);
+	return () => hooks.delete(hook);
+}
+/**
+* Run every registered hook, together, and wait for them. A hook that fails is
+* reported to `onError` and does not stop the others.
+*/
+async function runShutdownHooks(onError = () => {}) {
+	await Promise.all([...hooks].map(async (hook) => {
+		try {
+			await hook();
+		} catch (error) {
+			onError(error);
+		}
+	}));
+}
+//#endregion
+export { runShutdownHooks as n, onShutdown as t };
+
+//# sourceMappingURL=shutdown-C7xa8x9S.mjs.map

package/dist/shutdown-C7xa8x9S.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"shutdown-C7xa8x9S.mjs","names":[],"sources":["../src/shutdown.ts"],"sourcesContent":["/**\n * What a server releases when it stops: the connections constructs opened.\n *\n * A construct that holds something open — a database's pool — registers how to\n * close it here, and the generated server runs every hook once it has stopped\n * taking requests. Without that, a rolling deploy has the old task and the new\n * one both holding connections until the old process dies.\n *\n * Kept free of any driver import so the server entry can always import it,\n * whether or not the app has a database.\n */\n\ntype ShutdownHook = () => Promise<void> | void;\n\n// On globalThis, as Credentials are: a package loaded twice (ESM and CJS)\n// would otherwise keep two registries, and the server would run the empty one.\nconst key = Symbol.for('@geekmidas/constructs/shutdown');\nconst registry = globalThis as Record<symbol, Set<ShutdownHook> | undefined>;\nregistry[key] ??= new Set<ShutdownHook>();\nconst hooks = registry[key];\n\n/** Run `hook` when the server shuts down. Returns a function that removes it. */\nexport function onShutdown(hook: ShutdownHook): () => void {\n\thooks.add(hook);\n\treturn () => hooks.delete(hook);\n}\n\n/**\n * Run every registered hook, together, and wait for them. A hook that fails is\n * reported to `onError` and does not stop the others.\n */\nexport async function runShutdownHooks(\n\tonError: (error: unknown) => void = () => {},\n): Promise<void> {\n\tawait Promise.all(\n\t\t[...hooks].map(async (hook) => {\n\t\t\ttry {\n\t\t\t\tawait hook();\n\t\t\t} catch (error) {\n\t\t\t\tonError(error);\n\t\t\t}\n\t\t}),\n\t);\n}\n"],"mappings":";AAgBA,MAAM,MAAM,OAAO,IAAI,gCAAgC;AACvD,MAAM,WAAW;AACjB,SAAS,yBAAS,IAAI,IAAkB;AACxC,MAAM,QAAQ,SAAS;;AAGvB,SAAgB,WAAW,MAAgC;CAC1D,MAAM,IAAI,IAAI;CACd,aAAa,MAAM,OAAO,IAAI;AAC/B;;;;;AAMA,eAAsB,iBACrB,gBAA0C,CAAC,GAC3B;CAChB,MAAM,QAAQ,IACb,CAAC,GAAG,KAAK,CAAC,CAAC,IAAI,OAAO,SAAS;EAC9B,IAAI;GACH,MAAM,KAAK;EACZ,SAAS,OAAO;GACf,QAAQ,KAAK;EACd;CACD,CAAC,CACF;AACD"}

package/dist/site.cjs

@@ -1,16 +1,40 @@
-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"));
-
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_construct_interface = require("./construct-interface.cjs");
+let _geekmidas_manifest = require("@geekmidas/manifest");
 //#region src/site.ts
+/**
+* `StaticSite` — a frontend, declared like anything else.
+*
+* The point is not that a site needs provisioning; it is that a site is the
+* *consumer* whose edges make four hand-maintained lists derivable. Declaring it
+* is what turns "which origins does the API allow" from something a person keeps
+* in step into something the graph already knows.
+*
+* ```ts
+* export const console = new StaticSite('Console', { path: 'apps/console' })
+*   .dependsOn([api, auth]);
+* ```
+*
+* It has no `.service`. A site is not a process that registers clients — it is
+* built, and the values it needs are inlined or fetched by its own framework —
+* so the edge is {@link Declarable} rather than {@link Consumable}, and the
+* asymmetry is the honest one: a site consumes addresses, not connections.
+*
+* Only the static variant ships. SSR deploy shapes are unstable and each one is
+* its own maintenance, so they follow rather than arrive together. A mobile app
+* is not a site — it is reached by a scheme, not a URL — and is its own
+* construct: see `MobileApp`.
+*/
 var StaticSite = class StaticSite {
+	config;
+	dependencies;
 	id;
 	keys;
-	constructor(id, config = {}, dependencies = []) {
+	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") };
+		this.id = (0, _geekmidas_manifest.canonicalId)(id);
+		this.keys = { url: (0, _geekmidas_manifest.provideKey)(this.id, "url") };
 	}
 	/**
 	* What this site calls.
@@ -31,18 +55,20 @@ var StaticSite = class StaticSite {
 			kind: "site",
 			id: this.id,
 			variant: this.config.variant ?? "static",
+			...this.config.subdomain ? { subdomain: this.config.subdomain } : {},
 			app: {
-				...this.config.path ? { path: 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,
+			...this.config.telemetry ? { telemetry: this.config.telemetry.id } : {},
 			provides: [this.keys.url]
 		}];
 	}
 };
-
 //#endregion
 exports.StaticSite = StaticSite;
+
 //# sourceMappingURL=site.cjs.map

package/dist/site.cjs.map

@@ -1 +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"}
+{"version":3,"file":"site.cjs","names":["canonicalId","provideKey","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. A mobile app\n * is not a site — it is reached by a scheme, not a URL — and is its own\n * construct: see `MobileApp`.\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';\nimport type { Telemetry } from './telemetry';\n\n/**\n * Where a site's source lives, and the little else a layout can differ by.\n *\n * Only `path` is required: `new StaticSite('Web', { path: 'apps/web' })` is a\n * complete site.\n */\nexport interface StaticSiteConfig {\n\t/**\n\t * Where its source lives, relative to the workspace root — `'apps/web'`.\n\t *\n\t * Required, the same field `RestApi` and `BetterAuth` take. It was\n\t * inferred from the id, which made a site's home whatever was on disk.\n\t */\n\tpath: string;\n\t/**\n\t * The label it answers on under a stage's domain — `api` for\n\t * `api.myapp.com`, from `domains` — and under the project locally,\n\t * `api.myapp.localhost`. Absent, its id kebab-cased.\n\t */\n\tsubdomain?: 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\t/**\n\t * What the site emits — the `Telemetry` construct. An edge to the node and\n\t * nothing more for now: a site is handed none of its server keys, and the\n\t * browser half (propagation from the generated client, then a browser SDK\n\t * exporting through the API) builds on this edge.\n\t */\n\ttelemetry?: Telemetry;\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\t...(this.config.subdomain ? { subdomain: this.config.subdomain } : {}),\n\t\t\t\tapp: {\n\t\t\t\t\tpath: 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\t...(this.config.telemetry\n\t\t\t\t\t? { telemetry: this.config.telemetry.id }\n\t\t\t\t\t: {}),\n\t\t\t\tprovides: [this.keys.url],\n\t\t\t},\n\t\t];\n\t}\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AAgGA,IAAa,aAAb,MAAa,WAEb;CAMmB;CAOA;CAZlB;CACA;CAEA,YACC,IACA,QAOA,eAAuD,CAAC,GACvD;EARgB,KAAA,SAAA;EAOA,KAAA,eAAA;EAEjB,KAAK,MAAA,GAAKA,oBAAAA,YAAAA,CAAY,EAAY;EAClC,KAAK,OAAO,EAAE,MAAA,GAAKC,oBAAAA,WAAAA,CAAW,KAAK,IAAI,KAAK,EAAE;CAC/C;;;;;;;;;;;;CAaA,UAAU,YAAsD;EAC/D,OAAO,IAAI,WAAkB,KAAK,IAA4B,KAAK,QAAQ,CAC1E,GAAG,KAAK,cACR,GAAG,WAAW,IAAIC,4BAAAA,MAAM,CACzB,CAAC;CACF;CAEA,UAAyB;EACxB,OAAO,CACN;GACC,MAAM;GACN,IAAI,KAAK;GACT,SAAS,KAAK,OAAO,WAAW;GAChC,GAAI,KAAK,OAAO,YAAY,EAAE,WAAW,KAAK,OAAO,UAAU,IAAI,CAAC;GACpE,KAAK;IACJ,MAAM,KAAK,OAAO;IAClB,GAAI,KAAK,OAAO,OAAO,EAAE,MAAM,KAAK,OAAO,KAAK,IAAI,CAAC;IACrD,GAAI,KAAK,OAAO,SAAS,EAAE,QAAQ,KAAK,OAAO,OAAO,IAAI,CAAC;GAC5D;GACA,GAAI,KAAK,OAAO,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;GACzC,cAAc,KAAK;GACnB,GAAI,KAAK,OAAO,YACb,EAAE,WAAW,KAAK,OAAO,UAAU,GAAG,IACtC,CAAC;GACJ,UAAU,CAAC,KAAK,KAAK,GAAG;EACzB,CACD;CACD;AACD"}

package/dist/site.d.cts

@@ -1,29 +1,27 @@
-import { Declarable } from "./construct-interface-D2nNkHUN.cjs";
+import { i as Declarable } from "./construct-interface-B1AfqRl4.cjs";
+import { n as Telemetry } from "./telemetry-B48RLjyk.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`.
+ * Where a site's source lives, and the little else a layout can differ by.
  *
- * 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.
+ * Only `path` is required: `new StaticSite('Web', { path: 'apps/web' })` is a
+ * complete site.
  */
-interface StaticSiteConfig {
+export 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.
+   * Where its source lives, relative to the workspace root — `'apps/web'`.
    *
-   * Worth writing only when the layout differs — `path: 'sites/marketing'`.
+   * Required, the same field `RestApi` and `BetterAuth` take. It was
+   * inferred from the id, which made a site's home whatever was on disk.
+   */
+  path: string;
+  /**
+   * The label it answers on under a stage's domain — `api` for
+   * `api.myapp.com`, from `domains` — and under the project locally,
+   * `api.myapp.localhost`. Absent, its id kebab-cased.
    */
-  path?: string;
+  subdomain?: string;
   /**
    * The port it answers on locally.
    *
@@ -59,8 +57,15 @@ interface StaticSiteConfig {
    * else.
    */
   variant?: SiteDeclaration['variant'];
+  /**
+   * What the site emits — the `Telemetry` construct. An edge to the node and
+   * nothing more for now: a site is handed none of its server keys, and the
+   * browser half (propagation from the generated client, then a browser SDK
+   * exporting through the API) builds on this edge.
+   */
+  telemetry?: Telemetry;
 }
-declare class StaticSite<TName extends string = string> implements Declarable<TName> {
+export declare class StaticSite<TName extends string = string> implements Declarable<TName> {
   private readonly config;
   /**
    * Internal: how `.dependsOn()` carries edges into the copy it returns.
@@ -73,7 +78,7 @@ declare class StaticSite<TName extends string = string> implements Declarable<TN
   readonly keys: {
     url: string;
   };
-  constructor(id: ConstructName<TName>, config?: StaticSiteConfig,
+  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
@@ -95,7 +100,5 @@ declare class StaticSite<TName extends string = string> implements Declarable<TN
   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

@@ -1 +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"}
+{"version":3,"file":"site.d.cts","names":[],"sources":["../src/site.ts"],"mappings":";;;;;;;;;;iBAyCiB;;;;;;;EAOhB;;;;;;EAMA;;;;;;;EAOA;;;;;;;EAOA;IAAW;IAAiB;;;;;;;;;;EAS5B;;;;;;;;;EASA,UAAU;;;;;;;EAOV,YAAY;;qBAGA,WAAW,0CACZ,WAAW;mBAOJ;;;;;;;mBAOA;WAZT,IAAI;WACJ;IAAQ;;EAEjB,YACC,IAAI,cAAc,QACD,QAAQ,kBAOR;;;;;;;EAAA,wBAAuB;;;;;;;;;;;;EAiBzC,UAAU,qBAAqB,eAAe,WAAW;EAOzD,WAAW"}

package/dist/site.d.mts

@@ -1,29 +1,27 @@
-import { Declarable } from "./construct-interface-BqwRNYA2.mjs";
+import { i as Declarable } from "./construct-interface-DluK3_da.mjs";
+import { n as Telemetry } from "./telemetry-DRtT1_0A.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`.
+ * Where a site's source lives, and the little else a layout can differ by.
  *
- * 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.
+ * Only `path` is required: `new StaticSite('Web', { path: 'apps/web' })` is a
+ * complete site.
  */
-interface StaticSiteConfig {
+export 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.
+   * Where its source lives, relative to the workspace root — `'apps/web'`.
    *
-   * Worth writing only when the layout differs — `path: 'sites/marketing'`.
+   * Required, the same field `RestApi` and `BetterAuth` take. It was
+   * inferred from the id, which made a site's home whatever was on disk.
+   */
+  path: string;
+  /**
+   * The label it answers on under a stage's domain — `api` for
+   * `api.myapp.com`, from `domains` — and under the project locally,
+   * `api.myapp.localhost`. Absent, its id kebab-cased.
    */
-  path?: string;
+  subdomain?: string;
   /**
    * The port it answers on locally.
    *
@@ -59,8 +57,15 @@ interface StaticSiteConfig {
    * else.
    */
   variant?: SiteDeclaration['variant'];
+  /**
+   * What the site emits — the `Telemetry` construct. An edge to the node and
+   * nothing more for now: a site is handed none of its server keys, and the
+   * browser half (propagation from the generated client, then a browser SDK
+   * exporting through the API) builds on this edge.
+   */
+  telemetry?: Telemetry;
 }
-declare class StaticSite<TName extends string = string> implements Declarable<TName> {
+export declare class StaticSite<TName extends string = string> implements Declarable<TName> {
   private readonly config;
   /**
    * Internal: how `.dependsOn()` carries edges into the copy it returns.
@@ -73,7 +78,7 @@ declare class StaticSite<TName extends string = string> implements Declarable<TN
   readonly keys: {
     url: string;
   };
-  constructor(id: ConstructName<TName>, config?: StaticSiteConfig,
+  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
@@ -95,7 +100,5 @@ declare class StaticSite<TName extends string = string> implements Declarable<TN
   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

@@ -1 +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"}
+{"version":3,"file":"site.d.mts","names":[],"sources":["../src/site.ts"],"mappings":";;;;;;;;;;iBAyCiB;;;;;;;EAOhB;;;;;;EAMA;;;;;;;EAOA;;;;;;;EAOA;IAAW;IAAiB;;;;;;;;;;EAS5B;;;;;;;;;EASA,UAAU;;;;;;;EAOV,YAAY;;qBAGA,WAAW,0CACZ,WAAW;mBAOJ;;;;;;;mBAOA;WAZT,IAAI;WACJ;IAAQ;;EAEjB,YACC,IAAI,cAAc,QACD,QAAQ,kBAOR;;;;;;;EAAA,wBAAuB;;;;;;;;;;;;EAiBzC,UAAU,qBAAqB,eAAe,WAAW;EAOzD,WAAW"}

package/dist/site.mjs

@@ -1,11 +1,35 @@
-import { edgeTo } from "./construct-interface-Z4CpS8tK.mjs";
+import { edgeTo } from "./construct-interface.mjs";
 import { canonicalId, provideKey } from "@geekmidas/manifest";
-
 //#region src/site.ts
+/**
+* `StaticSite` — a frontend, declared like anything else.
+*
+* The point is not that a site needs provisioning; it is that a site is the
+* *consumer* whose edges make four hand-maintained lists derivable. Declaring it
+* is what turns "which origins does the API allow" from something a person keeps
+* in step into something the graph already knows.
+*
+* ```ts
+* export const console = new StaticSite('Console', { path: 'apps/console' })
+*   .dependsOn([api, auth]);
+* ```
+*
+* It has no `.service`. A site is not a process that registers clients — it is
+* built, and the values it needs are inlined or fetched by its own framework —
+* so the edge is {@link Declarable} rather than {@link Consumable}, and the
+* asymmetry is the honest one: a site consumes addresses, not connections.
+*
+* Only the static variant ships. SSR deploy shapes are unstable and each one is
+* its own maintenance, so they follow rather than arrive together. A mobile app
+* is not a site — it is reached by a scheme, not a URL — and is its own
+* construct: see `MobileApp`.
+*/
 var StaticSite = class StaticSite {
+	config;
+	dependencies;
 	id;
 	keys;
-	constructor(id, config = {}, dependencies = []) {
+	constructor(id, config, dependencies = []) {
 		this.config = config;
 		this.dependencies = dependencies;
 		this.id = canonicalId(id);
@@ -30,18 +54,20 @@ var StaticSite = class StaticSite {
 			kind: "site",
 			id: this.id,
 			variant: this.config.variant ?? "static",
+			...this.config.subdomain ? { subdomain: this.config.subdomain } : {},
 			app: {
-				...this.config.path ? { path: 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,
+			...this.config.telemetry ? { telemetry: this.config.telemetry.id } : {},
 			provides: [this.keys.url]
 		}];
 	}
 };
-
 //#endregion
 export { StaticSite };
+
 //# sourceMappingURL=site.mjs.map

package/dist/site.mjs.map

@@ -1 +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"}
+{"version":3,"file":"site.mjs","names":[],"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. A mobile app\n * is not a site — it is reached by a scheme, not a URL — and is its own\n * construct: see `MobileApp`.\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';\nimport type { Telemetry } from './telemetry';\n\n/**\n * Where a site's source lives, and the little else a layout can differ by.\n *\n * Only `path` is required: `new StaticSite('Web', { path: 'apps/web' })` is a\n * complete site.\n */\nexport interface StaticSiteConfig {\n\t/**\n\t * Where its source lives, relative to the workspace root — `'apps/web'`.\n\t *\n\t * Required, the same field `RestApi` and `BetterAuth` take. It was\n\t * inferred from the id, which made a site's home whatever was on disk.\n\t */\n\tpath: string;\n\t/**\n\t * The label it answers on under a stage's domain — `api` for\n\t * `api.myapp.com`, from `domains` — and under the project locally,\n\t * `api.myapp.localhost`. Absent, its id kebab-cased.\n\t */\n\tsubdomain?: 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\t/**\n\t * What the site emits — the `Telemetry` construct. An edge to the node and\n\t * nothing more for now: a site is handed none of its server keys, and the\n\t * browser half (propagation from the generated client, then a browser SDK\n\t * exporting through the API) builds on this edge.\n\t */\n\ttelemetry?: Telemetry;\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\t...(this.config.subdomain ? { subdomain: this.config.subdomain } : {}),\n\t\t\t\tapp: {\n\t\t\t\t\tpath: 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\t...(this.config.telemetry\n\t\t\t\t\t? { telemetry: this.config.telemetry.id }\n\t\t\t\t\t: {}),\n\t\t\t\tprovides: [this.keys.url],\n\t\t\t},\n\t\t];\n\t}\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAgGA,IAAa,aAAb,MAAa,WAEb;CAMmB;CAOA;CAZlB;CACA;CAEA,YACC,IACA,QAOA,eAAuD,CAAC,GACvD;EARgB,KAAA,SAAA;EAOA,KAAA,eAAA;EAEjB,KAAK,KAAK,YAAY,EAAY;EAClC,KAAK,OAAO,EAAE,KAAK,WAAW,KAAK,IAAI,KAAK,EAAE;CAC/C;;;;;;;;;;;;CAaA,UAAU,YAAsD;EAC/D,OAAO,IAAI,WAAkB,KAAK,IAA4B,KAAK,QAAQ,CAC1E,GAAG,KAAK,cACR,GAAG,WAAW,IAAI,MAAM,CACzB,CAAC;CACF;CAEA,UAAyB;EACxB,OAAO,CACN;GACC,MAAM;GACN,IAAI,KAAK;GACT,SAAS,KAAK,OAAO,WAAW;GAChC,GAAI,KAAK,OAAO,YAAY,EAAE,WAAW,KAAK,OAAO,UAAU,IAAI,CAAC;GACpE,KAAK;IACJ,MAAM,KAAK,OAAO;IAClB,GAAI,KAAK,OAAO,OAAO,EAAE,MAAM,KAAK,OAAO,KAAK,IAAI,CAAC;IACrD,GAAI,KAAK,OAAO,SAAS,EAAE,QAAQ,KAAK,OAAO,OAAO,IAAI,CAAC;GAC5D;GACA,GAAI,KAAK,OAAO,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;GACzC,cAAc,KAAK;GACnB,GAAI,KAAK,OAAO,YACb,EAAE,WAAW,KAAK,OAAO,UAAU,GAAG,IACtC,CAAC;GACJ,UAAU,CAAC,KAAK,KAAK,GAAG;EACzB,CACD;CACD;AACD"}

package/dist/stages-BSCF19o2.d.cts

@@ -0,0 +1,56 @@
+//#region src/stages.d.ts
+/**
+ * The project's stage names, as types.
+ *
+ * `gkm.config.ts` declares the stages — `stages: { local: 'dev', deployed:
+ * ['staging', 'prod'] }` — but constructs and application code cannot import
+ * the config, so a stage name written anywhere else was a bare `string`: a
+ * typo'd key in an `ExternalApi`'s `url` map was silently never read, and a
+ * seed's `stage === 'prodution'` branch silently never ran.
+ *
+ * `gkm dev`, `gkm build` and `gkm test --prepare` write `.gkm/stages.d.ts`,
+ * which fills this interface in from the loaded workspace:
+ *
+ * ```ts
+ * declare module '@geekmidas/constructs' {
+ *   interface Stages { local: 'dev'; deployed: 'staging' | 'prod' }
+ * }
+ * ```
+ *
+ * Until that file exists — a fresh clone, before the first run — the interface
+ * is empty and every stage type below is `string`, so nothing fails to compile
+ * for want of a generated file.
+ */
+interface Stages {}
+/** What `Stages` says under `key`, or `string` while it says nothing. */
+type Declared<TKey extends string> = Stages extends { [K in TKey]: infer TStage extends string; } ? TStage : string;
+/** The stage `gkm dev`, `exec`, `setup` and `test` run as: `stages.local`. */
+type LocalStage = Declared<'local'>;
+/** A stage `gkm deploy --stage` accepts: one of `stages.deployed`. */
+type DeployedStage = Declared<'deployed'>;
+/** What `gkm test` runs as. The CLI's own; no project stage may take it. */
+type TestStage = 'test';
+/** Any stage the project's code can find itself running as. */
+type AnyStage = LocalStage | TestStage | DeployedStage;
+/**
+ * What a seed is handed beside its database.
+ *
+ * Seeds run on every stage, production included, so a seed that should write
+ * something only somewhere — a demo tenant on the local stage, never on a
+ * deployed one — decides by the stage it is given:
+ *
+ * ```ts
+ * import type { SeedContext } from '@geekmidas/constructs';
+ *
+ * export async function seed(db: Kysely<Database>, { stage }: SeedContext) {
+ *   if (stage === 'dev') await insertDemoTenant(db);
+ * }
+ * ```
+ */
+interface SeedContext {
+  /** The stage being seeded: the local one, `test`, or a deployed one. */
+  stage: AnyStage;
+}
+//#endregion
+export { Stages as a, SeedContext as i, DeployedStage as n, TestStage as o, LocalStage as r, AnyStage as t };
+//# sourceMappingURL=stages-BSCF19o2.d.cts.map

package/dist/stages-BSCF19o2.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stages-BSCF19o2.d.cts","names":[],"sources":["../src/stages.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;UAuBiB;;KAGZ,SAAS,uBAAuB,kBACnC,KAAK,aAAa,2BAEjB;;KAIS,aAAa;;KAGb,gBAAgB;;KAGhB;;KAGA,WAAW,aAAa,YAAY;;;;;;;;;;;;;;;;UAiB/B;;EAEhB,OAAO"}

package/dist/stages-BSCF19o2.d.mts

@@ -0,0 +1,56 @@
+//#region src/stages.d.ts
+/**
+ * The project's stage names, as types.
+ *
+ * `gkm.config.ts` declares the stages — `stages: { local: 'dev', deployed:
+ * ['staging', 'prod'] }` — but constructs and application code cannot import
+ * the config, so a stage name written anywhere else was a bare `string`: a
+ * typo'd key in an `ExternalApi`'s `url` map was silently never read, and a
+ * seed's `stage === 'prodution'` branch silently never ran.
+ *
+ * `gkm dev`, `gkm build` and `gkm test --prepare` write `.gkm/stages.d.ts`,
+ * which fills this interface in from the loaded workspace:
+ *
+ * ```ts
+ * declare module '@geekmidas/constructs' {
+ *   interface Stages { local: 'dev'; deployed: 'staging' | 'prod' }
+ * }
+ * ```
+ *
+ * Until that file exists — a fresh clone, before the first run — the interface
+ * is empty and every stage type below is `string`, so nothing fails to compile
+ * for want of a generated file.
+ */
+interface Stages {}
+/** What `Stages` says under `key`, or `string` while it says nothing. */
+type Declared<TKey extends string> = Stages extends { [K in TKey]: infer TStage extends string; } ? TStage : string;
+/** The stage `gkm dev`, `exec`, `setup` and `test` run as: `stages.local`. */
+type LocalStage = Declared<'local'>;
+/** A stage `gkm deploy --stage` accepts: one of `stages.deployed`. */
+type DeployedStage = Declared<'deployed'>;
+/** What `gkm test` runs as. The CLI's own; no project stage may take it. */
+type TestStage = 'test';
+/** Any stage the project's code can find itself running as. */
+type AnyStage = LocalStage | TestStage | DeployedStage;
+/**
+ * What a seed is handed beside its database.
+ *
+ * Seeds run on every stage, production included, so a seed that should write
+ * something only somewhere — a demo tenant on the local stage, never on a
+ * deployed one — decides by the stage it is given:
+ *
+ * ```ts
+ * import type { SeedContext } from '@geekmidas/constructs';
+ *
+ * export async function seed(db: Kysely<Database>, { stage }: SeedContext) {
+ *   if (stage === 'dev') await insertDemoTenant(db);
+ * }
+ * ```
+ */
+interface SeedContext {
+  /** The stage being seeded: the local one, `test`, or a deployed one. */
+  stage: AnyStage;
+}
+//#endregion
+export { Stages as a, SeedContext as i, DeployedStage as n, TestStage as o, LocalStage as r, AnyStage as t };
+//# sourceMappingURL=stages-BSCF19o2.d.mts.map

package/dist/stages-BSCF19o2.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stages-BSCF19o2.d.mts","names":[],"sources":["../src/stages.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;UAuBiB;;KAGZ,SAAS,uBAAuB,kBACnC,KAAK,aAAa,2BAEjB;;KAIS,aAAa;;KAGb,gBAAgB;;KAGhB;;KAGA,WAAW,aAAa,YAAY;;;;;;;;;;;;;;;;UAiB/B;;EAEhB,OAAO"}