@geekmidas/constructs 10.0.0-alpha.11 → 10.0.0-alpha.111

package/dist/kysely-DKwnl0nf.d.mts

@@ -0,0 +1,175 @@
+import { n as Construct } from "./construct-interface-ZvYQbivO.mjs";
+import { t as Cache } from "./cache-5QZzh5Er.mjs";
+import { ConstructName, Declaration, PostgresVersion } from "@geekmidas/manifest";
+import { Service } from "@geekmidas/services";
+import { Kysely, KyselyConfig } from "kysely";
+import pg from "pg";
+//#region src/database/pool.d.ts
+/**
+ * End every pool opened, waiting for checked-out connections to come back.
+ * For a server's shutdown, after it has stopped taking requests.
+ */
+declare function closeDatabasePools(): Promise<void>;
+//#endregion
+//#region src/database/kysely.d.ts
+/**
+ * Everything Kysely takes, plus what this construct declares.
+ *
+ * `dialect` is omitted because the construct owns it — it is built from the one
+ * URL the adapter supplied, which is the whole point of the construct. The rest
+ * of `KyselyConfig` (`plugins`, `log`) is the app's business and passes
+ * straight through, so anything Kysely adds later arrives without being
+ * tracked here.
+ */
+interface KyselyDatabaseOptions extends Omit<KyselyConfig, 'dialect'> {
+  /**
+   * The schema, pinned on both roles' `search_path`.
+   *
+   * Defaults to `app` — the role the schema plays, rather than a restatement
+   * of the database's own name, which reads correctly beside `auth` and
+   * `pgboss` and keeps the application off `public`.
+   */
+  schema?: string;
+  /**
+   * Provision the owner/runtime role split. Defaults to on.
+   *
+   * Off falls back to the cluster's master credential in both URLs, giving up
+   * the DDL/DML split and putting credentials that can drop a table into the
+   * function's environment. A deliberate downgrade, not a default.
+   */
+  roles?: boolean;
+  /**
+   * The Postgres major version to provision.
+   *
+   * Declared here so one statement reaches both targets. It was previously
+   * set in two unrelated places — a container tag locally, nothing at all on
+   * AWS (so Aurora chose) — which is how local came to run 18 while deployed
+   * ran 17.7 with nothing recording the difference.
+   *
+   * Defaults to {@link DEFAULT_POSTGRES_VERSION}.
+   */
+  version?: PostgresVersion;
+  /**
+   * End each query run inside a request with a comment naming what ran it —
+   * `/*operation='POST /orders',request_id='…'*\/` — so `pg_stat_activity`
+   * and the server's logs can tie a query to its endpoint — and, inside a
+   * trace, with the query span's `traceparent='00-…'` (sqlcommenter), so
+   * they can tie it to the trace too. Defaults to on.
+   */
+  queryTags?: boolean;
+}
+/** What makes a construct derived rather than a database in its own right. */
+interface DerivedFrom {
+  kind: 'database-reader' | 'database-schema';
+  of: string;
+  schema?: string;
+}
+/**
+ * @typeParam DB - the database's schema.
+ * @typeParam TName - the canonical id. TypeScript has no partial
+ * type-argument inference, so `new KyselyDatabase<OrdersDB>('orders')` leaves
+ * this at its default and the service key widens to `string`. `db` still types
+ * through `.database()`, which infers from the service.
+ */
+declare class KyselyDatabase<DB = unknown, TName extends string = string> implements Construct<TName, Kysely<DB>> {
+  private readonly options;
+  readonly id: TName;
+  readonly service: Service<Uncapitalize<TName>, Kysely<DB>>;
+  /**
+   * Declared once and read by both `declare()` and `connect()`, so the key the
+   * build publishes and the key the client reads cannot drift.
+   */
+  private readonly config;
+  private readonly schemaName;
+  private readonly roles;
+  private readonly version;
+  private readonly derivedFrom?;
+  constructor(id: ConstructName<TName>, options?: KyselyDatabaseOptions, derivedFrom?: DerivedFrom);
+  declare(): Declaration[];
+  /**
+   * A read-only endpoint on this database.
+   *
+   * Read-only is enforced by the reader role's grants rather than by which
+   * endpoint it resolves to, so falling back to the writer where no replica
+   * exists is safe rather than a silently writable connection behind a name
+   * that says reader. There is no `writer()`: the database *is* the writer, so
+   * a replica can never be reached by accident.
+   *
+   * The return type is narrower than this class on purpose — see
+   * {@link ReadOnlyDatabase}.
+   */
+  reader(): ReadOnlyDatabase<DB, `${TName}Reader`>;
+  /**
+   * A cache that lives in this database.
+   *
+   * The same strengthening `schema()` is over a second database: `new
+   * Cache('Sessions')` says the app caches and leaves where to the deployment,
+   * while this says it caches *here* — which is a fact about the application
+   * and so belongs in its code.
+   *
+   * What it buys beyond being explicit: the table's schema and the role that
+   * reaches it come from this database rather than from a second convention,
+   * and the backend no longer has to guess which database "the database" meant
+   * when an app declares two.
+   *
+   * A cache is not a `KyselyDatabase`, so this returns a `Cache` — the client
+   * is a key/value store, not a query builder, and typing it as the parent
+   * would be a convenience that lies.
+   */
+  cache<TCache extends string = `${TName}Cache`>(id?: ConstructName<TCache>, options?: {
+    table?: string;
+  }): Cache<TCache>;
+  /**
+   * A second schema in this database, with its own role(s) and its own URL —
+   * so this database's role holds no grant on those tables at all.
+   *
+   * Typed separately because a tenant has its own tables: the point is that
+   * `auth.selectFrom('sessions')` type-checks and
+   * `orders.selectFrom('sessions')` does not.
+   */
+  schema<TenantDB, TTenant extends string>(id: ConstructName<TTenant>, options?: KyselyDatabaseOptions): KyselyDatabase<TenantDB, TTenant>;
+  /**
+   * A connection as the *owner* role — the one that may create, alter and drop.
+   *
+   * A `Service` rather than part of the construct, and deliberately so: a
+   * construct is what `.dependsOn()` accepts, and nothing should be able to
+   * depend on this. A migrator asks for it by name; a handler cannot ask at
+   * all, which is the security property the role split exists for.
+   *
+   * Falls back to the runtime URL where no owner URL was published — the
+   * `roles: false` downgrade, where there is only one credential and it is the
+   * cluster master's.
+   */
+  get owner(): Service<`${Uncapitalize<TName>}Owner`, Kysely<DB>>;
+  /**
+   * What this database's clients are built with besides a dialect — the
+   * plugins and logging it was declared with.
+   *
+   * Public so that whatever opens a connection to it outside \`connect()\` —
+   * a test's transaction — builds the same client. A test that dropped the
+   * plugins would write \`createdAt\` where production writes \`created_at\`.
+   */
+  get clientConfig(): Omit<KyselyConfig, 'dialect'>;
+  private connect;
+}
+/**
+ * A database you may read through, and derive nothing from.
+ *
+ * A reader is terminal in the graph, and this is that fact in the type system.
+ * `DERIVES_FROM` gives `cache` and `database-schema` no `database-reader`
+ * parent, and there is no reader of a reader — so `orders.reader().cache(…)`
+ * has always been illegal, but it type-checked and failed later at
+ * `assertDerivations`. That is a long way round to learn that a read-only
+ * endpoint cannot own a table something writes to.
+ *
+ * Omitting the three deriving methods rather than making them throw keeps the
+ * failure where it costs least: the editor, on the line that wrote it.
+ *
+ * The result is deliberately not assignable back to `KyselyDatabase` — a
+ * reader is not one, and anything that genuinely needs the writer should say
+ * so.
+ */
+type ReadOnlyDatabase<DB, TName extends string> = Omit<KyselyDatabase<DB, TName>, 'reader' | 'cache' | 'schema'>;
+//#endregion
+export { closeDatabasePools as i, KyselyDatabaseOptions as n, ReadOnlyDatabase as r, KyselyDatabase as t };
+//# sourceMappingURL=kysely-DKwnl0nf.d.mts.map

