@geekmidas/constructs 10.0.0-alpha.37 → 10.0.0-alpha.39

package/dist/Construct-BQALFCh2.d.cts

@@ -0,0 +1,230 @@
+import { t as StandardSchemaV1 } from "./index-CeEtxDmK.cjs";
+import { Logger } from "@geekmidas/logger";
+import { InferStandardSchema } from "@geekmidas/schema";
+import { Service, ServiceContext, ServiceDiscovery } from "@geekmidas/services";
+import { AuditStorage } from "@geekmidas/audit";
+import { SniffResult } from "@geekmidas/envkit/sniffer";
+import { EventPublisher, PublishableMessage } from "@geekmidas/events";
+import { ConstructName, Declaration } from "@geekmidas/manifest";
+//#region src/topic/Topic.d.ts
+/** A topic's event contract — a map of event type → payload schema. */
+type TopicEvents = Record<string, StandardSchemaV1>;
+/**
+ * The union of wire messages a topic carries, derived from its event map:
+ * `{ type: 'user.created'; payload: … } | { type: 'user.updated'; payload: … }`.
+ */
+type TopicMessage<TEvents extends TopicEvents> = { [K in keyof TEvents & string]: PublishableMessage<K, InferStandardSchema<TEvents[K]>>; }[keyof TEvents & string];
+/**
+ * A topic — pub/sub fan-out. Unlike a `Queue` (point-to-point, one consumer), a
+ * topic is a *resource* owned by no single handler: it declares the event
+ * contract, and any number of subscribers (`worker.topic(topic)`) bind to it.
+ * `gkm build` discovers it into the manifest's `topics` field; infra provisions
+ * an SNS topic.
+ *
+ * A construct publishes with `.event(topic, { type, payload })`, repeatable
+ * across topics, each event going through its own topic's publisher. That also
+ * puts `services.<topic>` in the handler, as `.dependsOn([topic])` does, for an
+ * event the handler decides on itself.
+ *
+ * ```ts
+ * export const users = new Topic('Users', {
+ *   events: { 'user.created': z.object({ userId: z.string() }) },
+ * });
+ * ```
+ */
+declare class Topic<TName extends string = string, TEvents extends TopicEvents = TopicEvents> extends Construct {
+  __IS_TOPIC__: boolean;
+  static isTopic(obj: unknown): obj is Topic<string, TopicEvents>;
+  /**
+   * The canonical id this topic is declared under.
+   *
+   * Derived from the name, so `users` and `Users` are one topic. The name is
+   * left alone: subscribers bind to it and it is what the broker routes on.
+   */
+  readonly id: string;
+  /** The name it was declared with — what the broker routes on. */
+  readonly name: TName;
+  /**
+   * The event contract — a map of event type → payload schema. Named
+   * `eventSchemas` (not `events`) to avoid clashing with `Construct.events`,
+   * which is the array of `MappedEvent`s a construct *publishes*.
+   */
+  readonly eventSchemas: TEvents;
+  /**
+   * The topic as a dependency — what `.dependsOn([users])` and
+   * `.event(users, …)` dissolve into, reachable as `services.users`.
+   *
+   * The producer, because publishing is the only thing depending on a topic
+   * can mean: a subscriber binds to the topic instead, and is never handed
+   * this. It reads `<NAME>_PUBLISHER_CONNECTION_STRING` and picks the
+   * transport from its protocol — `pgboss://` locally, `sns://` deployed.
+   *
+   * A field assigned once, not a getter: services are cached by object
+   * identity, and a fresh literal on every access never hit that cache.
+   */
+  readonly service: Service<Uncapitalize<TName>, EventPublisher<TopicMessage<TEvents>>>;
+  /** The producer's env key, read by both {@link declare} and the service. */
+  private readonly connectionKey;
+  constructor(name: ConstructName<TName>, options: TopicOptions<TEvents>);
+  /**
+   * What this topic is in the manifest.
+   *
+   * Only the producer's key: a subscriber is *bound* to a topic rather than
+   * depending on it, so the binding is an edge the deploy target reads and not
+   * an env key anyone can hold. Locally both sides meet on the same broker.
+   */
+  declare(): Declaration[];
+  /** The event type names this topic carries. */
+  get eventTypes(): (keyof TEvents & string)[];
+}
+interface TopicOptions<TEvents extends TopicEvents> {
+  /** Each event this topic carries — its type, and its payload's schema. */
+  events: TEvents;
+}
+//#endregion
+//#region src/publisher.d.ts
+/**
+ * An event a construct publishes to a topic once its handler has succeeded.
+ *
+ * It carries its topic, so a construct can publish to as many topics as it
+ * names — each event goes through the publisher of the topic it was declared
+ * against, never a single shared one.
+ */
+interface TopicEvent<TOutput = any> {
+  /** The topic's service: the publisher this event is sent through. */
+  topic: Service<string, EventPublisher<any>>;
+  type: string;
+  /** The event's payload, from what the handler returned. */
+  payload: (output: TOutput) => unknown;
+  /** Publish only when this holds for what the handler returned. */
+  when?: (output: TOutput) => boolean;
+}
+/**
+ * What `.event(topic, …)` takes: one of the topic's event types, and a payload
+ * of that event's shape built from the handler's output.
+ */
+type EventFor<TTopic extends Topic<any, any>, TOutput> = TTopic extends Topic<string, infer TEvents> ? { [K in keyof TEvents & string]: {
+  type: K;
+  payload: (output: TOutput) => InferStandardSchema<TEvents[K]>;
+  when?: (output: TOutput) => boolean;
+}; }[keyof TEvents & string] : never;
+/** Publish a construct's declared events for what its handler returned. */
+declare function publishConstructEvents<OutSchema extends StandardSchemaV1 | undefined = undefined>(construct: Pick<Construct, 'events' | 'logger'>, response: InferStandardSchema<OutSchema>, serviceDiscovery: ServiceDiscovery<any>, logger?: Logger, provided?: Readonly<Record<string, unknown>>): Promise<void>;
+//#endregion
+//#region src/Construct.d.ts
+/**
+ * Noop context for environment sniffing.
+ * Used when calling service.register() to detect env vars without a real request.
+ * Returns dummy values since services should only use context in instance methods,
+ * not during registration.
+ */
+declare const snifferContext: ServiceContext;
+declare abstract class Construct<TLogger extends Logger = Logger, OutSchema extends StandardSchemaV1 | undefined = undefined, TServices extends Service[] = [], TAuditStorageServiceName extends string = string, TAuditStorage extends AuditStorage | undefined = undefined, TDatabaseServiceName extends string = string, TDatabase = unknown> {
+  readonly type: ConstructType;
+  readonly logger: TLogger;
+  readonly services: TServices;
+  /**
+   * What this construct publishes once its handler succeeds — each event
+   * bound to its own topic, so a construct publishes to as many as it names.
+   */
+  readonly events: TopicEvent[];
+  outputSchema?: OutSchema | undefined;
+  readonly timeout?: number | undefined;
+  readonly memorySize?: number | undefined;
+  readonly auditorStorageService?: Service<TAuditStorageServiceName, TAuditStorage>;
+  /**
+   * The constructs this one declared an edge to, by id.
+   *
+   * What the manifest records. `services` is the same information in the
+   * form a handler runs with — clients, keyed by name — and an id cannot be
+   * recovered from one of those reliably, so both are kept.
+   *
+   * Last in the list because every other parameter is positional and already
+   * spoken for; a new one anywhere else silently rebinds existing callers.
+   */
+  readonly constructs: string[];
+  /** Database service for this construct (used by Endpoint for RLS/audit context) */
+  databaseService?: Service<TDatabaseServiceName, TDatabase>;
+  /**
+   * The deploy unit that runs this, by construct id.
+   *
+   * What an endpoint's `surface` is to it, and for the same reason: something
+   * has to say which process a runnable belongs to, and until this existed the
+   * only thing that said so was the directory its file sat in. Set by the
+   * factory it was built from — `worker.crons`, `api.get(…)` — so it is
+   * carried rather than configured.
+   *
+   * Undefined for a construct built from a free-standing builder, which is
+   * still how `c`, `s` and `f` work.
+   */
+  owner?: string;
+  constructor(type: ConstructType, logger: TLogger, services: TServices,
+  /**
+   * What this construct publishes once its handler succeeds — each event
+   * bound to its own topic, so a construct publishes to as many as it names.
+   */
+  events?: TopicEvent[], outputSchema?: OutSchema | undefined, timeout?: number | undefined, memorySize?: number | undefined, auditorStorageService?: Service<TAuditStorageServiceName, TAuditStorage>,
+  /**
+   * The constructs this one declared an edge to, by id.
+   *
+   * What the manifest records. `services` is the same information in the
+   * form a handler runs with — clients, keyed by name — and an id cannot be
+   * recovered from one of those reliably, so both are kept.
+   *
+   * Last in the list because every other parameter is positional and already
+   * spoken for; a new one anywhere else silently rebinds existing callers.
+   */
+  constructs?: string[]);
+  /**
+   * Returns an array of environment variable names required by this construct's services.
+   * This is determined by running a "sniffer" EnvironmentParser through each service's
+   * register method to track which environment variables are accessed.
+   *
+   * Results are cached per service class to handle singleton patterns where
+   * subsequent register() calls may short-circuit and not access env vars.
+   *
+   * @param markOptional - When true, optional vars (those accessed via `.optional()` or
+   *   `.default()`) are suffixed with `?` in the returned array (e.g. `'PORT?'`).
+   * @returns Promise that resolves to array of environment variable names, sorted alphabetically
+   *
+   * @example
+   * ```typescript
+   * const endpoint = e
+   *   .services([databaseService, authService])
+   *   .get('/users')
+   *   .handle(async () => []);
+   *
+   * await endpoint.getEnvironment();               // ['AUTH_SECRET', 'DATABASE_URL']
+   * await endpoint.getEnvironment({ markOptional: true }); // ['AUTH_SECRET', 'DATABASE_URL', 'PORT?']
+   * ```
+   */
+  getEnvironment(opts?: {
+    markOptional?: boolean;
+  }): Promise<string[]>;
+}
+declare enum ConstructType {
+  Cron = "dev.geekmidas.function.cron",
+  Endpoint = "dev.geekmidas.function.endpoint",
+  Function = "dev.geekmidas.function.function",
+  Subscriber = "dev.geekmidas.function.subscriber",
+  Queue = "dev.geekmidas.function.queue",
+  Topic = "dev.geekmidas.resource.topic"
+}
+/**
+ * Utility to test sniffing a service for environment variables.
+ * Useful for debugging services that throw errors during sniffing.
+ *
+ * @example
+ * ```typescript
+ * import { sniffService } from '@geekmidas/constructs';
+ * import { authService } from './services/AuthService';
+ *
+ * const result = await sniffService(authService);
+ * console.log('Env vars:', result.envVars);
+ * console.log('Error:', result.error);
+ * ```
+ */
+declare function sniffService(service: Service): Promise<SniffResult>;
+//#endregion
+export { EventFor as a, Topic as c, TopicOptions as d, snifferContext as i, TopicEvents as l, ConstructType as n, TopicEvent as o, sniffService as r, publishConstructEvents as s, Construct as t, TopicMessage as u };
+//# sourceMappingURL=Construct-BQALFCh2.d.cts.map

