@geekmidas/cli 10.0.0-alpha.72 → 10.0.0-alpha.74

package/dist/ready-B-7LayMF.cjs

@@ -1,872 +0,0 @@
-const require_discover = require("./discover-B4VjaFJk.cjs");
-const require_OpenApiTsGenerator = require("./OpenApiTsGenerator-BlP53kf2.cjs");
-const require_fakes = require("./fakes-zW-jNAbQ.cjs");
-let node_path = require("node:path");
-let node_fs = require("node:fs");
-let node_fs_promises = require("node:fs/promises");
-let _geekmidas_manifest = require("@geekmidas/manifest");
-let node_url = require("node:url");
-let _geekmidas_constructs_subscribers = require("@geekmidas/constructs/subscribers");
-let _geekmidas_envkit = require("@geekmidas/envkit");
-let _geekmidas_services = require("@geekmidas/services");
-//#region src/generators/drivers.ts
-/**
-* Driver registration for generated entry points.
-*
-* A construct declares that it needs object storage and is handed one URL; the
-* scheme in that URL picks the driver that builds the client. Which drivers
-* exist is therefore the *entry point's* decision, not the construct's and not
-* the application's — an app that never talks to S3 should never resolve the AWS
-* SDK, and application code that registers a driver has named a provider in the
-* one layer this design keeps provider-free.
-*
-* So the generated entries register: `gkm dev`'s server for local development,
-* and each Lambda handler for its own target. Registration is an explicit call
-* rather than an import side effect, because a side-effecting module is exactly
-* what a bundler is entitled to drop.
-*/
-/** The `s3://` driver, which serves MinIO locally and S3 deployed. */
-const S3 = {
-	imports: `import { registerStorageDriver } from '@geekmidas/storage';\nimport { s3Driver } from '@geekmidas/storage/aws';`,
-	setup: "registerStorageDriver(s3Driver);"
-};
-const NONE = {
-	imports: "",
-	setup: ""
-};
-/**
-* The cache driver for a backend — exactly one, never all three.
-*
-* Keyed off the *backend* rather than off a dependency, because unlike storage
-* the backend already says which driver is right: a project caching in Postgres
-* resolves `pg` and never `ioredis`, and one caching in Upstash resolves
-* neither. That is the whole reason the drivers live behind separate subpaths.
-*
-* Both HTTP schemes are registered for Upstash, because the local proxy speaks
-* `http://` and Upstash speaks `https://`, and an entry that registered one
-* would work in exactly one of the two places.
-*/
-const CACHE_DRIVERS = {
-	upstash: {
-		imports: `import { registerCacheDriver } from '@geekmidas/cache';\nimport { upstashCacheDriver, upstashInsecureCacheDriver } from '@geekmidas/cache/upstash';`,
-		setup: "registerCacheDriver(upstashCacheDriver);\nregisterCacheDriver(upstashInsecureCacheDriver);"
-	},
-	elasticache: {
-		imports: `import { registerCacheDriver } from '@geekmidas/cache';\nimport { redisCacheDriver, redissCacheDriver } from '@geekmidas/cache/redis';`,
-		setup: "registerCacheDriver(redisCacheDriver);\nregisterCacheDriver(redissCacheDriver);"
-	},
-	db: {
-		imports: `import { registerCacheDriver } from '@geekmidas/cache';\nimport { postgresCacheDriver } from '@geekmidas/cache/postgres';`,
-		setup: "registerCacheDriver(postgresCacheDriver);"
-	}
-};
-/**
-* The events drivers for a broker — only its own, so a bundle never resolves
-* another broker's client library.
-*
-* Keyed off the backend, as the cache is: the target already says which broker
-* carries the app's topics and queues. SNS registers SQS beside it, because on
-* AWS a topic is `sns://` and a queue is `sqs://`, and an entry registering one
-* would publish to topics and fail on the first queue.
-*/
-const EVENTS_DRIVERS = {
-	pgboss: {
-		imports: `import { registerEventsDriver } from '@geekmidas/events';\nimport { pgbossEventsDriver } from '@geekmidas/events/pgboss';`,
-		setup: "registerEventsDriver(pgbossEventsDriver);"
-	},
-	sns: {
-		imports: `import { registerEventsDriver } from '@geekmidas/events';\nimport { snsEventsDriver } from '@geekmidas/events/sns';\nimport { sqsEventsDriver } from '@geekmidas/events/sqs';`,
-		setup: "registerEventsDriver(snsEventsDriver);\nregisterEventsDriver(sqsEventsDriver);"
-	},
-	rabbitmq: {
-		imports: `import { registerEventsDriver } from '@geekmidas/events';\nimport { rabbitmqEventsDriver } from '@geekmidas/events/rabbitmq';`,
-		setup: "registerEventsDriver(rabbitmqEventsDriver);"
-	}
-};
-/**
-* Everything a generated entry should register: object storage, the cache,
-* and the events broker.
-*
-* Merged here rather than threaded separately, because a generated file has one
-* import block and one setup block whatever fills them.
-*/
-function driversFor(options) {
-	const backends = listOf(options.cache);
-	const brokers = listOf(options.events);
-	const parts = [
-		storageDriversFor(options.appRoot),
-		...[...new Set(backends)].map((backend) => CACHE_DRIVERS[backend] ?? CACHE_DRIVERS[require_fakes.DEFAULT_CACHE.aws]),
-		...[...new Set(brokers)].map((broker) => EVENTS_DRIVERS[broker])
-	].filter((part) => part.imports || part.setup);
-	if (parts.length === 0) return NONE;
-	return {
-		imports: parts.map((part) => part.imports).join("\n"),
-		setup: parts.map((part) => part.setup).join("\n")
-	};
-}
-function listOf(value) {
-	if (value === false || value === void 0) return [];
-	return typeof value === "string" ? [value] : value;
-}
-/**
-* Which events brokers an app's entry has to speak: the target's, when the app
-* declares a `Topic` or a `Queue` — and none at all when it declares neither,
-* so a project without events never resolves `@geekmidas/events`.
-*
-* A worker on pg-boss counts too: a server schedules its crons through the
-* pg-boss broker, which the plan provisions for a declared worker beside a
-* declared database (`workerBroker` in `reconcile/plan.ts`) whether or not
-* anything publishes.
-*/
-function eventsBackendsIn(manifest, configured) {
-	const kinds = new Set(Object.values(manifest).map((d) => d.kind));
-	return kinds.has("topic") || kinds.has("queue") || configured === "pgboss" && kinds.has("worker") && kinds.has("database") ? [configured] : [];
-}
-/**
-* Which cache backends an app's entry actually has to speak.
-*
-* The config answers this for a cache that named nowhere, and the *declaration*
-* answers it for one that named a database — `orders.cache('Sessions')` is a
-* statement about the application, so a deployment cannot move that cache and
-* the entry cannot register a driver for somewhere else.
-*
-* Reading only the config is how an entry ends up registering the Upstash
-* driver for a URL the target composed as `postgres://`, which fails at the
-* first request with `UnregisteredCacheScheme` and a stack that points at the
-* cache rather than at the config that disagreed.
-*/
-function cacheBackendsIn(manifest, configured) {
-	const caches = Object.values(manifest).filter((d) => d.kind === "cache");
-	return [...new Set(caches.map((c) => c.of ? "db" : configured))];
-}
-/**
-* The drivers an app's entry points should register.
-*
-* Keyed off the dependency rather than off a declared bucket, because the entry
-* is generated before discovery has run on the watcher's rebuild path — and an
-* app that installed `@geekmidas/storage` has already paid for the SDK it would
-* otherwise resolve lazily.
-*
-* "Installed" the way Node resolves it: the app's own `package.json`, or any
-* directory above it. A workspace that lists `@geekmidas/storage` once, at its
-* root, is the common case — and reading only the app's file registered no S3
-* driver there, so the first service to inject a bucket threw
-* `UnregisteredStorageScheme`. A queue whose consumer depended on one logged
-* that once and was never polled.
-*/
-function storageDriversFor(appRoot) {
-	return dependsOnStorage(appRoot) ? S3 : NONE;
-}
-function dependsOnStorage(appRoot) {
-	for (let dir = (0, node_path.resolve)(appRoot);; dir = (0, node_path.dirname)(dir)) {
-		if (listsStorage((0, node_path.join)(dir, "package.json"))) return true;
-		if ((0, node_path.dirname)(dir) === dir) return false;
-	}
-}
-function listsStorage(manifest) {
-	if (!(0, node_fs.existsSync)(manifest)) return false;
-	try {
-		const pkg = JSON.parse((0, node_fs.readFileSync)(manifest, "utf8"));
-		return Boolean(pkg.dependencies?.["@geekmidas/storage"] ?? pkg.devDependencies?.["@geekmidas/storage"]);
-	} catch {
-		return false;
-	}
-}
-//#endregion
-//#region src/generators/SubscriberGenerator.ts
-var SubscriberGenerator = class extends require_discover.ConstructGenerator {
-	isConstruct(value) {
-		return _geekmidas_constructs_subscribers.Subscriber.isSubscriber(value);
-	}
-	async build(context, constructs, outputDir, options) {
-		const target = options?.target ?? "aws";
-		const logger = console;
-		const subscriberInfos = [];
-		if (target === "server") {
-			await this.generateServerSubscribersFile(outputDir, constructs, context.eventsBackends?.includes("sns") ?? false);
-			logger.log(`Generated server subscribers file with ${constructs.length} subscribers (polling mode)`);
-			return subscriberInfos;
-		}
-		if (constructs.length === 0) return subscriberInfos;
-		const subscribersDir = (0, node_path.join)(outputDir, "subscribers");
-		await (0, node_fs_promises.mkdir)(subscribersDir, { recursive: true });
-		for (const { key, construct, path } of constructs) {
-			const handlerFile = await this.generateSubscriberHandler(subscribersDir, path.relative, key, construct, context, construct.owner);
-			subscriberInfos.push({
-				name: key,
-				handler: (0, node_path.relative)(options?.root ?? process.cwd(), handlerFile).replace(/\.ts$/, ".handler"),
-				subscribedEvents: construct.subscribedEvents || [],
-				...construct.topicName ? {
-					transport: "topic",
-					topic: construct.topicName
-				} : {},
-				timeout: construct.timeout,
-				memorySize: construct.memorySize,
-				environment: await construct.getEnvironment({ markOptional: context.markOptional }),
-				dependencies: construct.constructs
-			});
-			logger.log(`Generated subscriber handler: ${key}`);
-		}
-		return subscriberInfos;
-	}
-	async generateSubscriberHandler(outputDir, sourceFile, exportName, _subscriber, context, owner) {
-		const handlerFileName = `${exportName}.ts`;
-		const handlerPath = (0, node_path.join)(outputDir, handlerFileName);
-		const importPath = (0, node_path.relative)((0, node_path.dirname)(handlerPath), sourceFile).replace(/\.ts$/, ".js");
-		const runtime = require_OpenApiTsGenerator.runtimeFor(context, (0, node_path.dirname)(handlerPath), owner);
-		const content = `import { AWSLambdaSubscriber } from '@geekmidas/constructs/aws';
-import { ${exportName} } from '${importPath}';
-${runtime.imports}
-${context.storageDrivers?.imports ?? ""}
-${runtime.bindings}
-${context.storageDrivers?.setup ? `\n// The handler registers the drivers its target needs.\n${context.storageDrivers.setup}\n` : ""}
-const adapter = new AWSLambdaSubscriber(envParser, ${exportName});
-
-export const handler = adapter.handler;
-`;
-		await (0, node_fs_promises.writeFile)(handlerPath, content);
-		return handlerPath;
-	}
-	async generateServerSubscribersFile(outputDir, subscribers, push) {
-		await (0, node_fs_promises.mkdir)(outputDir, { recursive: true });
-		const subscribersPath = (0, node_path.join)(outputDir, "subscribers.ts");
-		if (subscribers.length === 0) {
-			await (0, node_fs_promises.writeFile)(subscribersPath, `/**
- * Generated subscribers setup — this app declares none.
- */
-import type { EnvironmentParser } from '@geekmidas/envkit';
-import type { Logger } from '@geekmidas/logger';
-
-export async function setupSubscribers(
-  _app: unknown,
-  _envParser: EnvironmentParser<any>,
-  _logger: Logger,
-): Promise<(port: number) => Promise<void>> {
-  return async () => {};
-}
-`);
-			return subscribersPath;
-		}
-		const importsByFile = /* @__PURE__ */ new Map();
-		for (const { path, key } of subscribers) {
-			const importPath = (0, node_path.relative)((0, node_path.dirname)(subscribersPath), path.relative).replace(/\.ts$/, ".js");
-			importsByFile.set(importPath, [...importsByFile.get(importPath) ?? [], key]);
-		}
-		const content = `/**
- * Generated subscribers setup.
- *
- * Each subscriber is run against the topic it is bound to, through that
- * topic's own connection string:
- *
- * - **sns://** — pushed, not polled. The subscriber gets an HTTP route on this
- *   server, and the route is subscribed to the topic with a filter policy of
- *   the events it named, so SNS fans out to each subscriber. The route runs the
- *   subscriber through the same adaptor a Lambda subscription does.
- * - **anything else** (pgboss://, rabbitmq://, sqs://) — polled. On pg-boss
- *   each subscriber drains a queue of its own, \`<topic>/<subscriber>\`, so
- *   every subscriber sees every event; replicas of one subscriber share it.
- *
- * GKM_SUBSCRIBERS=off (\`gkm dev --no-subscribers\`) runs none of them.
- * GKM_SUBSCRIBER_PUSH_URL is the address SNS pushes to; against the local
- * emulator it defaults to this server through host.docker.internal.
- */
-import { connect } from 'node:net';
-import type { EnvironmentParser } from '@geekmidas/envkit';
-import type { Logger } from '@geekmidas/logger';
-import { EventConnectionFactory, Subscriber } from '@geekmidas/events';
-import type { EventConnection } from '@geekmidas/events';
-import { ServiceDiscovery } from '@geekmidas/services';
-${Array.from(importsByFile.entries()).map(([importPath, exports]) => `import { ${exports.join(", ")} } from '${importPath}';`).join("\n")}
-
-const subscribers = [
-${subscribers.map(({ key, construct }) => {
-			const connectionKey = construct.topicName ? (0, _geekmidas_manifest.provideKey)((0, _geekmidas_manifest.canonicalId)(construct.topicName), "publisherConnectionString") : void 0;
-			return `  { id: '${key}', subscriber: ${key}, topic: ${construct.topicName ? `'${construct.topicName}'` : "undefined"}, connectionKey: ${connectionKey ? `'${connectionKey}'` : "undefined"} },`;
-		}).join("\n")}
-];
-
-/** The route a subscriber's pushes arrive on. */
-export const SUBSCRIBER_ROUTE = (id: string) => \`/__gkm/subscribers/\${id}\`;
-
-/** Resolves once something is accepting connections on the port. */
-async function listening(port: number): Promise<void> {
-  for (let attempt = 0; attempt < 100; attempt++) {
-    const open = await new Promise<boolean>((resolve) => {
-      const socket = connect(port, '127.0.0.1');
-      socket.once('connect', () => { socket.end(); resolve(true); });
-      socket.once('error', () => resolve(false));
-    });
-    if (open) return;
-    await new Promise((resolve) => setTimeout(resolve, 50));
-  }
-}
-
-/**
- * Mount each pushed subscriber's route and start each polled one. Returns what
- * to run once the server is listening: subscribing a route makes SNS send its
- * confirmation at once, so the route has to be reachable first.
- */
-export async function setupSubscribers(
-  app: { post: (path: string, handler: (c: any) => unknown) => unknown },
-  envParser: EnvironmentParser<any>,
-  logger: Logger,
-): Promise<(port: number) => Promise<void>> {
-  if (process.env.GKM_SUBSCRIBERS === 'off') {
-    logger.info('Subscribers are off (--no-subscribers)');
-    return async () => {};
-  }
-
-  const serviceDiscovery = ServiceDiscovery.getInstance(envParser);
-  const connections = new Map<string, EventConnection>();
-  const afterListening: ((port: number) => Promise<void>)[] = [];
-
-  for (const { id, subscriber, topic, connectionKey } of subscribers) {
-    const events = subscriber.subscribedEvents || [];
-    if (events.length === 0) {
-      logger.warn({ subscriber: id }, 'Subscriber has no subscribed events, skipping');
-      continue;
-    }
-    const connectionString = connectionKey ? process.env[connectionKey] : undefined;
-    if (!connectionString) {
-      logger.error(
-        { subscriber: id, connectionKey },
-        'No connection string for the topic this subscriber is bound to',
-      );
-      continue;
-    }
-
-    try {
-${push ? `      if (connectionString.startsWith('sns:')) {
-        const { SNSConnection, snsUrl, subscribeHttpEndpoint } = await import('@geekmidas/events/sns');
-        const { SnsPushSubscriberAdaptor } = await import('@geekmidas/constructs/subscribers');
-        const address = snsUrl.parse(connectionString);
-        const route = SUBSCRIBER_ROUTE(id);
-        const adaptor = new SnsPushSubscriberAdaptor(envParser, subscriber, {
-          topicArn: address.topicArn,
-          // An emulator signs nothing. Decided by the address this server was
-          // configured with, never by anything a request says about itself.
-          verify: !address.endpoint,
-          ...(address.endpoint ? { emulatorEndpoint: address.endpoint } : {}),
-        });
-
-        app.post(route, async (c: any) => {
-          const body = JSON.parse(await c.req.text());
-          const response = await adaptor.handle(body);
-          return c.json(response.body, response.status);
-        });
-
-        afterListening.push(async (port) => {
-          const base =
-            process.env.GKM_SUBSCRIBER_PUSH_URL ??
-            (address.endpoint ? \`http://host.docker.internal:\${port}\` : undefined);
-          if (!base) {
-            logger.error(
-              { subscriber: id },
-              'Set GKM_SUBSCRIBER_PUSH_URL to the public URL of this worker, which SNS pushes to',
-            );
-            return;
-          }
-          const connection = await SNSConnection.fromConnectionString(connectionString);
-          await subscribeHttpEndpoint(connection, {
-            endpoint: new URL(route, base).toString(),
-            events,
-          });
-          logger.info({ subscriber: id, events }, 'Subscriber subscribed for push');
-        });
-        continue;
-      }
-` : `      if (connectionString.startsWith('sns:')) {
-        // Built for a broker other than SNS, so this entry registered no SNS
-        // driver and has no push route to offer.
-        logger.error(
-          { subscriber: id, connectionKey },
-          'This build has no SNS driver: it was built for a target whose broker is not SNS',
-        );
-        continue;
-      }
-`}
-
-      let connection = connections.get(connectionString);
-      if (!connection) {
-        connection = await EventConnectionFactory.fromConnectionString(connectionString);
-        connections.set(connectionString, connection);
-      }
-      // Named, so a broker with one address for everything (pg-boss) gives
-      // this subscriber a queue of its own: fan-out, not competition.
-      const eventSubscriber = await Subscriber.fromConnection(connection, {
-        topic,
-        subscription: id,
-      });
-      const services = subscriber.services.length > 0
-        ? await serviceDiscovery.register(subscriber.services)
-        : {};
-      // The subscriber's database — the worker's, or its own — as \`db\`. A
-      // pushed subscriber gets it from the adaptor above instead.
-      const db = subscriber.databaseService
-        ? (await serviceDiscovery.register([subscriber.databaseService]))[
-            subscriber.databaseService.serviceName
-          ]
-        : undefined;
-
-      await eventSubscriber.subscribe(events, async (event) => {
-        try {
-          await subscriber.handler({
-            events: [event],
-            services: services as any,
-            logger: subscriber.logger,
-            db,
-          } as any);
-        } catch (error) {
-          logger.error({ err: error, event, subscriber: id }, 'Failed to process event');
-          // Rethrown so the transport keeps the event for a retry — as a queue
-          // consumer's failure does, and as a pushed subscriber's 500 does.
-          throw error;
-        }
-      });
-      logger.info({ subscriber: id, events }, 'Subscriber started polling');
-    } catch (error) {
-      // The message too: a missing module's code alone does not say which.
-      logger.error(
-        { err: error, subscriber: id },
-        'Failed to set up subscriber',
-      );
-    }
-  }
-
-  const shutdown = () => {
-    for (const connection of connections.values()) void connection.close();
-  };
-  process.once('SIGTERM', shutdown);
-  process.once('SIGINT', shutdown);
-
-  return async (port) => {
-    if (afterListening.length === 0) return;
-    await listening(port);
-    for (const subscribe of afterListening) {
-      await subscribe(port).catch((error) => {
-        logger.error({ err: error }, 'Failed to subscribe for push');
-      });
-    }
-  };
-}
-`;
-		await (0, node_fs_promises.writeFile)(subscribersPath, content);
-		return subscribersPath;
-	}
-};
-//#endregion
-//#region src/test/harness.ts
-/**
-* What `gkm test` writes for a feature test to be built from.
-*
-* `gkm test` already discovers an app's constructs and resolves the test
-* stage's environment; this keeps both, under `.gkm/test/`:
-*
-* - `manifest.json` — which construct and endpoint is exported where, and the
-*   environment the test stage resolved, keyed as the constructs derive keys.
-* - `clients/<surface>.ts` — each surface's typed client, from the same
-*   generator `gkm build` uses for the app's own.
-* - `index.ts` — the configured `it`, and a `Browser` holding one client per
-*   surface and one per auth server, each on the browser's `fetch`.
-*
-* A test imports `it` from there and declares nothing — not a construct, not an
-* environment key, not a client.
-*/
-/**
-* The variable the manifest's path travels in — what
-* `@geekmidas/constructs/testing` reads. Its own constant rather than an import:
-* that entry carries the whole harness (MSW, Hono, Vitest), and importing it
-* here put all of it on the start-up path of every `gkm` command.
-*/
-const TEST_MANIFEST_ENV = "GKM_TEST_MANIFEST";
-/** Where the harness lives, relative to the workspace root. */
-const TEST_HARNESS_DIR = ".gkm/test";
-/**
-* Better-auth's client plugin for each server plugin id.
-*
-* Written down rather than derived: the ids and the client names do not follow
-* one rule (`admin` pairs with `adminClient`, `email-otp` with
-* `emailOTPClient`), and a guess that missed would hand a test a client
-* silently lacking every method of that plugin. A server plugin not listed has
-* no client counterpart — `bearer`, `open-api` — or needs one from another
-* package, and is left out.
-*/
-const CLIENT_PLUGINS = {
-	admin: "adminClient",
-	anonymous: "anonymousClient",
-	"device-authorization": "deviceAuthorizationClient",
-	"email-otp": "emailOTPClient",
-	jwt: "jwtClient",
-	"last-login-method": "lastLoginMethodClient",
-	"magic-link": "magicLinkClient",
-	"multi-session": "multiSessionClient",
-	"oauth-popup": "oauthPopupClient",
-	"one-tap": "oneTapClient",
-	"one-time-token": "oneTimeTokenClient",
-	organization: "organizationClient",
-	"phone-number": "phoneNumberClient",
-	siwe: "siweClient",
-	"two-factor": "twoFactorClient",
-	username: "usernameClient"
-};
-/** Where a project keeps its test factories, relative to its root. */
-const DEFAULT_FACTORIES_DIR = "test/factories";
-/** A file in the factories folder that names no database construct. */
-var UnknownFactoryFile = class extends Error {
-	file;
-	known;
-	constructor(file, known) {
-		super(`${file} names no database construct, so no test could be handed it. ` + (known.length > 0 ? `The databases: ${known.join(", ")}. ` : "This project declares no database. ") + `Name a factory after its database: test/factories/<construct>.ts.`);
-		this.file = file;
-		this.known = known;
-		this.name = "UnknownFactoryFile";
-	}
-};
-/** A factory file that exports no `createFactory`. */
-var FactoryHasNoCreate = class extends Error {
-	file;
-	constructor(file) {
-		super(`${file} is a test factory but exports no \`createFactory\`. Export \`function createFactory(db: Kysely<Database>)\` returning the factory.`);
-		this.file = file;
-		this.name = "FactoryHasNoCreate";
-	}
-};
-/**
-* The factories in a folder, each matched to the database it is named after.
-*
-* A file that names no database, or exports no `createFactory`, is refused
-* rather than skipped: either is a factory no test would ever be handed.
-*/
-async function factorySources(folder, databases) {
-	if (!folder) return [];
-	const entries = await (0, node_fs_promises.readdir)(folder, { withFileTypes: true }).catch((error) => {
-		if (error.code === "ENOENT") return [];
-		throw error;
-	});
-	const found = [];
-	for (const entry of entries) {
-		if (!entry.isFile() || !isFactoryFile(entry.name)) continue;
-		const file = (0, node_path.join)(folder, entry.name);
-		const id = (0, _geekmidas_manifest.canonicalId)(entry.name.slice(0, -(0, node_path.extname)(entry.name).length));
-		if (!databases.includes(id)) throw new UnknownFactoryFile(file, databases);
-		if (typeof (await import((0, node_url.pathToFileURL)(file).href)).createFactory !== "function") throw new FactoryHasNoCreate(file);
-		found.push({
-			file,
-			service: (0, _geekmidas_manifest.serviceKey)(id)
-		});
-	}
-	return found.sort((a, b) => a.service < b.service ? -1 : 1);
-}
-function isFactoryFile(file) {
-	if (file.endsWith(".d.ts")) return false;
-	if (/\.(spec|test)\.[cm]?[jt]s$/.test(file)) return false;
-	return [
-		".ts",
-		".mts",
-		".js",
-		".mjs"
-	].includes((0, node_path.extname)(file));
-}
-/** Write the manifest, the clients and the harness; return the manifest path. */
-async function writeTestHarness(options) {
-	const sources = {};
-	const declared = await require_discover.discover({
-		patterns: options.patterns,
-		cwd: options.root,
-		sources
-	});
-	const endpoints = (await new require_OpenApiTsGenerator.EndpointGenerator().load(options.patterns, options.root)).map(({ key, construct, path }) => ({
-		surface: construct.owner ?? construct.surface?.id,
-		construct,
-		source: {
-			file: path.absolute,
-			export: key
-		}
-	})).filter((endpoint) => endpoint.surface !== void 0);
-	const subscribers = (await new SubscriberGenerator().load(options.patterns, options.root)).map(({ key, path }) => ({ source: {
-		file: path.absolute,
-		export: key
-	} }));
-	const manifest = {
-		stage: options.stage,
-		constructs: Object.fromEntries(Object.entries(declared).flatMap(([id, declaration]) => {
-			const source = sources[id];
-			return source ? [[id, {
-				kind: declaration.kind,
-				source: {
-					file: source.file,
-					export: source.exportName
-				}
-			}]] : [];
-		})),
-		endpoints: endpoints.map(({ surface, source }) => ({
-			surface,
-			source
-		})),
-		subscribers,
-		env: options.env
-	};
-	const surfaces = [...new Set(endpoints.map(({ surface }) => surface))];
-	const generator = new require_OpenApiTsGenerator.OpenApiTsGenerator();
-	const clients = await Promise.all(surfaces.map(async (surface) => ({
-		file: `${(0, _geekmidas_manifest.kebabCase)(surface)}.ts`,
-		content: await generator.generate(endpoints.filter((endpoint) => endpoint.surface === surface).map(({ construct }) => construct), {
-			title: surface,
-			version: "1.0.0"
-		})
-	})));
-	const auths = await authClients(declared, sources, options.env);
-	const drivers = driversFor({
-		appRoot: options.root,
-		cache: cacheBackendsIn(declared, options.cacheBackend),
-		events: eventsBackendsIn(declared, options.eventsBackend)
-	});
-	const owners = new Set(auths.map((auth) => auth.databaseId));
-	const databases = databaseSources(declared, sources).filter(({ id, kind }) => !owners.has(id) && kind !== "database-reader");
-	const factories = await factorySources(options.factories, databases.map(({ id }) => id));
-	const fakes = Object.entries(await require_fakes.readFakes(options.root, declared)).map(([id, { file }]) => ({
-		id,
-		file
-	}));
-	const services = serviceSources(declared, sources).filter(({ id }) => !owners.has(id));
-	const files = [.../* @__PURE__ */ new Set([
-		...Object.values(manifest.constructs).map(({ source }) => source.file),
-		...manifest.endpoints.map(({ source }) => source.file),
-		...(manifest.subscribers ?? []).map(({ source }) => source.file)
-	])];
-	const harnessFor = (dir) => harnessModule({
-		dir,
-		files,
-		databases,
-		surfaces: surfaces.map((id, index) => ({
-			id,
-			secured: clients[index].content.includes("authStrategies:")
-		})),
-		auths,
-		drivers,
-		factories,
-		fakes,
-		services,
-		mail: Object.values(declared).some(({ kind }) => kind === "email")
-	});
-	const json = `${JSON.stringify(manifest, null, 2)}\n`;
-	return (await Promise.all([...new Set(options.targets)].map(async (target) => {
-		const dir = (0, node_path.join)(target, TEST_HARNESS_DIR);
-		await (0, node_fs_promises.rm)(dir, {
-			recursive: true,
-			force: true
-		});
-		await (0, node_fs_promises.mkdir)((0, node_path.join)(dir, "clients"), { recursive: true });
-		await (0, node_fs_promises.writeFile)((0, node_path.join)(dir, "manifest.json"), json);
-		await (0, node_fs_promises.writeFile)((0, node_path.join)(dir, "index.ts"), harnessFor(dir));
-		for (const client of clients) await (0, node_fs_promises.writeFile)((0, node_path.join)(dir, "clients", client.file), client.content);
-		return (0, node_path.join)(dir, "manifest.json");
-	})))[0];
-}
-/** Each auth server, with the client plugins its server plugins pair with. */
-async function authClients(declared, sources, env) {
-	const clients = [];
-	const envParser = new _geekmidas_envkit.EnvironmentParser({ ...env });
-	for (const [id, declaration] of Object.entries(declared)) {
-		const source = sources[id];
-		if (declaration.kind !== "rest-api" || !source) continue;
-		const exported = (await import(source.file))[source.exportName];
-		if (!isBetterAuth(exported) || exported.id !== id) continue;
-		const ids = await exported.pluginIds({
-			envParser,
-			context: _geekmidas_services.serviceContext
-		});
-		clients.push({
-			id,
-			basePath: exported.basePath,
-			plugins: ids.flatMap((plugin) => CLIENT_PLUGINS[plugin] ?? []),
-			databaseId: exported.databaseId
-		});
-	}
-	return clients;
-}
-function isBetterAuth(value) {
-	return typeof value === "object" && value !== null && "pluginIds" in value && "basePath" in value;
-}
-/** `Api` → `api`, `AdminApi` → `adminApi`: a construct id as a property name. */
-function propertyOf(id) {
-	return id.charAt(0).toLowerCase() + id.slice(1);
-}
-/**
-* Every database construct the app declares — a database, a schema tenant, a
-* reader — keyed as a test is handed its transaction.
-*/
-function databaseSources(declared, sources) {
-	return Object.entries(declared).filter(([id, declaration]) => Boolean(sources[id] && declaration.kind.startsWith("database"))).map(([id, declaration]) => ({
-		id,
-		kind: declaration.kind,
-		service: (0, _geekmidas_manifest.serviceKey)(id),
-		source: sources[id]
-	}));
-}
-/** The kinds whose construct hands a handler a client — what `services` reaches. */
-const SERVICE_KINDS = /* @__PURE__ */ new Set([
-	"cache",
-	"credential",
-	"database",
-	"database-schema",
-	"database-reader",
-	"email",
-	"encryption",
-	"external-api",
-	"file-server",
-	"objects",
-	"queue",
-	"topic"
-]);
-function serviceSources(declared, sources) {
-	return Object.entries(declared).filter(([id, declaration]) => Boolean(sources[id] && SERVICE_KINDS.has(declaration.kind))).map(([id, declaration]) => ({
-		id,
-		kind: declaration.kind,
-		service: (0, _geekmidas_manifest.serviceKey)(id),
-		source: sources[id]
-	}));
-}
-/** An import specifier for `file`, from the harness written into `dir`. */
-function specifierFrom(dir, file) {
-	const path = (0, node_path.relative)(dir, file).replace(/\.tsx?$/, ".js");
-	return path.startsWith(".") ? path : `./${path}`;
-}
-function harnessModule(options) {
-	const { surfaces, auths, drivers, databases, services, dir, files, factories, fakes, mail } = options;
-	const magicLinks = mail ? auths.filter(({ plugins }) => plugins.includes("magicLinkClient")) : [];
-	const signIn = magicLinks.length === 1 ? magicLinks[0] : void 0;
-	const plugins = [...new Set(auths.flatMap(({ plugins }) => plugins))].sort();
-	const imports = [
-		`import {${services.length ? " type ClientOf," : ""}${databases.length ? " type DatabaseOf," : ""} featureTest, loadTestManifest${signIn ? ", signInWithMagicLink" : ""} } from '@geekmidas/constructs/testing';`,
-		...[...new Map([...databases, ...services].map((construct) => [construct.id, construct])).values()].map(({ id, source }) => `import type { ${source.exportName} as __${id} } from '${specifierFrom(dir, source.file)}';`),
-		`import { Browser as TestBrowser } from '@geekmidas/testkit/browser';`,
-		...surfaces.map(({ id }) => `import { createApi as create${id} } from './clients/${(0, _geekmidas_manifest.kebabCase)(id)}.js';`),
-		...auths.length ? [`import { createAuthClient } from 'better-auth/client';`] : [],
-		...plugins.length ? [`import { ${plugins.join(", ")} } from 'better-auth/client/plugins';`] : [],
-		...drivers.imports ? [drivers.imports] : [],
-		...factories.map(({ file, service }) => `import { createFactory as __${service}Factory } from '${specifierFrom(dir, file)}';`),
-		...fakes.map(({ id, file }) => `import __${id}Fake from '${specifierFrom(dir, file)}';`),
-		...files.map((file, index) => `import * as __module${index} from '${specifierFrom(dir, file)}';`)
-	];
-	const url = (id) => `manifest.env[${JSON.stringify((0, _geekmidas_manifest.provideKey)(id, "url"))}]!`;
-	const members = [
-		...surfaces.map(({ id, secured }) => `	/** \`${id}\`, at ${(0, _geekmidas_manifest.provideKey)(id, "url")}. */
-	readonly ${propertyOf(id)} = create${id}({
-		baseURL: ${url(id)},
-		fetch: this.fetch,${secured ? `
-		// Served in-process: no authorizer runs, so nothing is signed. A scheme
-		// with no strategy sends its request without credentials.
-		authStrategies: {} as never,` : ""}
-	});`),
-		...auths.map((auth) => `	/** \`${auth.id}\`, at ${(0, _geekmidas_manifest.provideKey)(auth.id, "url")}. */
-	readonly ${propertyOf(auth.id)} = createAuthClient({
-		baseURL: \`\${${url(auth.id)}}${auth.basePath}\`,
-		plugins: [${auth.plugins.map((plugin) => `${plugin}()`).join(", ")}],
-		fetchOptions: { customFetchImpl: this.fetch },
-	});`),
-		...signIn ? [`	/**
-	 * Sign in as \`email\` through \`${signIn.id}\`'s magic link, the way a person
-	 * does — the email opened, the link followed. The session it then reports.
-	 * Without an address, as somebody new: \`user.email\` says who.
-	 */
-	signIn(email?: string) {
-		return signInWithMagicLink(this, this.${propertyOf(signIn.id)}, email);
-	}`] : []
-	];
-	const factoriesType = factories.length ? `{ ${factories.map(({ service }) => `${service}: typeof __${service}Factory`).join("; ")} }` : "";
-	const factoriesOption = factories.length ? `, factories: { ${factories.map(({ service }) => `${service}: __${service}Factory`).join(", ")} }` : "";
-	const fakesOption = fakes.length ? `, fakes: { ${fakes.map(({ id }) => `${id}: __${id}Fake`).join(", ")} }` : "";
-	const databasesType = `{ ${databases.map(({ id, service }) => `${service}: DatabaseOf<typeof __${id}>`).join("; ")} }`;
-	const servicesType = services.length ? `{ ${services.map(({ id, service }) => `${service}: ClientOf<typeof __${id}>`).join("; ")} }` : "";
-	const generics = databases.length || factoriesType || servicesType ? `<Browser, ${databases.length ? databasesType : "{}"}${factoriesType || servicesType ? `, ${factoriesType || "{}"}` : ""}${servicesType ? `, ${servicesType}` : ""}>` : "";
-	return `// Generated by \`gkm test\` from the app's constructs — do not edit.
-${imports.join("\n")}
-
-${drivers.setup ? `// The drivers the app's server entry registers, registered the same way.\n${drivers.setup}\n\n` : ""}const manifest = loadTestManifest(new URL('./manifest.json', import.meta.url));
-
-/** A browser with a client for every surface the app declares. */
-export class Browser extends TestBrowser {
-${members.join("\n\n")}
-}
-
-/** The app's modules, by the path the manifest records for each. */
-const modules = {
-${files.map((file, index) => `\t${JSON.stringify(file)}: __module${index},`).join("\n")}
-};
-
-/** \`it\`, for a test that drives the app the way it runs deployed. */
-export const it = featureTest${generics}({ manifest, modules, browser: Browser${factoriesOption}${fakesOption} });
-`;
-}
-//#endregion
-//#region src/test/ready.ts
-/**
-* The hand-off between `gkm test` and the Vitest global setup.
-*
-* `gkm test` reconciles and migrates the test stage before Vitest starts; the
-* setup, run inside Vitest, only has to load what that left. Started by plain
-* `vitest` instead, the setup runs `gkm test --setup` itself first — so there is
-* one way the stage gets ready, whichever started the suite.
-*/
-/** Set on the Vitest process by `gkm test`: the stage is ready, here. */
-const TEST_READY_ENV = "GKM_TEST_READY";
-/** Where `gkm test` records what it prepared, from where it ran. */
-const TEST_READY_FILE = ".gkm/test-ready.json";
-//#endregion
-Object.defineProperty(exports, "DEFAULT_FACTORIES_DIR", {
-	enumerable: true,
-	get: function() {
-		return DEFAULT_FACTORIES_DIR;
-	}
-});
-Object.defineProperty(exports, "SubscriberGenerator", {
-	enumerable: true,
-	get: function() {
-		return SubscriberGenerator;
-	}
-});
-Object.defineProperty(exports, "TEST_MANIFEST_ENV", {
-	enumerable: true,
-	get: function() {
-		return TEST_MANIFEST_ENV;
-	}
-});
-Object.defineProperty(exports, "TEST_READY_ENV", {
-	enumerable: true,
-	get: function() {
-		return TEST_READY_ENV;
-	}
-});
-Object.defineProperty(exports, "TEST_READY_FILE", {
-	enumerable: true,
-	get: function() {
-		return TEST_READY_FILE;
-	}
-});
-Object.defineProperty(exports, "cacheBackendsIn", {
-	enumerable: true,
-	get: function() {
-		return cacheBackendsIn;
-	}
-});
-Object.defineProperty(exports, "driversFor", {
-	enumerable: true,
-	get: function() {
-		return driversFor;
-	}
-});
-Object.defineProperty(exports, "eventsBackendsIn", {
-	enumerable: true,
-	get: function() {
-		return eventsBackendsIn;
-	}
-});
-Object.defineProperty(exports, "writeTestHarness", {
-	enumerable: true,
-	get: function() {
-		return writeTestHarness;
-	}
-});
-
-//# sourceMappingURL=ready-B-7LayMF.cjs.map