package/dist/kysely-DKwnl0nf.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kysely-DKwnl0nf.d.mts","names":[],"sources":["../src/database/pool.ts","../src/database/kysely.ts"],"mappings":";;;;;;;;;;;iBAwGsB,sBAAsB;;;;;;;;;;;;UChE3B,8BAA8B,KAAK;;;;;;;;EAQnD;;;;;;;;EAQA;;;;;;;;;;;EAWA,UAAU;;;;;;;;EAQV;;;UAIS;EACT;EACA;EACA;;;;;;;;;cAUY,eAAe,cAAc,0CAC9B,UAAU,OAAO,OAAO;mBAiBjB;WAfT,IAAI;WACJ,SAAS,QAAQ,aAAa,QAAQ,OAAO;;;;;mBAMrC;mBACA;mBACA;mBACA;mBACA;EAEjB,YACC,IAAI,cAAc,QACD,UAAS,uBAC1B,cAAc;EAyBf,WAAW;;;;;;;;;;;;;EAqDX,UAAU,iBAAiB,OAAO;;;;;;;;;;;;;;;;;;EAyBlC,MAAM,2BAA2B,cAChC,KAAI,cAAc,SAClB;IAAW;MACT,MAAM;;;;;;;;;EAeT,OAAO,UAAU,wBAChB,IAAI,cAAc,UAClB,UAAS,wBACP,eAAe,UAAU;;;;;;;;;;;;;MAoBxB,SAAS,WAAW,aAAa,eAAe,OAAO;;;;;;;;;MAgBvD,gBAAgB,KAAK;UAcX;;;;;;;;;;;;;;;;;;;KAuCH,iBAAiB,IAAI,wBAAwB,KACxD,eAAe,IAAI"}

package/dist/{telemetry-C3L0iS28.d.cts → lambdaTelemetry-8vnmVZQ5.d.cts}

@@ -1,7 +1,5 @@
 import { Context } from "aws-lambda";
-
-//#region src/telemetry.d.ts
-
+//#region src/endpoints/lambdaTelemetry.d.ts
 /**
  * Context object returned by onRequestStart, passed to subsequent hooks
  */
@@ -89,7 +87,6 @@ interface Telemetry {
    */
   onRequestError(ctx: TelemetryContext, error: Error): void;
 }
-//# sourceMappingURL=telemetry.d.ts.map
 //#endregion
-export { Telemetry, TelemetryContext, TelemetryRequest, TelemetryResponse };
-//# sourceMappingURL=telemetry-C3L0iS28.d.cts.map
+export { TelemetryResponse as i, TelemetryContext as n, TelemetryRequest as r, Telemetry as t };
+//# sourceMappingURL=lambdaTelemetry-8vnmVZQ5.d.cts.map

package/dist/lambdaTelemetry-8vnmVZQ5.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lambdaTelemetry-8vnmVZQ5.d.cts","names":["LambdaContext"],"sources":["../src/endpoints/lambdaTelemetry.ts"],"mappings":";;;;;UAWiB;;;;GAIf;;;;;UAMe;;;;EAIhB;;;;EAKA,SAASA;;;;;UAMO;;;;EAIhB;;;;EAKA;;;;EAKA,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;UA4BM;;;;;;;EAOhB,eAAe,SAAS,mBAAmB;;;;;;;EAQ3C,aAAa,KAAK,kBAAkB,UAAU;;;;;;;EAQ9C,eAAe,KAAK,kBAAkB,OAAO"}

package/dist/{telemetry-D7bVFLGi.d.mts → lambdaTelemetry-8vnmVZQ5.d.mts}

@@ -1,7 +1,5 @@
 import { Context } from "aws-lambda";
-
-//#region src/telemetry.d.ts
-
+//#region src/endpoints/lambdaTelemetry.d.ts
 /**
  * Context object returned by onRequestStart, passed to subsequent hooks
  */
@@ -89,7 +87,6 @@ interface Telemetry {
    */
   onRequestError(ctx: TelemetryContext, error: Error): void;
 }
-//# sourceMappingURL=telemetry.d.ts.map
 //#endregion
-export { Telemetry, TelemetryContext, TelemetryRequest, TelemetryResponse };
-//# sourceMappingURL=telemetry-D7bVFLGi.d.mts.map
+export { TelemetryResponse as i, TelemetryContext as n, TelemetryRequest as r, Telemetry as t };
+//# sourceMappingURL=lambdaTelemetry-8vnmVZQ5.d.mts.map