package/dist/Construct-BQALFCh2.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Construct-BQALFCh2.d.cts","names":[],"sources":["../src/topic/Topic.ts","../src/publisher.ts","../src/Construct.ts"],"mappings":";;;;;;;;;;KAoBY,cAAc,eAAe;;;;;KAM7B,aAAa,gBAAgB,kBACvC,WAAW,mBAAmB,mBAC9B,GACA,oBAAoB,QAAQ,cAEtB;;;;;;;;;;;;;;;;;;;cAoBK,MACZ,+BACA,gBAAgB,cAAc,qBACrB;EACT;SAEO,QAAQ,eAAe,OAAO,cAAc;;;;;;;WAc1C;;WAGA,MAAM;;;;;;WAON,cAAc;;;;;;;;;;;;;WAcd,SAAS,QACjB,aAAa,QACb,eAAe,aAAa;;mBAIZ;EAEjB,YAAY,MAAM,cAAc,QAAQ,SAAS,aAAa;;;;;;;;EA8B9D,WAAW;;MAmBP,qBAAqB;;UAKT,aAAa,gBAAgB;;EAE7C,QAAQ;;;;;;;;;;;UChJQ,WAAW;;EAE3B,OAAO,gBAAgB;EACvB;;EAEA,UAAU,QAAQ;;EAElB,QAAQ,QAAQ;;;;;;KAOL,SACX,eAAe,iBACf,WACG,eAAe,oBAAoB,cAEnC,WAAW;EACX,MAAM;EACN,UAAU,QAAQ,YAAY,oBAAoB,QAAQ;EAC1D,QAAQ,QAAQ;WAEV;;iBAwFY,uBACrB,kBAAkB,0CAElB,WAAW,KAAK,iCAChB,UAAU,oBAAoB,YAC9B,kBAAkB,uBAClB,SAAQ,QACR,WAAU,SAAS,2BAA6B;;;;;;;;;cC5G3C,gBAAgB;uBAsBA,UACrB,gBAAgB,SAAS,QACzB,kBAAkB,0CAClB,kBAAkB,gBAClB,kDACA,sBAAsB,sCACtB,8CACA;WAoBiB,MAAM;WACN,QAAQ;WACR,UAAU;;;;;WAKV,QAAQ;EACjB,eAAe;WACN;WACA;WACA,wBAAwB,QACvC,0BACA;;;;;;;;;;;WAYe;;EA1CV,kBAAkB,QAAQ,sBAAsB;;;;;;;;;;;;;EAchD;EAEP,YACiB,MAAM,eACN,QAAQ,SACR,UAAU,WAKV;;;;;EAAA,SAAQ,cACjB,eAAe,uBACN,8BACA,iCACA,wBAAwB,QACvC,0BACA,gBAYe;;;;;;;;;;;EAAA;;;;;;;;;;;;;;;;;;;;;;;;EA0BX,eACL;IAAQ;MACN;;aAiEQ;EACX;EACA;EACA;EACA;EACA;EACA;;;;;;;;;;;;;;;;iBAiBqB,aAAa,SAAS,UAAU,QAAQ"}