package/dist/lambdaTelemetry-8vnmVZQ5.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lambdaTelemetry-8vnmVZQ5.d.mts","names":["LambdaContext"],"sources":["../src/endpoints/lambdaTelemetry.ts"],"mappings":";;;;;UAWiB;;;;GAIf;;;;;UAMe;;;;EAIhB;;;;EAKA,SAASA;;;;;UAMO;;;;EAIhB;;;;EAKA;;;;EAKA,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;UA4BM;;;;;;;EAOhB,eAAe,SAAS,mBAAmB;;;;;;;EAQ3C,aAAa,KAAK,kBAAkB,UAAU;;;;;;;EAQ9C,eAAe,KAAK,kBAAkB,OAAO"}

package/dist/mobile-app.cjs

@@ -0,0 +1,74 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_construct_interface = require("./construct-interface.cjs");
+let _geekmidas_manifest = require("@geekmidas/manifest");
+//#region src/mobile-app.ts
+/**
+* `MobileApp` — an Expo app, declared like a site.
+*
+* Its edges are the point, as a site's are. One `.dependsOn([api, auth])` is
+* the fact behind everything a mobile app otherwise has written down by hand:
+*
+* - its `EXPO_PUBLIC_API_URL` and `EXPO_PUBLIC_AUTH_URL`, which locally are
+*   the servers' own ports — reachable once the app swaps `localhost` for the
+*   address Metro is served from, which is what makes a phone on the LAN work;
+* - with an `Email` among them, Mailpit's inbox on a local stage
+*   (`EXPO_PUBLIC_<ID>_INBOX_URL`), so a sign-in link can be opened from the
+*   app — unset deployed, where there is no inbox;
+* - its URL scheme (`shop`), the same on every stage;
+* - the scheme in the auth server's and the API's trusted origins — and, on a
+*   local stage, the `exp://` origins Expo Go sends from;
+* - Better Auth's Expo plugin on the auth server, and sign-in links an app asks
+*   for built on an address the phone can open.
+*
+* ```ts
+* export const app = new MobileApp('App', { path: 'apps/app' })
+*   .dependsOn([api, auth]);
+* ```
+*
+* Like a site it has no `.service`: it is built by its own toolchain, and
+* consumes addresses rather than connections. Nothing deploys it — EAS and the
+* stores do — so the targets derive *for* it and never run it.
+*/
+var MobileApp = class MobileApp {
+	config;
+	dependencies;
+	id;
+	/** The key its scheme arrives under — what its `app.config.ts` reads. */
+	keys;
+	constructor(id, config, dependencies = []) {
+		this.config = config;
+		this.dependencies = dependencies;
+		this.id = (0, _geekmidas_manifest.canonicalId)(id);
+		this.keys = { scheme: (0, _geekmidas_manifest.provideKey)(this.id, "scheme") };
+	}
+	/**
+	* What this app calls — the surfaces it is built with the URLs of, and the
+	* ones that come to trust its scheme.
+	*
+	* Immutable, like every other builder: it returns a new app rather than
+	* changing this one.
+	*/
+	dependsOn(constructs) {
+		return new MobileApp(this.id, this.config, [...this.dependencies, ...constructs.map(require_construct_interface.edgeTo)]);
+	}
+	declare() {
+		return [{
+			kind: "mobile-app",
+			id: this.id,
+			variant: this.config.variant ?? "expo",
+			app: {
+				path: this.config.path,
+				...this.config.port ? { port: this.config.port } : {},
+				...this.config.config ? { config: this.config.config } : {}
+			},
+			...this.config.scheme ? { scheme: this.config.scheme } : {},
+			...this.config.stages ? { stages: this.config.stages } : {},
+			dependencies: this.dependencies,
+			provides: [this.keys.scheme]
+		}];
+	}
+};
+//#endregion
+exports.MobileApp = MobileApp;
+
+//# sourceMappingURL=mobile-app.cjs.map

package/dist/mobile-app.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"mobile-app.cjs","names":["canonicalId","provideKey","edgeTo"],"sources":["../src/mobile-app.ts"],"sourcesContent":["/**\n * `MobileApp` — an Expo app, declared like a site.\n *\n * Its edges are the point, as a site's are. One `.dependsOn([api, auth])` is\n * the fact behind everything a mobile app otherwise has written down by hand:\n *\n * - its `EXPO_PUBLIC_API_URL` and `EXPO_PUBLIC_AUTH_URL`, which locally are\n *   the servers' own ports — reachable once the app swaps `localhost` for the\n *   address Metro is served from, which is what makes a phone on the LAN work;\n * - with an `Email` among them, Mailpit's inbox on a local stage\n *   (`EXPO_PUBLIC_<ID>_INBOX_URL`), so a sign-in link can be opened from the\n *   app — unset deployed, where there is no inbox;\n * - its URL scheme (`shop`), the same on every stage;\n * - the scheme in the auth server's and the API's trusted origins — and, on a\n *   local stage, the `exp://` origins Expo Go sends from;\n * - Better Auth's Expo plugin on the auth server, and sign-in links an app asks\n *   for built on an address the phone can open.\n *\n * ```ts\n * export const app = new MobileApp('App', { path: 'apps/app' })\n *   .dependsOn([api, auth]);\n * ```\n *\n * Like a site it has no `.service`: it is built by its own toolchain, and\n * consumes addresses rather than connections. Nothing deploys it — EAS and the\n * stores do — so the targets derive *for* it and never run it.\n */\n\nimport {\n\ttype ConstructName,\n\tcanonicalId,\n\ttype Declaration,\n\ttype Dependency,\n\ttype MobileAppDeclaration,\n\ttype MobileAppStage,\n\tprovideKey,\n} from '@geekmidas/manifest';\nimport { type Declarable, edgeTo } from './construct-interface';\n\nexport interface MobileAppConfig {\n\t/**\n\t * Where its source lives, relative to the workspace root — `'apps/app'`.\n\t * Required, the same field a site and a surface take.\n\t */\n\tpath: string;\n\t/**\n\t * The port Metro serves it on locally.\n\t *\n\t * Normally omitted: ports are assigned in a stable order, as a site's are,\n\t * and `gkm exec` hands it to Expo as `RCT_METRO_PORT`.\n\t */\n\tport?: number;\n\t/**\n\t * Modules to import when sniffing which env vars the app reads — its\n\t * values are inlined at build time, as a site's are.\n\t */\n\tconfig?: { client?: string; server?: string };\n\t/**\n\t * Which toolchain builds it — the same field a site names its framework\n\t * by. Expo is the one that ships, and the default.\n\t */\n\tvariant?: MobileAppDeclaration['variant'];\n\t/**\n\t * Its URL scheme.\n\t *\n\t * Normally omitted: it is the project's name — `shop` — on every stage.\n\t * Give one only when the app is known by another name.\n\t */\n\tscheme?: string;\n\t/**\n\t * How a deployed stage ships it, where that differs from the defaults: the\n\t * protected stage reads EAS's `production` environment and submits to\n\t * Play's `production` track, every other deployed stage `preview` and\n\t * `internal`, and every Android release is a `draft` until someone\n\t * releases it in Play Console.\n\t *\n\t * ```ts\n\t * stages: { beta: { environment: 'preview', android: { track: 'alpha' } } }\n\t * ```\n\t */\n\tstages?: Readonly<Record<string, MobileAppStage>>;\n}\n\nexport class MobileApp<TName extends string = string>\n\timplements Declarable<TName>\n{\n\treadonly id: TName;\n\t/** The key its scheme arrives under — what its `app.config.ts` reads. */\n\treadonly keys: { scheme: string };\n\n\tconstructor(\n\t\tid: ConstructName<TName>,\n\t\tprivate readonly config: MobileAppConfig,\n\t\t/** Internal: how `.dependsOn()` carries edges into the copy it returns. */\n\t\tprivate readonly dependencies: readonly Dependency[] = [],\n\t) {\n\t\tthis.id = canonicalId(id as string) as TName;\n\t\tthis.keys = { scheme: provideKey(this.id, 'scheme') };\n\t}\n\n\t/**\n\t * What this app calls — the surfaces it is built with the URLs of, and the\n\t * ones that come to trust its scheme.\n\t *\n\t * Immutable, like every other builder: it returns a new app rather than\n\t * changing this one.\n\t */\n\tdependsOn(constructs: readonly Declarable[]): MobileApp<TName> {\n\t\treturn new MobileApp<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: 'mobile-app',\n\t\t\t\tid: this.id,\n\t\t\t\tvariant: this.config.variant ?? 'expo',\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.scheme ? { scheme: this.config.scheme } : {}),\n\t\t\t\t...(this.config.stages ? { stages: this.config.stages } : {}),\n\t\t\t\tdependencies: this.dependencies,\n\t\t\t\tprovides: [this.keys.scheme],\n\t\t\t},\n\t\t];\n\t}\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmFA,IAAa,YAAb,MAAa,UAEb;CAOmB;CAEA;CARlB;;CAEA;CAEA,YACC,IACA,QAEA,eAAuD,CAAC,GACvD;EAHgB,KAAA,SAAA;EAEA,KAAA,eAAA;EAEjB,KAAK,MAAA,GAAKA,oBAAAA,YAAAA,CAAY,EAAY;EAClC,KAAK,OAAO,EAAE,SAAA,GAAQC,oBAAAA,WAAAA,CAAW,KAAK,IAAI,QAAQ,EAAE;CACrD;;;;;;;;CASA,UAAU,YAAqD;EAC9D,OAAO,IAAI,UAAiB,KAAK,IAA4B,KAAK,QAAQ,CACzE,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,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,SAAS,EAAE,QAAQ,KAAK,OAAO,OAAO,IAAI,CAAC;GAC3D,GAAI,KAAK,OAAO,SAAS,EAAE,QAAQ,KAAK,OAAO,OAAO,IAAI,CAAC;GAC3D,cAAc,KAAK;GACnB,UAAU,CAAC,KAAK,KAAK,MAAM;EAC5B,CACD;CACD;AACD"}

package/dist/mobile-app.d.cts

@@ -0,0 +1,73 @@
+import { i as Declarable } from "./construct-interface-B1AfqRl4.cjs";
+import { ConstructName, Declaration, Dependency, MobileAppDeclaration, MobileAppStage } from "@geekmidas/manifest";
+//#region src/mobile-app.d.ts
+export interface MobileAppConfig {
+  /**
+   * Where its source lives, relative to the workspace root — `'apps/app'`.
+   * Required, the same field a site and a surface take.
+   */
+  path: string;
+  /**
+   * The port Metro serves it on locally.
+   *
+   * Normally omitted: ports are assigned in a stable order, as a site's are,
+   * and `gkm exec` hands it to Expo as `RCT_METRO_PORT`.
+   */
+  port?: number;
+  /**
+   * Modules to import when sniffing which env vars the app reads — its
+   * values are inlined at build time, as a site's are.
+   */
+  config?: {
+    client?: string;
+    server?: string;
+  };
+  /**
+   * Which toolchain builds it — the same field a site names its framework
+   * by. Expo is the one that ships, and the default.
+   */
+  variant?: MobileAppDeclaration['variant'];
+  /**
+   * Its URL scheme.
+   *
+   * Normally omitted: it is the project's name — `shop` — on every stage.
+   * Give one only when the app is known by another name.
+   */
+  scheme?: string;
+  /**
+   * How a deployed stage ships it, where that differs from the defaults: the
+   * protected stage reads EAS's `production` environment and submits to
+   * Play's `production` track, every other deployed stage `preview` and
+   * `internal`, and every Android release is a `draft` until someone
+   * releases it in Play Console.
+   *
+   * ```ts
+   * stages: { beta: { environment: 'preview', android: { track: 'alpha' } } }
+   * ```
+   */
+  stages?: Readonly<Record<string, MobileAppStage>>;
+}
+export declare class MobileApp<TName extends string = string> implements Declarable<TName> {
+  private readonly config;
+  /** Internal: how `.dependsOn()` carries edges into the copy it returns. */
+  private readonly dependencies;
+  readonly id: TName;
+  /** The key its scheme arrives under — what its `app.config.ts` reads. */
+  readonly keys: {
+    scheme: string;
+  };
+  constructor(id: ConstructName<TName>, config: MobileAppConfig,
+  /** Internal: how `.dependsOn()` carries edges into the copy it returns. */
+  dependencies?: readonly Dependency[]);
+  /**
+   * What this app calls — the surfaces it is built with the URLs of, and the
+   * ones that come to trust its scheme.
+   *
+   * Immutable, like every other builder: it returns a new app rather than
+   * changing this one.
+   */
+  dependsOn(constructs: readonly Declarable[]): MobileApp<TName>;
+  declare(): Declaration[];
+}
+//#endregion
+//# sourceMappingURL=mobile-app.d.cts.map