package/dist/{Construct-yG9Sw-5p.cjs → Construct-DmvXceVY.cjs}

@@ -69,7 +69,6 @@ var Construct = class {
 	logger;
 	services;
 	events;
-	publisherService;
 	outputSchema;
 	timeout;
 	memorySize;
@@ -90,12 +89,11 @@ var Construct = class {
 	* still how `c`, `s` and `f` work.
 	*/
 	owner;
-	constructor(type, logger, services, events = [], publisherService, outputSchema, timeout, memorySize, auditorStorageService, constructs = []) {
+	constructor(type, logger, services, events = [], outputSchema, timeout, memorySize, auditorStorageService, constructs = []) {
 		this.type = type;
 		this.logger = logger;
 		this.services = services;
 		this.events = events;
-		this.publisherService = publisherService;
 		this.outputSchema = outputSchema;
 		this.timeout = timeout;
 		this.memorySize = memorySize;
@@ -131,8 +129,7 @@ var Construct = class {
 		const optionalVars = /* @__PURE__ */ new Set();
 		const services = (0, import_lodash_compact.default)([
 			...this.services,
-			this.publisherService,
-			this.publisherService,
+			...this.events.map(({ topic }) => topic),
 			this.auditorStorageService,
 			this.databaseService
 		]);
@@ -225,4 +222,4 @@ Object.defineProperty(exports, "snifferContext", {
 	}
 });
 
-//# sourceMappingURL=Construct-yG9Sw-5p.cjs.map
+//# sourceMappingURL=Construct-DmvXceVY.cjs.map

package/dist/Construct-DmvXceVY.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Construct-DmvXceVY.cjs","names":["compact","SnifferEnvironmentParser","sniffWithFireAndForget"],"sources":["../../../node_modules/.pnpm/lodash.compact@3.0.1/node_modules/lodash.compact/index.js","../src/Construct.ts"],"sourcesContent":["/**\n * lodash 3.0.1 (Custom Build) <https://lodash.com/>\n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright 2012-2016 The Dojo Foundation <http://dojofoundation.org/>\n * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n * Copyright 2009-2016 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n * Available under MIT license <https://lodash.com/license>\n */\n\n/**\n * Creates an array with all falsey values removed. The values `false`, `null`,\n * `0`, `\"\"`, `undefined`, and `NaN` are falsey.\n *\n * @static\n * @memberOf _\n * @category Array\n * @param {Array} array The array to compact.\n * @returns {Array} Returns the new array of filtered values.\n * @example\n *\n * _.compact([0, 1, false, 2, '', 3]);\n * // => [1, 2, 3]\n */\nfunction compact(array) {\n  var index = -1,\n      length = array ? array.length : 0,\n      resIndex = 0,\n      result = [];\n\n  while (++index < length) {\n    var value = array[index];\n    if (value) {\n      result[resIndex++] = value;\n    }\n  }\n  return result;\n}\n\nmodule.exports = compact;\n","import type { AuditStorage } from '@geekmidas/audit';\nimport {\n\tSnifferEnvironmentParser,\n\ttype SniffResult,\n\tsniffWithFireAndForget,\n} from '@geekmidas/envkit/sniffer';\nimport type { Logger } from '@geekmidas/logger';\nimport type { Service, ServiceContext } from '@geekmidas/services';\nimport type { StandardSchemaV1 } from '@standard-schema/spec';\nimport compact from 'lodash.compact';\nimport type { TopicEvent } from './publisher';\n\n// Cache for service environment variables to handle singleton services\n// Stores both the full list and the optional subset so the same sniff result\n// can satisfy both getEnvironment() and getEnvironment({ markOptional: true }).\nconst serviceEnvCache = new Map<\n\tService,\n\t{ envVars: string[]; optionalEnvVars: string[] }\n>();\n\n/**\n * Noop context for environment sniffing.\n * Used when calling service.register() to detect env vars without a real request.\n * Returns dummy values since services should only use context in instance methods,\n * not during registration.\n */\nconst snifferContext: ServiceContext = {\n\tgetLogger() {\n\t\t// Return a noop logger for sniffing - services shouldn't log during registration\n\t\treturn {\n\t\t\tdebug: () => {},\n\t\t\tinfo: () => {},\n\t\t\twarn: () => {},\n\t\t\terror: () => {},\n\t\t\tchild: () => snifferContext.getLogger(),\n\t\t} as unknown as Logger;\n\t},\n\tgetRequestId() {\n\t\treturn 'sniffer-context';\n\t},\n\tgetRequestStartTime() {\n\t\treturn Date.now();\n\t},\n\thasContext() {\n\t\treturn false;\n\t},\n};\n\nexport abstract class Construct<\n\tTLogger extends Logger = Logger,\n\tOutSchema extends StandardSchemaV1 | undefined = undefined,\n\tTServices extends Service[] = [],\n\tTAuditStorageServiceName extends string = string,\n\tTAuditStorage extends AuditStorage | undefined = undefined,\n\tTDatabaseServiceName extends string = string,\n\tTDatabase = unknown,\n> {\n\t/** Database service for this construct (used by Endpoint for RLS/audit context) */\n\tpublic databaseService?: Service<TDatabaseServiceName, TDatabase>;\n\n\t/**\n\t * The deploy unit that runs this, by construct id.\n\t *\n\t * What an endpoint's `surface` is to it, and for the same reason: something\n\t * has to say which process a runnable belongs to, and until this existed the\n\t * only thing that said so was the directory its file sat in. Set by the\n\t * factory it was built from — `worker.crons`, `api.get(…)` — so it is\n\t * carried rather than configured.\n\t *\n\t * Undefined for a construct built from a free-standing builder, which is\n\t * still how `c`, `s` and `f` work.\n\t */\n\tpublic owner?: string;\n\n\tconstructor(\n\t\tpublic readonly type: ConstructType,\n\t\tpublic readonly logger: TLogger,\n\t\tpublic readonly services: TServices,\n\t\t/**\n\t\t * What this construct publishes once its handler succeeds — each event\n\t\t * bound to its own topic, so a construct publishes to as many as it names.\n\t\t */\n\t\tpublic readonly events: TopicEvent[] = [],\n\t\tpublic outputSchema?: OutSchema,\n\t\tpublic readonly timeout?: number,\n\t\tpublic readonly memorySize?: number,\n\t\tpublic readonly auditorStorageService?: Service<\n\t\t\tTAuditStorageServiceName,\n\t\t\tTAuditStorage\n\t\t>,\n\t\t/**\n\t\t * The constructs this one declared an edge to, by id.\n\t\t *\n\t\t * What the manifest records. `services` is the same information in the\n\t\t * form a handler runs with — clients, keyed by name — and an id cannot be\n\t\t * recovered from one of those reliably, so both are kept.\n\t\t *\n\t\t * Last in the list because every other parameter is positional and already\n\t\t * spoken for; a new one anywhere else silently rebinds existing callers.\n\t\t */\n\t\tpublic readonly constructs: string[] = [],\n\t) {}\n\n\t/**\n\t * Returns an array of environment variable names required by this construct's services.\n\t * This is determined by running a \"sniffer\" EnvironmentParser through each service's\n\t * register method to track which environment variables are accessed.\n\t *\n\t * Results are cached per service class to handle singleton patterns where\n\t * subsequent register() calls may short-circuit and not access env vars.\n\t *\n\t * @param markOptional - When true, optional vars (those accessed via `.optional()` or\n\t *   `.default()`) are suffixed with `?` in the returned array (e.g. `'PORT?'`).\n\t * @returns Promise that resolves to array of environment variable names, sorted alphabetically\n\t *\n\t * @example\n\t * ```typescript\n\t * const endpoint = e\n\t *   .services([databaseService, authService])\n\t *   .get('/users')\n\t *   .handle(async () => []);\n\t *\n\t * await endpoint.getEnvironment();               // ['AUTH_SECRET', 'DATABASE_URL']\n\t * await endpoint.getEnvironment({ markOptional: true }); // ['AUTH_SECRET', 'DATABASE_URL', 'PORT?']\n\t * ```\n\t */\n\tasync getEnvironment(\n\t\topts: { markOptional?: boolean } = {},\n\t): Promise<string[]> {\n\t\tconst { markOptional = false } = opts;\n\t\tconst envVars = new Set<string>();\n\t\tconst optionalVars = new Set<string>();\n\t\tconst services: Service[] = compact([\n\t\t\t...this.services,\n\t\t\t// Each topic an event names is a dependency like any other.\n\t\t\t...this.events.map(({ topic }) => topic),\n\t\t\tthis.auditorStorageService,\n\t\t\tthis.databaseService,\n\t\t]);\n\n\t\ttry {\n\t\t\tfor (const service of services) {\n\t\t\t\t// Check cache first - handles singleton services that short-circuit\n\t\t\t\tif (serviceEnvCache.has(service)) {\n\t\t\t\t\tconst cached = serviceEnvCache.get(service)!;\n\t\t\t\t\tcached.envVars.forEach((v) => envVars.add(v));\n\t\t\t\t\tcached.optionalEnvVars.forEach((v) => optionalVars.add(v));\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\n\t\t\t\t// Use sniffService to properly handle all error scenarios\n\t\t\t\tconst result = await sniffService(service);\n\n\t\t\t\t// Log any issues for debugging\n\t\t\t\tif (result.error) {\n\t\t\t\t\tthis.logger.warn(\n\t\t\t\t\t\t{ error: result.error.message, service: service.serviceName },\n\t\t\t\t\t\t'Service threw error during env sniffing (env vars still captured)',\n\t\t\t\t\t);\n\t\t\t\t}\n\t\t\t\tif (result.unhandledRejections.length > 0) {\n\t\t\t\t\tthis.logger.warn(\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\terrors: result.unhandledRejections.map((e) => e.message),\n\t\t\t\t\t\t\tservice: service.serviceName,\n\t\t\t\t\t\t},\n\t\t\t\t\t\t'Fire-and-forget rejections during env sniffing (suppressed)',\n\t\t\t\t\t);\n\t\t\t\t}\n\n\t\t\t\t// Cache and collect env vars (both required and optional)\n\t\t\t\tserviceEnvCache.set(service, {\n\t\t\t\t\tenvVars: result.envVars,\n\t\t\t\t\toptionalEnvVars: result.optionalEnvVars,\n\t\t\t\t});\n\t\t\t\tresult.envVars.forEach((v) => envVars.add(v));\n\t\t\t\tresult.optionalEnvVars.forEach((v) => optionalVars.add(v));\n\t\t\t}\n\n\t\t\tconst sorted = Array.from(envVars).sort();\n\t\t\tif (!markOptional || optionalVars.size === 0) return sorted;\n\t\t\treturn sorted.map((v) => (optionalVars.has(v) ? `${v}?` : v));\n\t\t} catch (error) {\n\t\t\tthis.logger.error(\n\t\t\t\t{ error },\n\t\t\t\t'Error determining environment variables for construct',\n\t\t\t);\n\n\t\t\treturn [];\n\t\t}\n\t}\n}\n\nexport enum ConstructType {\n\tCron = 'dev.geekmidas.function.cron',\n\tEndpoint = 'dev.geekmidas.function.endpoint',\n\tFunction = 'dev.geekmidas.function.function',\n\tSubscriber = 'dev.geekmidas.function.subscriber',\n\tQueue = 'dev.geekmidas.function.queue',\n\tTopic = 'dev.geekmidas.resource.topic',\n}\n\n/**\n * Utility to test sniffing a service for environment variables.\n * Useful for debugging services that throw errors during sniffing.\n *\n * @example\n * ```typescript\n * import { sniffService } from '@geekmidas/constructs';\n * import { authService } from './services/AuthService';\n *\n * const result = await sniffService(authService);\n * console.log('Env vars:', result.envVars);\n * console.log('Error:', result.error);\n * ```\n */\nexport async function sniffService(service: Service): Promise<SniffResult> {\n\tconst sniffer = new SnifferEnvironmentParser();\n\n\treturn sniffWithFireAndForget(sniffer, () =>\n\t\tservice.register({\n\t\t\tenvParser: sniffer as any,\n\t\t\tcontext: snifferContext,\n\t\t}),\n\t);\n}\n\n// Export for testing\nexport { snifferContext };\n"],"x_google_ignoreList":[0],"mappings":"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"}

package/dist/Construct-QXnl3VqT.d.mts

@@ -0,0 +1,230 @@
+import { t as StandardSchemaV1 } from "./index-CeEtxDmK.mjs";
+import { SniffResult } from "@geekmidas/envkit/sniffer";
+import { ConstructName, Declaration } from "@geekmidas/manifest";
+import { EventPublisher, PublishableMessage } from "@geekmidas/events";
+import { Service, ServiceContext, ServiceDiscovery } from "@geekmidas/services";
+import { AuditStorage } from "@geekmidas/audit";
+import { Logger } from "@geekmidas/logger";
+import { InferStandardSchema } from "@geekmidas/schema";
+//#region src/topic/Topic.d.ts
+/** A topic's event contract — a map of event type → payload schema. */
+type TopicEvents = Record<string, StandardSchemaV1>;
+/**
+ * The union of wire messages a topic carries, derived from its event map:
+ * `{ type: 'user.created'; payload: … } | { type: 'user.updated'; payload: … }`.
+ */
+type TopicMessage<TEvents extends TopicEvents> = { [K in keyof TEvents & string]: PublishableMessage<K, InferStandardSchema<TEvents[K]>>; }[keyof TEvents & string];
+/**
+ * A topic — pub/sub fan-out. Unlike a `Queue` (point-to-point, one consumer), a
+ * topic is a *resource* owned by no single handler: it declares the event
+ * contract, and any number of subscribers (`worker.topic(topic)`) bind to it.
+ * `gkm build` discovers it into the manifest's `topics` field; infra provisions
+ * an SNS topic.
+ *
+ * A construct publishes with `.event(topic, { type, payload })`, repeatable
+ * across topics, each event going through its own topic's publisher. That also
+ * puts `services.<topic>` in the handler, as `.dependsOn([topic])` does, for an
+ * event the handler decides on itself.
+ *
+ * ```ts
+ * export const users = new Topic('Users', {
+ *   events: { 'user.created': z.object({ userId: z.string() }) },
+ * });
+ * ```
+ */
+declare class Topic<TName extends string = string, TEvents extends TopicEvents = TopicEvents> extends Construct {
+  __IS_TOPIC__: boolean;
+  static isTopic(obj: unknown): obj is Topic<string, TopicEvents>;
+  /**
+   * The canonical id this topic is declared under.
+   *
+   * Derived from the name, so `users` and `Users` are one topic. The name is
+   * left alone: subscribers bind to it and it is what the broker routes on.
+   */
+  readonly id: string;
+  /** The name it was declared with — what the broker routes on. */
+  readonly name: TName;
+  /**
+   * The event contract — a map of event type → payload schema. Named
+   * `eventSchemas` (not `events`) to avoid clashing with `Construct.events`,
+   * which is the array of `MappedEvent`s a construct *publishes*.
+   */
+  readonly eventSchemas: TEvents;
+  /**
+   * The topic as a dependency — what `.dependsOn([users])` and
+   * `.event(users, …)` dissolve into, reachable as `services.users`.
+   *
+   * The producer, because publishing is the only thing depending on a topic
+   * can mean: a subscriber binds to the topic instead, and is never handed
+   * this. It reads `<NAME>_PUBLISHER_CONNECTION_STRING` and picks the
+   * transport from its protocol — `pgboss://` locally, `sns://` deployed.
+   *
+   * A field assigned once, not a getter: services are cached by object
+   * identity, and a fresh literal on every access never hit that cache.
+   */
+  readonly service: Service<Uncapitalize<TName>, EventPublisher<TopicMessage<TEvents>>>;
+  /** The producer's env key, read by both {@link declare} and the service. */
+  private readonly connectionKey;
+  constructor(name: ConstructName<TName>, options: TopicOptions<TEvents>);
+  /**
+   * What this topic is in the manifest.
+   *
+   * Only the producer's key: a subscriber is *bound* to a topic rather than
+   * depending on it, so the binding is an edge the deploy target reads and not
+   * an env key anyone can hold. Locally both sides meet on the same broker.
+   */
+  declare(): Declaration[];
+  /** The event type names this topic carries. */
+  get eventTypes(): (keyof TEvents & string)[];
+}
+interface TopicOptions<TEvents extends TopicEvents> {
+  /** Each event this topic carries — its type, and its payload's schema. */
+  events: TEvents;
+}
+//#endregion
+//#region src/publisher.d.ts
+/**
+ * An event a construct publishes to a topic once its handler has succeeded.
+ *
+ * It carries its topic, so a construct can publish to as many topics as it
+ * names — each event goes through the publisher of the topic it was declared
+ * against, never a single shared one.
+ */
+interface TopicEvent<TOutput = any> {
+  /** The topic's service: the publisher this event is sent through. */
+  topic: Service<string, EventPublisher<any>>;
+  type: string;
+  /** The event's payload, from what the handler returned. */
+  payload: (output: TOutput) => unknown;
+  /** Publish only when this holds for what the handler returned. */
+  when?: (output: TOutput) => boolean;
+}
+/**
+ * What `.event(topic, …)` takes: one of the topic's event types, and a payload
+ * of that event's shape built from the handler's output.
+ */
+type EventFor<TTopic extends Topic<any, any>, TOutput> = TTopic extends Topic<string, infer TEvents> ? { [K in keyof TEvents & string]: {
+  type: K;
+  payload: (output: TOutput) => InferStandardSchema<TEvents[K]>;
+  when?: (output: TOutput) => boolean;
+}; }[keyof TEvents & string] : never;
+/** Publish a construct's declared events for what its handler returned. */
+declare function publishConstructEvents<OutSchema extends StandardSchemaV1 | undefined = undefined>(construct: Pick<Construct, 'events' | 'logger'>, response: InferStandardSchema<OutSchema>, serviceDiscovery: ServiceDiscovery<any>, logger?: Logger, provided?: Readonly<Record<string, unknown>>): Promise<void>;
+//#endregion
+//#region src/Construct.d.ts
+/**
+ * Noop context for environment sniffing.
+ * Used when calling service.register() to detect env vars without a real request.
+ * Returns dummy values since services should only use context in instance methods,
+ * not during registration.
+ */
+declare const snifferContext: ServiceContext;
+declare abstract class Construct<TLogger extends Logger = Logger, OutSchema extends StandardSchemaV1 | undefined = undefined, TServices extends Service[] = [], TAuditStorageServiceName extends string = string, TAuditStorage extends AuditStorage | undefined = undefined, TDatabaseServiceName extends string = string, TDatabase = unknown> {
+  readonly type: ConstructType;
+  readonly logger: TLogger;
+  readonly services: TServices;
+  /**
+   * What this construct publishes once its handler succeeds — each event
+   * bound to its own topic, so a construct publishes to as many as it names.
+   */
+  readonly events: TopicEvent[];
+  outputSchema?: OutSchema | undefined;
+  readonly timeout?: number | undefined;
+  readonly memorySize?: number | undefined;
+  readonly auditorStorageService?: Service<TAuditStorageServiceName, TAuditStorage>;
+  /**
+   * The constructs this one declared an edge to, by id.
+   *
+   * What the manifest records. `services` is the same information in the
+   * form a handler runs with — clients, keyed by name — and an id cannot be
+   * recovered from one of those reliably, so both are kept.
+   *
+   * Last in the list because every other parameter is positional and already
+   * spoken for; a new one anywhere else silently rebinds existing callers.
+   */
+  readonly constructs: string[];
+  /** Database service for this construct (used by Endpoint for RLS/audit context) */
+  databaseService?: Service<TDatabaseServiceName, TDatabase>;
+  /**
+   * The deploy unit that runs this, by construct id.
+   *
+   * What an endpoint's `surface` is to it, and for the same reason: something
+   * has to say which process a runnable belongs to, and until this existed the
+   * only thing that said so was the directory its file sat in. Set by the
+   * factory it was built from — `worker.crons`, `api.get(…)` — so it is
+   * carried rather than configured.
+   *
+   * Undefined for a construct built from a free-standing builder, which is
+   * still how `c`, `s` and `f` work.
+   */
+  owner?: string;
+  constructor(type: ConstructType, logger: TLogger, services: TServices,
+  /**
+   * What this construct publishes once its handler succeeds — each event
+   * bound to its own topic, so a construct publishes to as many as it names.
+   */
+  events?: TopicEvent[], outputSchema?: OutSchema | undefined, timeout?: number | undefined, memorySize?: number | undefined, auditorStorageService?: Service<TAuditStorageServiceName, TAuditStorage>,
+  /**
+   * The constructs this one declared an edge to, by id.
+   *
+   * What the manifest records. `services` is the same information in the
+   * form a handler runs with — clients, keyed by name — and an id cannot be
+   * recovered from one of those reliably, so both are kept.
+   *
+   * Last in the list because every other parameter is positional and already
+   * spoken for; a new one anywhere else silently rebinds existing callers.
+   */
+  constructs?: string[]);
+  /**
+   * Returns an array of environment variable names required by this construct's services.
+   * This is determined by running a "sniffer" EnvironmentParser through each service's
+   * register method to track which environment variables are accessed.
+   *
+   * Results are cached per service class to handle singleton patterns where
+   * subsequent register() calls may short-circuit and not access env vars.
+   *
+   * @param markOptional - When true, optional vars (those accessed via `.optional()` or
+   *   `.default()`) are suffixed with `?` in the returned array (e.g. `'PORT?'`).
+   * @returns Promise that resolves to array of environment variable names, sorted alphabetically
+   *
+   * @example
+   * ```typescript
+   * const endpoint = e
+   *   .services([databaseService, authService])
+   *   .get('/users')
+   *   .handle(async () => []);
+   *
+   * await endpoint.getEnvironment();               // ['AUTH_SECRET', 'DATABASE_URL']
+   * await endpoint.getEnvironment({ markOptional: true }); // ['AUTH_SECRET', 'DATABASE_URL', 'PORT?']
+   * ```
+   */
+  getEnvironment(opts?: {
+    markOptional?: boolean;
+  }): Promise<string[]>;
+}
+declare enum ConstructType {
+  Cron = "dev.geekmidas.function.cron",
+  Endpoint = "dev.geekmidas.function.endpoint",
+  Function = "dev.geekmidas.function.function",
+  Subscriber = "dev.geekmidas.function.subscriber",
+  Queue = "dev.geekmidas.function.queue",
+  Topic = "dev.geekmidas.resource.topic"
+}
+/**
+ * Utility to test sniffing a service for environment variables.
+ * Useful for debugging services that throw errors during sniffing.
+ *
+ * @example
+ * ```typescript
+ * import { sniffService } from '@geekmidas/constructs';
+ * import { authService } from './services/AuthService';
+ *
+ * const result = await sniffService(authService);
+ * console.log('Env vars:', result.envVars);
+ * console.log('Error:', result.error);
+ * ```
+ */
+declare function sniffService(service: Service): Promise<SniffResult>;
+//#endregion
+export { EventFor as a, Topic as c, TopicOptions as d, snifferContext as i, TopicEvents as l, ConstructType as n, TopicEvent as o, sniffService as r, publishConstructEvents as s, Construct as t, TopicMessage as u };
+//# sourceMappingURL=Construct-QXnl3VqT.d.mts.map

package/dist/Construct-QXnl3VqT.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Construct-QXnl3VqT.d.mts","names":[],"sources":["../src/topic/Topic.ts","../src/publisher.ts","../src/Construct.ts"],"mappings":";;;;;;;;;;KAoBY,cAAc,eAAe;;;;;KAM7B,aAAa,gBAAgB,kBACvC,WAAW,mBAAmB,mBAC9B,GACA,oBAAoB,QAAQ,cAEtB;;;;;;;;;;;;;;;;;;;cAoBK,MACZ,+BACA,gBAAgB,cAAc,qBACrB;EACT;SAEO,QAAQ,eAAe,OAAO,cAAc;;;;;;;WAc1C;;WAGA,MAAM;;;;;;WAON,cAAc;;;;;;;;;;;;;WAcd,SAAS,QACjB,aAAa,QACb,eAAe,aAAa;;mBAIZ;EAEjB,YAAY,MAAM,cAAc,QAAQ,SAAS,aAAa;;;;;;;;EA8B9D,WAAW;;MAmBP,qBAAqB;;UAKT,aAAa,gBAAgB;;EAE7C,QAAQ;;;;;;;;;;;UChJQ,WAAW;;EAE3B,OAAO,gBAAgB;EACvB;;EAEA,UAAU,QAAQ;;EAElB,QAAQ,QAAQ;;;;;;KAOL,SACX,eAAe,iBACf,WACG,eAAe,oBAAoB,cAEnC,WAAW;EACX,MAAM;EACN,UAAU,QAAQ,YAAY,oBAAoB,QAAQ;EAC1D,QAAQ,QAAQ;WAEV;;iBAwFY,uBACrB,kBAAkB,0CAElB,WAAW,KAAK,iCAChB,UAAU,oBAAoB,YAC9B,kBAAkB,uBAClB,SAAQ,QACR,WAAU,SAAS,2BAA6B;;;;;;;;;cC5G3C,gBAAgB;uBAsBA,UACrB,gBAAgB,SAAS,QACzB,kBAAkB,0CAClB,kBAAkB,gBAClB,kDACA,sBAAsB,sCACtB,8CACA;WAoBiB,MAAM;WACN,QAAQ;WACR,UAAU;;;;;WAKV,QAAQ;EACjB,eAAe;WACN;WACA;WACA,wBAAwB,QACvC,0BACA;;;;;;;;;;;WAYe;;EA1CV,kBAAkB,QAAQ,sBAAsB;;;;;;;;;;;;;EAchD;EAEP,YACiB,MAAM,eACN,QAAQ,SACR,UAAU,WAKV;;;;;EAAA,SAAQ,cACjB,eAAe,uBACN,8BACA,iCACA,wBAAwB,QACvC,0BACA,gBAYe;;;;;;;;;;;EAAA;;;;;;;;;;;;;;;;;;;;;;;;EA0BX,eACL;IAAQ;MACN;;aAiEQ;EACX;EACA;EACA;EACA;EACA;EACA;;;;;;;;;;;;;;;;iBAiBqB,aAAa,SAAS,UAAU,QAAQ"}

package/dist/{Cron-CA2oa2nC.d.cts → Cron-CMEGfRs8.d.cts}

@@ -1,12 +1,12 @@
 import { t as StandardSchemaV1 } from "./index-CeEtxDmK.cjs";
-import { a as FunctionHandler, r as Function } from "./index-BI23K3wy.cjs";
-import { EventPublisher } from "@geekmidas/events";
+import { o as TopicEvent } from "./Construct-BQALFCh2.cjs";
+import { a as FunctionHandler, r as Function } from "./index-B0kxstwf.cjs";
 import { Logger } from "@geekmidas/logger";
 import { ComposableStandardSchema } from "@geekmidas/schema";
 import { Service } from "@geekmidas/services";
 import { AuditableAction } from "@geekmidas/audit";
 //#region src/crons/Cron.d.ts
-declare class Cron<TInput extends ComposableStandardSchema | undefined = undefined, TServices extends Service[] = [], TLogger extends Logger = Logger, OutSchema extends StandardSchemaV1 | undefined = undefined, TEventPublisher extends EventPublisher<any> | undefined = undefined, TEventPublisherServiceName extends string = string, TDatabase = undefined, TDatabaseServiceName extends string = string> extends Function<TInput, TServices, TLogger, OutSchema, TEventPublisher, TEventPublisherServiceName, undefined, string, TDatabase, TDatabaseServiceName, AuditableAction<string, unknown>, FunctionHandler<TInput, TServices, TLogger, OutSchema, TDatabase>> {
+declare class Cron<TInput extends ComposableStandardSchema | undefined = undefined, TServices extends Service[] = [], TLogger extends Logger = Logger, OutSchema extends StandardSchemaV1 | undefined = undefined, TDatabase = undefined, TDatabaseServiceName extends string = string> extends Function<TInput, TServices, TLogger, OutSchema, undefined, string, TDatabase, TDatabaseServiceName, AuditableAction<string, unknown>, FunctionHandler<TInput, TServices, TLogger, OutSchema, TDatabase>> {
   protected _schedule?: ScheduleExpression | undefined;
   /**
    * Where this cron's schedule lives when a server runs it.
@@ -21,7 +21,9 @@ declare class Cron<TInput extends ComposableStandardSchema | undefined = undefin
    */
   scheduleStore?: Service<string, unknown>;
   static isCron(obj: any): obj is Cron<any, any, any, any>;
-  constructor(fn: FunctionHandler<TInput, TServices, TLogger, OutSchema, TDatabase>, timeout?: number, _schedule?: ScheduleExpression | undefined, input?: TInput, outputSchema?: OutSchema, services?: TServices, logger?: TLogger, publisherService?: Service<TEventPublisherServiceName, TEventPublisher>, events?: any[], memorySize?: number, databaseService?: Service<TDatabaseServiceName, TDatabase>,
+  constructor(fn: FunctionHandler<TInput, TServices, TLogger, OutSchema, TDatabase>, timeout?: number, _schedule?: ScheduleExpression | undefined, input?: TInput, outputSchema?: OutSchema, services?: TServices, logger?: TLogger,
+  /** What it publishes once it has run, each to its own topic. */
+  events?: TopicEvent[], memorySize?: number, databaseService?: Service<TDatabaseServiceName, TDatabase>,
   /**
    * The construct ids `.dependsOn()` named — last, so no existing positional
    * argument moves.
@@ -39,4 +41,4 @@ type CronExpression = `cron(${CronMinute} ${CronHour} ${CronDay} ${CronMonth} ${
 type ScheduleExpression = RateExpression | CronExpression;
 //#endregion
 export { ScheduleExpression as i, CronExpression as n, RateExpression as r, Cron as t };
-//# sourceMappingURL=Cron-CA2oa2nC.d.cts.map
+//# sourceMappingURL=Cron-CMEGfRs8.d.cts.map

package/dist/Cron-CMEGfRs8.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Cron-CMEGfRs8.d.cts","names":[],"sources":["../src/crons/Cron.ts"],"mappings":";;;;;;;;cAUa,KACZ,eAAe,kDACf,kBAAkB,gBAClB,gBAAgB,SAAS,QACzB,kBAAkB,0CAClB,uBACA,sDACS,SACT,QACA,WACA,SACA,8BAGA,WACA,sBACA,kCACA,gBAAgB,QAAQ,WAAW,SAAS,WAAW;YA0B5C,YAAY;;;;;;;;;;;;EAbvB,gBAAgB;SAET,OAAO,WAAW,OAAO;EAQhC,YACC,IAAI,gBAAgB,QAAQ,WAAW,SAAS,WAAW,YAC3D,kBACU,YAAY,gCACtB,QAAQ,QACR,eAAe,WACf,WAAU,WACV,SAAS,SAET;;EAAA,SAAQ,cACR,qBACA,kBAAkB,QAAQ,sBAAsB,YAKhD;;;;;EAAA;MAkBG,YAAY;;KAKL;KAEP;KAUA;KAUA;KAUA;KAqBA;KAiBO,yBACH,cAAc,YAAY,WAAW,aAAa;KAE/C,qBAAqB,iBAAiB"}

package/dist/{Cron-B_iuyNxr.d.mts → Cron-D6X4-xjB.d.mts}

@@ -1,12 +1,12 @@
 import { t as StandardSchemaV1 } from "./index-CeEtxDmK.mjs";
-import { a as FunctionHandler, r as Function } from "./index-yb3fXNyH.mjs";
-import { EventPublisher } from "@geekmidas/events";
+import { o as TopicEvent } from "./Construct-QXnl3VqT.mjs";
+import { a as FunctionHandler, r as Function } from "./index-CjVEjOw0.mjs";
 import { Service } from "@geekmidas/services";
 import { AuditableAction } from "@geekmidas/audit";
 import { Logger } from "@geekmidas/logger";
 import { ComposableStandardSchema } from "@geekmidas/schema";
 //#region src/crons/Cron.d.ts
-declare class Cron<TInput extends ComposableStandardSchema | undefined = undefined, TServices extends Service[] = [], TLogger extends Logger = Logger, OutSchema extends StandardSchemaV1 | undefined = undefined, TEventPublisher extends EventPublisher<any> | undefined = undefined, TEventPublisherServiceName extends string = string, TDatabase = undefined, TDatabaseServiceName extends string = string> extends Function<TInput, TServices, TLogger, OutSchema, TEventPublisher, TEventPublisherServiceName, undefined, string, TDatabase, TDatabaseServiceName, AuditableAction<string, unknown>, FunctionHandler<TInput, TServices, TLogger, OutSchema, TDatabase>> {
+declare class Cron<TInput extends ComposableStandardSchema | undefined = undefined, TServices extends Service[] = [], TLogger extends Logger = Logger, OutSchema extends StandardSchemaV1 | undefined = undefined, TDatabase = undefined, TDatabaseServiceName extends string = string> extends Function<TInput, TServices, TLogger, OutSchema, undefined, string, TDatabase, TDatabaseServiceName, AuditableAction<string, unknown>, FunctionHandler<TInput, TServices, TLogger, OutSchema, TDatabase>> {
   protected _schedule?: ScheduleExpression | undefined;
   /**
    * Where this cron's schedule lives when a server runs it.
@@ -21,7 +21,9 @@ declare class Cron<TInput extends ComposableStandardSchema | undefined = undefin
    */
   scheduleStore?: Service<string, unknown>;
   static isCron(obj: any): obj is Cron<any, any, any, any>;
-  constructor(fn: FunctionHandler<TInput, TServices, TLogger, OutSchema, TDatabase>, timeout?: number, _schedule?: ScheduleExpression | undefined, input?: TInput, outputSchema?: OutSchema, services?: TServices, logger?: TLogger, publisherService?: Service<TEventPublisherServiceName, TEventPublisher>, events?: any[], memorySize?: number, databaseService?: Service<TDatabaseServiceName, TDatabase>,
+  constructor(fn: FunctionHandler<TInput, TServices, TLogger, OutSchema, TDatabase>, timeout?: number, _schedule?: ScheduleExpression | undefined, input?: TInput, outputSchema?: OutSchema, services?: TServices, logger?: TLogger,
+  /** What it publishes once it has run, each to its own topic. */
+  events?: TopicEvent[], memorySize?: number, databaseService?: Service<TDatabaseServiceName, TDatabase>,
   /**
    * The construct ids `.dependsOn()` named — last, so no existing positional
    * argument moves.
@@ -39,4 +41,4 @@ type CronExpression = `cron(${CronMinute} ${CronHour} ${CronDay} ${CronMonth} ${
 type ScheduleExpression = RateExpression | CronExpression;
 //#endregion
 export { ScheduleExpression as i, CronExpression as n, RateExpression as r, Cron as t };
-//# sourceMappingURL=Cron-B_iuyNxr.d.mts.map
+//# sourceMappingURL=Cron-D6X4-xjB.d.mts.map

package/dist/Cron-D6X4-xjB.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Cron-D6X4-xjB.d.mts","names":[],"sources":["../src/crons/Cron.ts"],"mappings":";;;;;;;;cAUa,KACZ,eAAe,kDACf,kBAAkB,gBAClB,gBAAgB,SAAS,QACzB,kBAAkB,0CAClB,uBACA,sDACS,SACT,QACA,WACA,SACA,8BAGA,WACA,sBACA,kCACA,gBAAgB,QAAQ,WAAW,SAAS,WAAW;YA0B5C,YAAY;;;;;;;;;;;;EAbvB,gBAAgB;SAET,OAAO,WAAW,OAAO;EAQhC,YACC,IAAI,gBAAgB,QAAQ,WAAW,SAAS,WAAW,YAC3D,kBACU,YAAY,gCACtB,QAAQ,QACR,eAAe,WACf,WAAU,WACV,SAAS,SAET;;EAAA,SAAQ,cACR,qBACA,kBAAkB,QAAQ,sBAAsB,YAKhD;;;;;EAAA;MAkBG,YAAY;;KAKL;KAEP;KAUA;KAUA;KAUA;KAqBA;KAiBO,yBACH,cAAc,YAAY,WAAW,aAAa;KAE/C,qBAAqB,iBAAiB"}