package/dist/mobile-app.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mobile-app.d.cts","names":[],"sources":["../src/mobile-app.ts"],"mappings":";;;iBAuCiB;;;;;EAKhB;;;;;;;EAOA;;;;;EAKA;IAAW;IAAiB;;;;;;EAK5B,UAAU;;;;;;;EAOV;;;;;;;;;;;;EAYA,SAAS,SAAS,eAAe;;qBAGrB,UAAU,0CACX,WAAW;mBAQJ;;mBAEA;WART,IAAI;;WAEJ;IAAQ;;EAEjB,YACC,IAAI,cAAc,QACD,QAAQ,iBAER;;EAAA,wBAAuB;;;;;;;;EAazC,UAAU,qBAAqB,eAAe,UAAU;EAOxD,WAAW"}

package/dist/mobile-app.d.mts

@@ -0,0 +1,73 @@
+import { i as Declarable } from "./construct-interface-ZvYQbivO.mjs";
+import { ConstructName, Declaration, Dependency, MobileAppDeclaration, MobileAppStage } from "@geekmidas/manifest";
+//#region src/mobile-app.d.ts
+export interface MobileAppConfig {
+  /**
+   * Where its source lives, relative to the workspace root — `'apps/app'`.
+   * Required, the same field a site and a surface take.
+   */
+  path: string;
+  /**
+   * The port Metro serves it on locally.
+   *
+   * Normally omitted: ports are assigned in a stable order, as a site's are,
+   * and `gkm exec` hands it to Expo as `RCT_METRO_PORT`.
+   */
+  port?: number;
+  /**
+   * Modules to import when sniffing which env vars the app reads — its
+   * values are inlined at build time, as a site's are.
+   */
+  config?: {
+    client?: string;
+    server?: string;
+  };
+  /**
+   * Which toolchain builds it — the same field a site names its framework
+   * by. Expo is the one that ships, and the default.
+   */
+  variant?: MobileAppDeclaration['variant'];
+  /**
+   * Its URL scheme.
+   *
+   * Normally omitted: it is the project's name — `shop` — on every stage.
+   * Give one only when the app is known by another name.
+   */
+  scheme?: string;
+  /**
+   * How a deployed stage ships it, where that differs from the defaults: the
+   * protected stage reads EAS's `production` environment and submits to
+   * Play's `production` track, every other deployed stage `preview` and
+   * `internal`, and every Android release is a `draft` until someone
+   * releases it in Play Console.
+   *
+   * ```ts
+   * stages: { beta: { environment: 'preview', android: { track: 'alpha' } } }
+   * ```
+   */
+  stages?: Readonly<Record<string, MobileAppStage>>;
+}
+export declare class MobileApp<TName extends string = string> implements Declarable<TName> {
+  private readonly config;
+  /** Internal: how `.dependsOn()` carries edges into the copy it returns. */
+  private readonly dependencies;
+  readonly id: TName;
+  /** The key its scheme arrives under — what its `app.config.ts` reads. */
+  readonly keys: {
+    scheme: string;
+  };
+  constructor(id: ConstructName<TName>, config: MobileAppConfig,
+  /** Internal: how `.dependsOn()` carries edges into the copy it returns. */
+  dependencies?: readonly Dependency[]);
+  /**
+   * What this app calls — the surfaces it is built with the URLs of, and the
+   * ones that come to trust its scheme.
+   *
+   * Immutable, like every other builder: it returns a new app rather than
+   * changing this one.
+   */
+  dependsOn(constructs: readonly Declarable[]): MobileApp<TName>;
+  declare(): Declaration[];
+}
+//#endregion
+//# sourceMappingURL=mobile-app.d.mts.map

package/dist/mobile-app.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mobile-app.d.mts","names":[],"sources":["../src/mobile-app.ts"],"mappings":";;;iBAuCiB;;;;;EAKhB;;;;;;;EAOA;;;;;EAKA;IAAW;IAAiB;;;;;;EAK5B,UAAU;;;;;;;EAOV;;;;;;;;;;;;EAYA,SAAS,SAAS,eAAe;;qBAGrB,UAAU,0CACX,WAAW;mBAQJ;;mBAEA;WART,IAAI;;WAEJ;IAAQ;;EAEjB,YACC,IAAI,cAAc,QACD,QAAQ,iBAER;;EAAA,wBAAuB;;;;;;;;EAazC,UAAU,qBAAqB,eAAe,UAAU;EAOxD,WAAW"}

package/dist/mobile-app.mjs

@@ -0,0 +1,73 @@
+import { edgeTo } from "./construct-interface.mjs";
+import { canonicalId, provideKey } from "@geekmidas/manifest";
+//#region src/mobile-app.ts
+/**
+* `MobileApp` — an Expo app, declared like a site.
+*
+* Its edges are the point, as a site's are. One `.dependsOn([api, auth])` is
+* the fact behind everything a mobile app otherwise has written down by hand:
+*
+* - its `EXPO_PUBLIC_API_URL` and `EXPO_PUBLIC_AUTH_URL`, which locally are
+*   the servers' own ports — reachable once the app swaps `localhost` for the
+*   address Metro is served from, which is what makes a phone on the LAN work;
+* - with an `Email` among them, Mailpit's inbox on a local stage
+*   (`EXPO_PUBLIC_<ID>_INBOX_URL`), so a sign-in link can be opened from the
+*   app — unset deployed, where there is no inbox;
+* - its URL scheme (`shop`), the same on every stage;
+* - the scheme in the auth server's and the API's trusted origins — and, on a
+*   local stage, the `exp://` origins Expo Go sends from;
+* - Better Auth's Expo plugin on the auth server, and sign-in links an app asks
+*   for built on an address the phone can open.
+*
+* ```ts
+* export const app = new MobileApp('App', { path: 'apps/app' })
+*   .dependsOn([api, auth]);
+* ```
+*
+* Like a site it has no `.service`: it is built by its own toolchain, and
+* consumes addresses rather than connections. Nothing deploys it — EAS and the
+* stores do — so the targets derive *for* it and never run it.
+*/
+var MobileApp = class MobileApp {
+	config;
+	dependencies;
+	id;
+	/** The key its scheme arrives under — what its `app.config.ts` reads. */
+	keys;
+	constructor(id, config, dependencies = []) {
+		this.config = config;
+		this.dependencies = dependencies;
+		this.id = canonicalId(id);
+		this.keys = { scheme: provideKey(this.id, "scheme") };
+	}
+	/**
+	* What this app calls — the surfaces it is built with the URLs of, and the
+	* ones that come to trust its scheme.
+	*
+	* Immutable, like every other builder: it returns a new app rather than
+	* changing this one.
+	*/
+	dependsOn(constructs) {
+		return new MobileApp(this.id, this.config, [...this.dependencies, ...constructs.map(edgeTo)]);
+	}
+	declare() {
+		return [{
+			kind: "mobile-app",
+			id: this.id,
+			variant: this.config.variant ?? "expo",
+			app: {
+				path: this.config.path,
+				...this.config.port ? { port: this.config.port } : {},
+				...this.config.config ? { config: this.config.config } : {}
+			},
+			...this.config.scheme ? { scheme: this.config.scheme } : {},
+			...this.config.stages ? { stages: this.config.stages } : {},
+			dependencies: this.dependencies,
+			provides: [this.keys.scheme]
+		}];
+	}
+};
+//#endregion
+export { MobileApp };
+
+//# sourceMappingURL=mobile-app.mjs.map

package/dist/mobile-app.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"mobile-app.mjs","names":[],"sources":["../src/mobile-app.ts"],"sourcesContent":["/**\n * `MobileApp` — an Expo app, declared like a site.\n *\n * Its edges are the point, as a site's are. One `.dependsOn([api, auth])` is\n * the fact behind everything a mobile app otherwise has written down by hand:\n *\n * - its `EXPO_PUBLIC_API_URL` and `EXPO_PUBLIC_AUTH_URL`, which locally are\n *   the servers' own ports — reachable once the app swaps `localhost` for the\n *   address Metro is served from, which is what makes a phone on the LAN work;\n * - with an `Email` among them, Mailpit's inbox on a local stage\n *   (`EXPO_PUBLIC_<ID>_INBOX_URL`), so a sign-in link can be opened from the\n *   app — unset deployed, where there is no inbox;\n * - its URL scheme (`shop`), the same on every stage;\n * - the scheme in the auth server's and the API's trusted origins — and, on a\n *   local stage, the `exp://` origins Expo Go sends from;\n * - Better Auth's Expo plugin on the auth server, and sign-in links an app asks\n *   for built on an address the phone can open.\n *\n * ```ts\n * export const app = new MobileApp('App', { path: 'apps/app' })\n *   .dependsOn([api, auth]);\n * ```\n *\n * Like a site it has no `.service`: it is built by its own toolchain, and\n * consumes addresses rather than connections. Nothing deploys it — EAS and the\n * stores do — so the targets derive *for* it and never run it.\n */\n\nimport {\n\ttype ConstructName,\n\tcanonicalId,\n\ttype Declaration,\n\ttype Dependency,\n\ttype MobileAppDeclaration,\n\ttype MobileAppStage,\n\tprovideKey,\n} from '@geekmidas/manifest';\nimport { type Declarable, edgeTo } from './construct-interface';\n\nexport interface MobileAppConfig {\n\t/**\n\t * Where its source lives, relative to the workspace root — `'apps/app'`.\n\t * Required, the same field a site and a surface take.\n\t */\n\tpath: string;\n\t/**\n\t * The port Metro serves it on locally.\n\t *\n\t * Normally omitted: ports are assigned in a stable order, as a site's are,\n\t * and `gkm exec` hands it to Expo as `RCT_METRO_PORT`.\n\t */\n\tport?: number;\n\t/**\n\t * Modules to import when sniffing which env vars the app reads — its\n\t * values are inlined at build time, as a site's are.\n\t */\n\tconfig?: { client?: string; server?: string };\n\t/**\n\t * Which toolchain builds it — the same field a site names its framework\n\t * by. Expo is the one that ships, and the default.\n\t */\n\tvariant?: MobileAppDeclaration['variant'];\n\t/**\n\t * Its URL scheme.\n\t *\n\t * Normally omitted: it is the project's name — `shop` — on every stage.\n\t * Give one only when the app is known by another name.\n\t */\n\tscheme?: string;\n\t/**\n\t * How a deployed stage ships it, where that differs from the defaults: the\n\t * protected stage reads EAS's `production` environment and submits to\n\t * Play's `production` track, every other deployed stage `preview` and\n\t * `internal`, and every Android release is a `draft` until someone\n\t * releases it in Play Console.\n\t *\n\t * ```ts\n\t * stages: { beta: { environment: 'preview', android: { track: 'alpha' } } }\n\t * ```\n\t */\n\tstages?: Readonly<Record<string, MobileAppStage>>;\n}\n\nexport class MobileApp<TName extends string = string>\n\timplements Declarable<TName>\n{\n\treadonly id: TName;\n\t/** The key its scheme arrives under — what its `app.config.ts` reads. */\n\treadonly keys: { scheme: string };\n\n\tconstructor(\n\t\tid: ConstructName<TName>,\n\t\tprivate readonly config: MobileAppConfig,\n\t\t/** Internal: how `.dependsOn()` carries edges into the copy it returns. */\n\t\tprivate readonly dependencies: readonly Dependency[] = [],\n\t) {\n\t\tthis.id = canonicalId(id as string) as TName;\n\t\tthis.keys = { scheme: provideKey(this.id, 'scheme') };\n\t}\n\n\t/**\n\t * What this app calls — the surfaces it is built with the URLs of, and the\n\t * ones that come to trust its scheme.\n\t *\n\t * Immutable, like every other builder: it returns a new app rather than\n\t * changing this one.\n\t */\n\tdependsOn(constructs: readonly Declarable[]): MobileApp<TName> {\n\t\treturn new MobileApp<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: 'mobile-app',\n\t\t\t\tid: this.id,\n\t\t\t\tvariant: this.config.variant ?? 'expo',\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.scheme ? { scheme: this.config.scheme } : {}),\n\t\t\t\t...(this.config.stages ? { stages: this.config.stages } : {}),\n\t\t\t\tdependencies: this.dependencies,\n\t\t\t\tprovides: [this.keys.scheme],\n\t\t\t},\n\t\t];\n\t}\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmFA,IAAa,YAAb,MAAa,UAEb;CAOmB;CAEA;CARlB;;CAEA;CAEA,YACC,IACA,QAEA,eAAuD,CAAC,GACvD;EAHgB,KAAA,SAAA;EAEA,KAAA,eAAA;EAEjB,KAAK,KAAK,YAAY,EAAY;EAClC,KAAK,OAAO,EAAE,QAAQ,WAAW,KAAK,IAAI,QAAQ,EAAE;CACrD;;;;;;;;CASA,UAAU,YAAqD;EAC9D,OAAO,IAAI,UAAiB,KAAK,IAA4B,KAAK,QAAQ,CACzE,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,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,SAAS,EAAE,QAAQ,KAAK,OAAO,OAAO,IAAI,CAAC;GAC3D,GAAI,KAAK,OAAO,SAAS,EAAE,QAAQ,KAAK,OAAO,OAAO,IAAI,CAAC;GAC3D,cAAc,KAAK;GACnB,UAAU,CAAC,KAAK,KAAK,MAAM;EAC5B,CACD;CACD;AACD"}

package/dist/object-storage.cjs

@@ -1,9 +1,17 @@
-const require_chunk = require('./chunk-DWy1uDak.cjs');
-const __geekmidas_manifest = require_chunk.__toESM(require("@geekmidas/manifest"));
-const __geekmidas_storage = require_chunk.__toESM(require("@geekmidas/storage"));
-
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _geekmidas_manifest = require("@geekmidas/manifest");
+let _geekmidas_storage = require("@geekmidas/storage");
 //#region src/object-storage.ts
+/**
+* `ObjectStorage` — a declared bucket.
+*
+* Where the three packages meet: it implements the construct contract, derives
+* its env key through `@geekmidas/manifest`, and hands back a
+* `@geekmidas/storage` client. It names no cloud — `--target=aws` fills the
+* injected URL with S3's values, local dev with MinIO's.
+*/
 var ObjectStorage = class {
+	options;
 	id;
 	service;
 	/**
@@ -14,12 +22,12 @@ var ObjectStorage = class {
 	keys;
 	constructor(id, options = {}) {
 		this.options = options;
-		const canonical = (0, __geekmidas_manifest.canonicalId)(id);
+		const canonical = (0, _geekmidas_manifest.canonicalId)(id);
 		this.id = canonical;
-		this.keys = { url: (0, __geekmidas_manifest.provideKey)(canonical, "url") };
+		this.keys = { url: (0, _geekmidas_manifest.provideKey)(canonical, "url") };
 		this.service = {
-			serviceName: (0, __geekmidas_manifest.serviceKey)(canonical),
-			register: (options$1) => this.connect(options$1)
+			serviceName: (0, _geekmidas_manifest.serviceKey)(canonical),
+			register: (options) => this.connect(options)
 		};
 	}
 	declare() {
@@ -39,10 +47,10 @@ var ObjectStorage = class {
 	*/
 	async connect({ envParser }) {
 		const { url } = envParser.create((get) => ({ url: get(this.keys.url).string() })).parse();
-		return (0, __geekmidas_storage.createStorageClient)(url);
+		return (0, _geekmidas_storage.createStorageClient)(url);
 	}
 };
-
 //#endregion
 exports.ObjectStorage = ObjectStorage;
+
 //# sourceMappingURL=object-storage.cjs.map

package/dist/object-storage.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"object-storage.cjs","names":["id: ConstructName<TName>","options: ObjectStorageOptions","options"],"sources":["../src/object-storage.ts"],"sourcesContent":["/**\n * `ObjectStorage` — a declared bucket.\n *\n * Where the three packages meet: it implements the construct contract, derives\n * its env key through `@geekmidas/manifest`, and hands back a\n * `@geekmidas/storage` client. It names no cloud — `--target=aws` fills the\n * injected URL with S3's values, local dev with MinIO's.\n */\n\nimport {\n\ttype ConstructName,\n\tcanonicalId,\n\ttype Declaration,\n\tprovideKey,\n\tserviceKey,\n} from '@geekmidas/manifest';\nimport type { Service, ServiceRegisterOptions } from '@geekmidas/services';\nimport { createStorageClient, type StorageClient } from '@geekmidas/storage';\nimport type { Construct } from './construct-interface';\n\nexport interface ObjectStorageOptions {\n\t/** Keep previous versions of an object. */\n\tversioned?: boolean;\n}\n\nexport class ObjectStorage<TName extends string = string>\n\timplements Construct<TName, StorageClient>\n{\n\treadonly id: TName;\n\treadonly service: Service<Uncapitalize<TName>, StorageClient>;\n\n\t/**\n\t * Declared once and read by both `declare()` and `connect()`, so the key the\n\t * build publishes and the key the client reads cannot drift — the whole point\n\t * of the construct owning both faces.\n\t */\n\tprivate readonly keys: { url: string };\n\n\tconstructor(\n\t\tid: ConstructName<TName>,\n\t\tprivate readonly options: ObjectStorageOptions = {},\n\t) {\n\t\t// Canonicalises, so `uploads` and `Uploads` are one construct rather than\n\t\t// two that collide. Throws on anything that cannot become a valid id.\n\t\tconst canonical = canonicalId(id as string);\n\n\t\tthis.id = canonical as TName;\n\t\tthis.keys = { url: provideKey(canonical, 'url') };\n\n\t\t// A field, not a getter: consumers cache services by object identity.\n\t\tthis.service = {\n\t\t\tserviceName: serviceKey(canonical) as Uncapitalize<TName>,\n\t\t\tregister: (options) => this.connect(options),\n\t\t};\n\t}\n\n\tdeclare(): Declaration[] {\n\t\treturn [\n\t\t\t{\n\t\t\t\tkind: 'objects',\n\t\t\t\tid: this.id,\n\t\t\t\tprovides: [this.keys.url],\n\t\t\t\t...(this.options.versioned ? { versioned: true } : {}),\n\t\t\t},\n\t\t];\n\t}\n\n\t/**\n\t * Builds the client from the single URL the adapter supplied.\n\t *\n\t * The URL's scheme selects the driver, so this construct imports no provider\n\t * and an app that never touches S3 never resolves the AWS SDK. Whoever\n\t * assembles the application registers the drivers its target needs.\n\t */\n\tprivate async connect({\n\t\tenvParser,\n\t}: ServiceRegisterOptions): Promise<StorageClient> {\n\t\tconst { url } = envParser\n\t\t\t.create((get) => ({ url: get(this.keys.url).string() }))\n\t\t\t.parse();\n\n\t\treturn createStorageClient(url);\n\t}\n}\n"],"mappings":";;;;;AAyBA,IAAa,gBAAb,MAEA;CACC,AAAS;CACT,AAAS;;;;;;CAOT,AAAiB;CAEjB,YACCA,IACiBC,UAAgC,CAAE,GAClD;EADgB;EAIjB,MAAM,YAAY,sCAAY,GAAa;AAE3C,OAAK,KAAK;AACV,OAAK,OAAO,EAAE,KAAK,qCAAW,WAAW,MAAM,CAAE;AAGjD,OAAK,UAAU;GACd,aAAa,qCAAW,UAAU;GAClC,UAAU,CAACC,cAAY,KAAK,QAAQA,UAAQ;EAC5C;CACD;CAED,UAAyB;AACxB,SAAO,CACN;GACC,MAAM;GACN,IAAI,KAAK;GACT,UAAU,CAAC,KAAK,KAAK,GAAI;GACzB,GAAI,KAAK,QAAQ,YAAY,EAAE,WAAW,KAAM,IAAG,CAAE;EACrD,CACD;CACD;;;;;;;;CASD,MAAc,QAAQ,EACrB,WACwB,EAA0B;EAClD,MAAM,EAAE,KAAK,GAAG,UACd,OAAO,CAAC,SAAS,EAAE,KAAK,IAAI,KAAK,KAAK,IAAI,CAAC,QAAQ,CAAE,GAAE,CACvD,OAAO;AAET,SAAO,6CAAoB,IAAI;CAC/B;AACD"}
+{"version":3,"file":"object-storage.cjs","names":["canonicalId","provideKey","serviceKey","createStorageClient"],"sources":["../src/object-storage.ts"],"sourcesContent":["/**\n * `ObjectStorage` — a declared bucket.\n *\n * Where the three packages meet: it implements the construct contract, derives\n * its env key through `@geekmidas/manifest`, and hands back a\n * `@geekmidas/storage` client. It names no cloud — `--target=aws` fills the\n * injected URL with S3's values, local dev with MinIO's.\n */\n\nimport {\n\ttype ConstructName,\n\tcanonicalId,\n\ttype Declaration,\n\tprovideKey,\n\tserviceKey,\n} from '@geekmidas/manifest';\nimport type { Service, ServiceRegisterOptions } from '@geekmidas/services';\nimport { createStorageClient, type StorageClient } from '@geekmidas/storage';\nimport type { Construct } from './construct-interface';\n\nexport interface ObjectStorageOptions {\n\t/** Keep previous versions of an object. */\n\tversioned?: boolean;\n}\n\nexport class ObjectStorage<TName extends string = string>\n\timplements Construct<TName, StorageClient>\n{\n\treadonly id: TName;\n\treadonly service: Service<Uncapitalize<TName>, StorageClient>;\n\n\t/**\n\t * Declared once and read by both `declare()` and `connect()`, so the key the\n\t * build publishes and the key the client reads cannot drift — the whole point\n\t * of the construct owning both faces.\n\t */\n\tprivate readonly keys: { url: string };\n\n\tconstructor(\n\t\tid: ConstructName<TName>,\n\t\tprivate readonly options: ObjectStorageOptions = {},\n\t) {\n\t\t// Canonicalises, so `uploads` and `Uploads` are one construct rather than\n\t\t// two that collide. Throws on anything that cannot become a valid id.\n\t\tconst canonical = canonicalId(id as string);\n\n\t\tthis.id = canonical as TName;\n\t\tthis.keys = { url: provideKey(canonical, 'url') };\n\n\t\t// A field, not a getter: consumers cache services by object identity.\n\t\tthis.service = {\n\t\t\tserviceName: serviceKey(canonical) as Uncapitalize<TName>,\n\t\t\tregister: (options) => this.connect(options),\n\t\t};\n\t}\n\n\tdeclare(): Declaration[] {\n\t\treturn [\n\t\t\t{\n\t\t\t\tkind: 'objects',\n\t\t\t\tid: this.id,\n\t\t\t\tprovides: [this.keys.url],\n\t\t\t\t...(this.options.versioned ? { versioned: true } : {}),\n\t\t\t},\n\t\t];\n\t}\n\n\t/**\n\t * Builds the client from the single URL the adapter supplied.\n\t *\n\t * The URL's scheme selects the driver, so this construct imports no provider\n\t * and an app that never touches S3 never resolves the AWS SDK. Whoever\n\t * assembles the application registers the drivers its target needs.\n\t */\n\tprivate async connect({\n\t\tenvParser,\n\t}: ServiceRegisterOptions): Promise<StorageClient> {\n\t\tconst { url } = envParser\n\t\t\t.create((get) => ({ url: get(this.keys.url).string() }))\n\t\t\t.parse();\n\n\t\treturn createStorageClient(url);\n\t}\n}\n"],"mappings":";;;;;;;;;;;;AAyBA,IAAa,gBAAb,MAEA;CAamB;CAZlB;CACA;;;;;;CAOA;CAEA,YACC,IACA,UAAiD,CAAC,GACjD;EADgB,KAAA,UAAA;EAIjB,MAAM,aAAA,GAAYA,oBAAAA,YAAAA,CAAY,EAAY;EAE1C,KAAK,KAAK;EACV,KAAK,OAAO,EAAE,MAAA,GAAKC,oBAAAA,WAAAA,CAAW,WAAW,KAAK,EAAE;EAGhD,KAAK,UAAU;GACd,cAAA,GAAaC,oBAAAA,WAAAA,CAAW,SAAS;GACjC,WAAW,YAAY,KAAK,QAAQ,OAAO;EAC5C;CACD;CAEA,UAAyB;EACxB,OAAO,CACN;GACC,MAAM;GACN,IAAI,KAAK;GACT,UAAU,CAAC,KAAK,KAAK,GAAG;GACxB,GAAI,KAAK,QAAQ,YAAY,EAAE,WAAW,KAAK,IAAI,CAAC;EACrD,CACD;CACD;;;;;;;;CASA,MAAc,QAAQ,EACrB,aACkD;EAClD,MAAM,EAAE,QAAQ,UACd,QAAQ,SAAS,EAAE,KAAK,IAAI,KAAK,KAAK,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,CACvD,MAAM;EAER,QAAA,GAAOC,mBAAAA,oBAAAA,CAAoB,GAAG;CAC/B;AACD"}