@geekmidas/constructs 10.0.0-alpha.123 → 10.0.0-alpha.125

package/dist/ObjectSubscriberBuilder-l-64yUiF.d.cts

@@ -0,0 +1,129 @@
+import { n as StandardSchemaV1 } from "./index-DdRjYhiJ.cjs";
+import { c as Topic, l as TopicEvents, u as TopicMessage } from "./Construct-127M7yrl.cjs";
+import { t as DatabaseContext } from "./Function-BIEsY0Hm.cjs";
+import { c as ServicesOf, r as Consumable } from "./construct-interface-B1AfqRl4.cjs";
+import { n as SubscriberHandler, t as Subscriber } from "./Subscriber-BdCtfFXL.cjs";
+import { Logger } from "@geekmidas/logger";
+import { InferStandardSchema } from "@geekmidas/schema";
+import { Service, ServiceRecord } from "@geekmidas/services";
+import { EventPublisher, ExtractPublisherMessage } from "@geekmidas/events";
+import { ObjectEvent, ObjectEventType, ObjectFilter, ObjectMessage } from "@geekmidas/storage/events";
+//#region src/subscribers/SubscriberBuilder.d.ts
+declare class SubscriberBuilder<TServices extends Service[] = [], TLogger extends Logger = Logger, OutSchema extends StandardSchemaV1 | undefined = undefined, TEventPublisher extends EventPublisher<any> | undefined = undefined, TSubscribedEvents extends any[] = [], TDatabase = undefined, TDatabaseServiceName extends string = string> {
+  private _subscribedEvents;
+  private _timeout?;
+  private outputSchema?;
+  private _services;
+  /** The construct ids `.dependsOn()` named — what the manifest records. */
+  _constructs: string[];
+  private _logger;
+  /**
+   * The deploy unit that runs this, by construct id. Seeded by the factory a
+   * `Worker` hands out, so a subscriber is not owned by its directory.
+   */
+  _owner?: string;
+  private _topicName?;
+  /** What the handler's `db` comes from — the worker's, unless overridden. */
+  private _databaseService?;
+  /** The edge `.database()` added, so the next one can replace it. */
+  private _databaseEdge?;
+  constructor();
+  /**
+   * Bind this subscriber to a {@link Topic}: the subscribable event types (and
+   * their payloads) come from the topic's contract, and the binding is recorded
+   * for the manifest, so infra wires the SNS subscription.
+   *
+   * A consumer does not publish, so binding a topic does *not* hand it the
+   * topic's publisher connection string (least privilege). One that publishes
+   * follow-up events depends on the topic it publishes to: `.dependsOn([orders])`.
+   */
+  topic<TName extends string, TEvents extends TopicEvents>(topic: Topic<TName, TEvents>): SubscriberBuilder<TServices, TLogger, OutSchema, EventPublisher<TopicMessage<TEvents>>, TSubscribedEvents, TDatabase, TDatabaseServiceName>;
+  timeout(timeout: number): this;
+  output<T extends StandardSchemaV1>(schema: T): SubscriberBuilder<TServices, TLogger, T, TEventPublisher, TSubscribedEvents, TDatabase, TDatabaseServiceName>;
+  /**
+   * Depend on constructs — a database, a bucket, a mail sender, a queue, a
+   * topic.
+   *
+   * It records the edge and dissolves each construct's client into the
+   * handler's service record under the construct's own id, so
+   * `.dependsOn([uploads])` is what makes `services.uploads` exist and type.
+   *
+   * Constructs only. A `Service` does not match the shape, which is what keeps
+   * env sniffing confined to `.services()` and the explicit lift.
+   */
+  dependsOn<const T extends readonly Consumable[]>(constructs: T): SubscriberBuilder<[...TServices, ...ServicesOf<T>], TLogger, OutSchema, TEventPublisher, TSubscribedEvents, TDatabase, TDatabaseServiceName>;
+  services<T extends Service[]>(services: T): SubscriberBuilder<[...TServices, ...T], TLogger, OutSchema, TEventPublisher, TSubscribedEvents, TDatabase, TDatabaseServiceName>;
+  logger<T extends Logger>(logger: T): SubscriberBuilder<TServices, T, OutSchema, TEventPublisher, TSubscribedEvents, TDatabase, TDatabaseServiceName>;
+  /**
+   * The database the handler receives as `db`.
+   *
+   * A subscriber built from a worker already has the worker's, when the
+   * worker named one with `.database(db)`; this replaces it — the edge as well
+   * as the client — for a consumer that works against a different database.
+   */
+  database<T, TDbName extends string>(source: Consumable<TDbName, T> | Service<TDbName, T>): SubscriberBuilder<TServices, TLogger, OutSchema, TEventPublisher, TSubscribedEvents, T, TDbName>;
+  subscribe<TEvent extends TEventPublisher extends EventPublisher<any> ? ExtractPublisherMessage<TEventPublisher>['type'] | ExtractPublisherMessage<TEventPublisher>['type'][] : never>(event: TEvent): SubscriberBuilder<TServices, TLogger, OutSchema, TEventPublisher, TEvent extends any[] ? [...TSubscribedEvents, ...TEvent] : [...TSubscribedEvents, TEvent], TDatabase, TDatabaseServiceName>;
+  handle(fn: SubscriberHandler<TEventPublisher, TSubscribedEvents, TServices, TLogger, OutSchema, TDatabase>): Subscriber<TServices, TLogger, OutSchema, TEventPublisher, TSubscribedEvents, TDatabase, TDatabaseServiceName>;
+}
+//#endregion
+//#region src/subscribers/ObjectSubscriberBuilder.d.ts
+/**
+ * A subscriber bound to a bucket: a topic subscriber whose topic is the
+ * storage itself, so it runs through the same adaptors — Lambda, SNS push,
+ * a polled broker, a feature test.
+ */
+type ObjectSubscriber<TServices extends Service[] = [], TLogger extends Logger = Logger, OutSchema extends StandardSchemaV1 | undefined = undefined, TEvents extends ObjectEventType[] = ObjectEventType[], TDatabase = undefined, TDatabaseServiceName extends string = string> = Subscriber<TServices, TLogger, OutSchema, EventPublisher<ObjectMessage>, TEvents, TDatabase, TDatabaseServiceName>;
+/** What a bucket's subscriber is handed: the objects, and how each changed. */
+type ObjectSubscriberContext<TEvents extends ObjectEventType[], TServices extends Service[] = [], TLogger extends Logger = Logger, TDatabase = undefined> = {
+  /** Each object that changed, in the order the storage reported them. */
+  objects: ObjectEvent[];
+  /** The same objects with what happened to each — for a handler of both. */
+  events: ObjectMessage<TEvents[number]>[];
+  services: ServiceRecord<TServices>;
+  logger: TLogger;
+} & DatabaseContext<TDatabase>;
+type ObjectSubscriberHandler<TEvents extends ObjectEventType[], TServices extends Service[] = [], TLogger extends Logger = Logger, OutSchema extends StandardSchemaV1 | undefined = undefined, TDatabase = undefined> = (ctx: ObjectSubscriberContext<TEvents, TServices, TLogger, TDatabase>) => OutSchema extends StandardSchemaV1 ? InferStandardSchema<OutSchema> | Promise<InferStandardSchema<OutSchema>> : any | Promise<any>;
+/** `.on()` was given no event to react to. */
+declare class ObjectSubscriberHasNoEvents extends Error {
+  readonly bucket: string;
+  constructor(bucket: string);
+}
+/**
+ * A subscriber to a bucket's objects, from `worker.objects(bucket)`.
+ *
+ * Built on the topic subscriber's builder, which it wraps rather than
+ * extends: the services, database, owner and edges are configured exactly as
+ * a topic subscriber's, and only the trigger differs — the storage, filtered
+ * by event and key.
+ */
+declare class ObjectSubscriberBuilder<TServices extends Service[] = [], TLogger extends Logger = Logger, OutSchema extends StandardSchemaV1 | undefined = undefined, TEvents extends ObjectEventType[] = [], TDatabase = undefined, TDatabaseServiceName extends string = string> {
+  /** The topic subscriber's builder, already owned by its worker. */
+  private readonly inner;
+  /** The bucket's id — what the build binds the subscriber to. */
+  private readonly bucket;
+  private readonly events;
+  private readonly filter;
+  constructor(
+  /** The topic subscriber's builder, already owned by its worker. */
+  inner: SubscriberBuilder<any, any, any, any, any, any, any>,
+  /** The bucket's id — what the build binds the subscriber to. */
+  bucket: string, events?: readonly ObjectEventType[], filter?: ObjectFilter);
+  /**
+   * What it reacts to: the events, and — optionally — only keys under a
+   * prefix and ending in a suffix. Repeatable; the last filter wins.
+   */
+  on<const T extends ObjectEventType[]>(events: T, filter?: ObjectFilter): ObjectSubscriberBuilder<TServices, TLogger, OutSchema, [...TEvents, ...T], TDatabase, TDatabaseServiceName>;
+  /** See {@link SubscriberBuilder.dependsOn}. */
+  dependsOn<const T extends readonly Consumable[]>(constructs: T): ObjectSubscriberBuilder<[...TServices, ...ServicesOf<T>], TLogger, OutSchema, TEvents, TDatabase, TDatabaseServiceName>;
+  services<T extends Service[]>(services: T): ObjectSubscriberBuilder<[...TServices, ...T], TLogger, OutSchema, TEvents, TDatabase, TDatabaseServiceName>;
+  /** See {@link SubscriberBuilder.database}. */
+  database<T, TDbName extends string>(source: Consumable<TDbName, T> | Service<TDbName, T>): ObjectSubscriberBuilder<TServices, TLogger, OutSchema, TEvents, T, TDbName>;
+  timeout(timeout: number): this;
+  output<T extends StandardSchemaV1>(schema: T): ObjectSubscriberBuilder<TServices, TLogger, T, TEvents, TDatabase, TDatabaseServiceName>;
+  logger<T extends Logger>(logger: T): ObjectSubscriberBuilder<TServices, T, OutSchema, TEvents, TDatabase, TDatabaseServiceName>;
+  handle(fn: ObjectSubscriberHandler<TEvents, TServices, TLogger, OutSchema, TDatabase>): ObjectSubscriber<TServices, TLogger, OutSchema, TEvents, TDatabase, TDatabaseServiceName>;
+  private with;
+}
+//#endregion
+export { ObjectSubscriberHasNoEvents as a, ObjectSubscriberHandler as i, ObjectSubscriberBuilder as n, SubscriberBuilder as o, ObjectSubscriberContext as r, ObjectSubscriber as t };
+//# sourceMappingURL=ObjectSubscriberBuilder-l-64yUiF.d.cts.map

package/dist/ObjectSubscriberBuilder-l-64yUiF.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ObjectSubscriberBuilder-l-64yUiF.d.cts","names":[],"sources":["../src/subscribers/SubscriberBuilder.ts","../src/subscribers/ObjectSubscriberBuilder.ts"],"mappings":"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"}

package/dist/ProcessorBuilder-B2_stA8f.d.mts

@@ -0,0 +1,216 @@
+import { n as StandardSchemaV1 } from "./index-DdRjYhiJ.mjs";
+import { t as Construct } from "./Construct-DySlwh8o.mjs";
+import { c as ServicesOf, r as Consumable } from "./construct-interface-ZvYQbivO.mjs";
+import { DERIVED_PREFIX as DERIVED_PREFIX$1 } from "@geekmidas/manifest";
+import { StorageClient } from "@geekmidas/storage";
+import { Service, ServiceRecord } from "@geekmidas/services";
+import { Logger } from "@geekmidas/logger";
+import { InferStandardSchema } from "@geekmidas/schema";
+//#region src/processors/pattern.d.ts
+/**
+ * A processor's path pattern: literal segments, `:name` parameters, and a
+ * final `*` that is the object's key.
+ *
+ * ```
+ * /i/:width/*        →  /i/256/avatars/7.png   { width: '256' }, 'avatars/7.png'
+ * /pdf/:page/:dpi/*  →  /pdf/1/150/doc.pdf     { page: '1', dpi: '150' }, 'doc.pdf'
+ * ```
+ *
+ * It starts with a literal segment because the edge routes on that prefix: a
+ * pattern beginning with a parameter would claim every path on the file
+ * server, objects included.
+ */
+/** The parameter names a pattern declares, as a union. */
+type PatternParamNames<P extends string> = P extends `${string}/:${infer Name}/${infer Rest}` ? Name | PatternParamNames<`/${Rest}`> : never;
+/** The raw parameters a pattern matches, before its schema parses them. */
+type PatternParams<P extends string> = { [K in PatternParamNames<P>]: string; };
+/** A pattern a processor cannot be served on. */
+declare class ProcessorPatternInvalid extends Error {
+  readonly pattern: string;
+  readonly reason: string;
+  constructor(pattern: string, reason: string);
+}
+/** A pattern, parsed once. */
+interface ParsedPattern {
+  readonly pattern: string;
+  /** Each segment before the key: a literal, or a parameter's name. */
+  readonly segments: readonly ({
+    kind: 'literal';
+    value: string;
+  } | {
+    kind: 'param';
+    name: string;
+  })[];
+  /** The parameter names, in the order they appear. */
+  readonly params: readonly string[];
+  /** The literal path the edge routes on — `/i/`. */
+  readonly prefix: string;
+}
+/** @throws {ProcessorPatternInvalid} */
+declare function parsePattern(pattern: string): ParsedPattern;
+/** A path the pattern matched: its raw parameters and the key. */
+interface PatternMatch {
+  params: Record<string, string>;
+  key: string;
+}
+/**
+ * Match a request path, decoding each parameter and each key segment. A path
+ * with an empty key, or one that decodes to a `..` segment, matches nothing.
+ */
+declare function matchPattern(parsed: ParsedPattern, path: string): PatternMatch | undefined;
+/** The path that addresses `key` through the pattern with these parameters. */
+declare function fillPattern(parsed: ParsedPattern, params: Readonly<Record<string, string | number>>, key: string): string;
+/** A processed URL was asked for without one of the pattern's parameters. */
+declare class ProcessorParamMissing extends Error {
+  readonly pattern: string;
+  readonly param: string;
+  constructor(pattern: string, param: string);
+}
+//#endregion
+//#region src/processors/Processor.d.ts
+/** How long a response may be kept, by a browser and by the edge. */
+type ProcessorCache =
+/** Never changes for these parameters and this key: kept for a year. */
+'immutable' |
+/** Kept this many seconds. */
+{
+  maxAge: number;
+} |
+/** Not kept. */
+'none';
+/** What a processor handler returns. */
+interface ProcessorResult {
+  body: Uint8Array | string;
+  contentType: string;
+  /**
+   * `immutable` results are also kept in the bucket, so the next request
+   * for them never runs the handler. Defaults to an hour, kept nowhere.
+   */
+  cache?: ProcessorCache;
+}
+/** The object a request addresses, read from the bucket on first use. */
+interface SourceObject {
+  readonly key: string;
+  bytes(): Promise<Uint8Array>;
+  stream(): Promise<ReadableStream<Uint8Array>>;
+  /** The type it was stored with. */
+  contentType(): Promise<string | undefined>;
+}
+interface ProcessorContext<TParams, TServices extends Service[], TLogger extends Logger> {
+  params: TParams;
+  key: string;
+  object: SourceObject;
+  logger: TLogger;
+  services: ServiceRecord<TServices>;
+}
+type ProcessorHandler<TParams, TServices extends Service[], TLogger extends Logger> = (context: ProcessorContext<TParams, TServices, TLogger>) => Promise<ProcessorResult> | ProcessorResult;
+/** What a processor's parameters parse to: its schema's output, or the raw strings. */
+type ProcessorParams<TPattern extends string, TSchema extends StandardSchemaV1 | undefined> = TSchema extends StandardSchemaV1 ? InferStandardSchema<TSchema> : PatternParams<TPattern>;
+/**
+ * A processor — a handler behind one path pattern of a file server, which
+ * makes a derivative of an open object on read: a thumbnail, a page of a PDF.
+ *
+ * Built from the file server (`assets.process('/i/:width/*')`), so it carries
+ * the bucket it reads and the open paths it may serve. Its parameters' schema
+ * is the allowlist: a request outside it is refused before anything runs, so
+ * nobody can mint new work — or new cache entries — by varying a number.
+ */
+declare class Processor<TPattern extends string = string, TSchema extends StandardSchemaV1 | undefined = undefined, TServices extends Service[] = [], TLogger extends Logger = Logger> extends Construct<TLogger, undefined, TServices> {
+  readonly parsed: ParsedPattern;
+  readonly handler: ProcessorHandler<ProcessorParams<TPattern, TSchema>, TServices, TLogger>;
+  readonly options: {
+    /** The file server's surface id — the unit that runs it. */
+    surfaceId: string;
+    /** The bucket it reads from and keeps derivatives in. */
+    bucketId: string;
+    /** How it reaches that bucket. */
+    origin: Service<string, StorageClient>;
+    /** Whether a key is one of the file server's open paths. */
+    serves: (key: string) => boolean;
+    paramsSchema?: TSchema;
+    /** Packages with native code, installed for the target. */
+    native: readonly string[];
+    logger: TLogger;
+    services: TServices;
+    constructs: string[];
+    timeout?: number;
+    memorySize?: number;
+  };
+  __IS_PROCESSOR__: boolean;
+  static isProcessor(obj: unknown): obj is Processor<string, any, any, any>;
+  constructor(parsed: ParsedPattern, handler: ProcessorHandler<ProcessorParams<TPattern, TSchema>, TServices, TLogger>, options: {
+    /** The file server's surface id — the unit that runs it. */
+    surfaceId: string;
+    /** The bucket it reads from and keeps derivatives in. */
+    bucketId: string;
+    /** How it reaches that bucket. */
+    origin: Service<string, StorageClient>;
+    /** Whether a key is one of the file server's open paths. */
+    serves: (key: string) => boolean;
+    paramsSchema?: TSchema;
+    /** Packages with native code, installed for the target. */
+    native: readonly string[];
+    logger: TLogger;
+    services: TServices;
+    constructs: string[];
+    timeout?: number;
+    memorySize?: number;
+  });
+  /** The pattern it answers, as written. */
+  get pattern(): TPattern;
+  /** The literal path the edge routes to it — `/i/`. */
+  get prefix(): string;
+  get native(): readonly string[];
+  get surfaceId(): string;
+  get bucketId(): string;
+}
+//#endregion
+//#region src/processors/ProcessorBuilder.d.ts
+/** A native package named in a way no installer could resolve. */
+declare class ProcessorNativeInvalid extends Error {
+  readonly packageName: string;
+  constructor(packageName: string);
+}
+interface ProcessorBuilderState<TLogger extends Logger> {
+  parsed: ParsedPattern;
+  surfaceId: string;
+  bucketId: string;
+  origin: Service<string, StorageClient>;
+  serves: (key: string) => boolean;
+  logger: TLogger;
+  paramsSchema?: StandardSchemaV1;
+  native: string[];
+  services: Service[];
+  constructs: string[];
+  timeout?: number;
+  memorySize?: number;
+}
+/**
+ * What `fileServer.process(pattern)` returns: a processor, built up one
+ * immutable step at a time and finished by `.handle()`.
+ */
+declare class ProcessorBuilder<TPattern extends string, TSchema extends StandardSchemaV1 | undefined = undefined, TServices extends Service[] = [], TLogger extends Logger = Logger> {
+  private readonly state;
+  constructor(state: ProcessorBuilderState<TLogger>);
+  /**
+   * The parameters' schema — the allowlist. Every request is parsed by it
+   * before anything runs, and one it refuses is answered 400.
+   */
+  params<T extends StandardSchemaV1>(schema: T): ProcessorBuilder<TPattern, T, TServices, TLogger>;
+  /** Constructs its handler reaches, as `services.<id>`. */
+  dependsOn<const T extends readonly Consumable[]>(constructs: T): ProcessorBuilder<TPattern, TSchema, [...TServices, ...ServicesOf<T>], TLogger>;
+  /**
+   * Packages with native code — `sharp` — installed for the target the
+   * processor runs on rather than bundled: linux in its image, arm64 on
+   * Lambda.
+   */
+  native(packages: readonly string[]): this;
+  /** Milliseconds a request may take, where the target bounds it. */
+  timeout(ms: number): this;
+  /** Megabytes of memory, where the target sets it. */
+  memorySize(mb: number): this;
+  handle(fn: ProcessorHandler<ProcessorParams<TPattern, TSchema>, TServices, TLogger>): Processor<TPattern, TSchema, TServices, TLogger>;
+}
+//#endregion
+export { parsePattern as _, ProcessorCache as a, ProcessorParams as c, ParsedPattern as d, PatternParams as f, matchPattern as g, fillPattern as h, Processor as i, ProcessorResult as l, ProcessorPatternInvalid as m, ProcessorNativeInvalid as n, ProcessorContext as o, ProcessorParamMissing as p, DERIVED_PREFIX$1 as r, ProcessorHandler as s, ProcessorBuilder as t, SourceObject as u };
+//# sourceMappingURL=ProcessorBuilder-B2_stA8f.d.mts.map

package/dist/ProcessorBuilder-B2_stA8f.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProcessorBuilder-B2_stA8f.d.mts","names":[],"sources":["../src/processors/pattern.ts","../src/processors/Processor.ts","../src/processors/ProcessorBuilder.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;KAeY,kBAAkB,oBAC7B,8BAA8B,cAAc,SACzC,OAAO,sBAAsB;;KAIrB,cAAc,uBACxB,KAAK,kBAAkB;;cAIZ,gCAAgC;WAElC;WACA;EAFV,YACU,iBACA;;;UAYM;WACP;;WAEA;IACJ;IAAiB;;IACjB;IAAe;;;WAGX;;WAEA;;;iBAIM,aAAa,kBAAkB;;UAkE9B;EAChB,QAAQ;EACR;;;;;;iBAOe,aACf,QAAQ,eACR,eACE;;iBA0Ba,YACf,QAAQ,eACR,QAAQ,SAAS,kCACjB;;cAmBY,8BAA8B;WAEhC;WACA;EAFV,YACU,iBACA;;;;;KCtKC;;;;;EAIP;;;;;UAKY;EAChB,MAAM;EACN;;;;;EAKA,QAAQ;;;UAIQ;WACP;EACT,SAAS,QAAQ;EACjB,UAAU,QAAQ,eAAe;;EAEjC,eAAe;;UAGC,iBAChB,SACA,kBAAkB,WAClB,gBAAgB;EAEhB,QAAQ;EACR;EACA,QAAQ;EACR,QAAQ;EACR,UAAU,cAAc;;KAGb,iBACX,SACA,kBAAkB,WAClB,gBAAgB,WAEhB,SAAS,iBAAiB,SAAS,WAAW,aAC1C,QAAQ,mBAAmB;;KAGpB,gBACX,yBACA,gBAAgB,gCACb,gBAAgB,mBACjB,oBAAoB,WACpB,cAAc;;;;;;;;;;cAWJ,UACZ,kCACA,gBAAgB,0CAChB,kBAAkB,gBAClB,gBAAgB,SAAS,gBAChB,UAAU,oBAAoB;WAY7B,QAAQ;WACR,SAAS,iBACjB,gBAAgB,UAAU,UAC1B,WACA;WAEQ;;IAER;;IAEA;;IAEA,QAAQ,gBAAgB;;IAExB,SAAS;IACT,eAAe;;IAEf;IACA,QAAQ;IACR,UAAU;IACV;IACA;IACA;;EAjCF;SAEO,YAAY,eAAe,OAAO;EAQzC,YACU,QAAQ,eACR,SAAS,iBACjB,gBAAgB,UAAU,UAC1B,WACA,UAEQ;;IAER;;IAEA;;IAEA,QAAQ,gBAAgB;;IAExB,SAAS;IACT,eAAe;;IAEf;IACA,QAAQ;IACR,UAAU;IACV;IACA;IACA;;;MAsBE,WAAW;;MAKX;MAIA;MAIA;MAIA;;;;;cC/IQ,+BAA+B;WACtB;EAArB,YAAqB;;UAUZ,sBAAsB,gBAAgB;EAC/C,QAAQ;EACR;EACA;EACA,QAAQ,gBAAgB;EACxB,SAAS;EACT,QAAQ;EACR,eAAe;EACf;EACA,UAAU;EACV;EACA;EACA;;;;;;cAOY,iBACZ,yBACA,gBAAgB,0CAChB,kBAAkB,gBAClB,gBAAgB,SAAS;mBAEI;EAA7B,YAA6B,OAAO,sBAAsB;;;;;EAM1D,OAAO,UAAU,kBAChB,QAAQ,IACN,iBAAiB,UAAU,GAAG,WAAW;;EAK5C,gBAAgB,mBAAmB,cAClC,YAAY,IACV,iBACF,UACA,aACI,cAAc,WAAW,KAC7B;;;;;;EAqBD,OAAO;;EAaP,QAAQ;;EAKR,WAAW;EAIX,OACC,IAAI,iBACH,gBAAgB,UAAU,UAC1B,WACA,WAEC,UAAU,UAAU,SAAS,WAAW"}

package/dist/ProcessorBuilder-C62bIOwj.d.cts

@@ -0,0 +1,216 @@
+import { n as StandardSchemaV1 } from "./index-DdRjYhiJ.cjs";
+import { t as Construct } from "./Construct-127M7yrl.cjs";
+import { c as ServicesOf, r as Consumable } from "./construct-interface-B1AfqRl4.cjs";
+import { Logger } from "@geekmidas/logger";
+import { InferStandardSchema } from "@geekmidas/schema";
+import { Service, ServiceRecord } from "@geekmidas/services";
+import { DERIVED_PREFIX } from "@geekmidas/manifest";
+import { StorageClient } from "@geekmidas/storage";
+//#region src/processors/pattern.d.ts
+/**
+ * A processor's path pattern: literal segments, `:name` parameters, and a
+ * final `*` that is the object's key.
+ *
+ * ```
+ * /i/:width/*        →  /i/256/avatars/7.png   { width: '256' }, 'avatars/7.png'
+ * /pdf/:page/:dpi/*  →  /pdf/1/150/doc.pdf     { page: '1', dpi: '150' }, 'doc.pdf'
+ * ```
+ *
+ * It starts with a literal segment because the edge routes on that prefix: a
+ * pattern beginning with a parameter would claim every path on the file
+ * server, objects included.
+ */
+/** The parameter names a pattern declares, as a union. */
+type PatternParamNames<P extends string> = P extends `${string}/:${infer Name}/${infer Rest}` ? Name | PatternParamNames<`/${Rest}`> : never;
+/** The raw parameters a pattern matches, before its schema parses them. */
+type PatternParams<P extends string> = { [K in PatternParamNames<P>]: string; };
+/** A pattern a processor cannot be served on. */
+declare class ProcessorPatternInvalid extends Error {
+  readonly pattern: string;
+  readonly reason: string;
+  constructor(pattern: string, reason: string);
+}
+/** A pattern, parsed once. */
+interface ParsedPattern {
+  readonly pattern: string;
+  /** Each segment before the key: a literal, or a parameter's name. */
+  readonly segments: readonly ({
+    kind: 'literal';
+    value: string;
+  } | {
+    kind: 'param';
+    name: string;
+  })[];
+  /** The parameter names, in the order they appear. */
+  readonly params: readonly string[];
+  /** The literal path the edge routes on — `/i/`. */
+  readonly prefix: string;
+}
+/** @throws {ProcessorPatternInvalid} */
+declare function parsePattern(pattern: string): ParsedPattern;
+/** A path the pattern matched: its raw parameters and the key. */
+interface PatternMatch {
+  params: Record<string, string>;
+  key: string;
+}
+/**
+ * Match a request path, decoding each parameter and each key segment. A path
+ * with an empty key, or one that decodes to a `..` segment, matches nothing.
+ */
+declare function matchPattern(parsed: ParsedPattern, path: string): PatternMatch | undefined;
+/** The path that addresses `key` through the pattern with these parameters. */
+declare function fillPattern(parsed: ParsedPattern, params: Readonly<Record<string, string | number>>, key: string): string;
+/** A processed URL was asked for without one of the pattern's parameters. */
+declare class ProcessorParamMissing extends Error {
+  readonly pattern: string;
+  readonly param: string;
+  constructor(pattern: string, param: string);
+}
+//#endregion
+//#region src/processors/Processor.d.ts
+/** How long a response may be kept, by a browser and by the edge. */
+type ProcessorCache =
+/** Never changes for these parameters and this key: kept for a year. */
+'immutable' |
+/** Kept this many seconds. */
+{
+  maxAge: number;
+} |
+/** Not kept. */
+'none';
+/** What a processor handler returns. */
+interface ProcessorResult {
+  body: Uint8Array | string;
+  contentType: string;
+  /**
+   * `immutable` results are also kept in the bucket, so the next request
+   * for them never runs the handler. Defaults to an hour, kept nowhere.
+   */
+  cache?: ProcessorCache;
+}
+/** The object a request addresses, read from the bucket on first use. */
+interface SourceObject {
+  readonly key: string;
+  bytes(): Promise<Uint8Array>;
+  stream(): Promise<ReadableStream<Uint8Array>>;
+  /** The type it was stored with. */
+  contentType(): Promise<string | undefined>;
+}
+interface ProcessorContext<TParams, TServices extends Service[], TLogger extends Logger> {
+  params: TParams;
+  key: string;
+  object: SourceObject;
+  logger: TLogger;
+  services: ServiceRecord<TServices>;
+}
+type ProcessorHandler<TParams, TServices extends Service[], TLogger extends Logger> = (context: ProcessorContext<TParams, TServices, TLogger>) => Promise<ProcessorResult> | ProcessorResult;
+/** What a processor's parameters parse to: its schema's output, or the raw strings. */
+type ProcessorParams<TPattern extends string, TSchema extends StandardSchemaV1 | undefined> = TSchema extends StandardSchemaV1 ? InferStandardSchema<TSchema> : PatternParams<TPattern>;
+/**
+ * A processor — a handler behind one path pattern of a file server, which
+ * makes a derivative of an open object on read: a thumbnail, a page of a PDF.
+ *
+ * Built from the file server (`assets.process('/i/:width/*')`), so it carries
+ * the bucket it reads and the open paths it may serve. Its parameters' schema
+ * is the allowlist: a request outside it is refused before anything runs, so
+ * nobody can mint new work — or new cache entries — by varying a number.
+ */
+declare class Processor<TPattern extends string = string, TSchema extends StandardSchemaV1 | undefined = undefined, TServices extends Service[] = [], TLogger extends Logger = Logger> extends Construct<TLogger, undefined, TServices> {
+  readonly parsed: ParsedPattern;
+  readonly handler: ProcessorHandler<ProcessorParams<TPattern, TSchema>, TServices, TLogger>;
+  readonly options: {
+    /** The file server's surface id — the unit that runs it. */
+    surfaceId: string;
+    /** The bucket it reads from and keeps derivatives in. */
+    bucketId: string;
+    /** How it reaches that bucket. */
+    origin: Service<string, StorageClient>;
+    /** Whether a key is one of the file server's open paths. */
+    serves: (key: string) => boolean;
+    paramsSchema?: TSchema;
+    /** Packages with native code, installed for the target. */
+    native: readonly string[];
+    logger: TLogger;
+    services: TServices;
+    constructs: string[];
+    timeout?: number;
+    memorySize?: number;
+  };
+  __IS_PROCESSOR__: boolean;
+  static isProcessor(obj: unknown): obj is Processor<string, any, any, any>;
+  constructor(parsed: ParsedPattern, handler: ProcessorHandler<ProcessorParams<TPattern, TSchema>, TServices, TLogger>, options: {
+    /** The file server's surface id — the unit that runs it. */
+    surfaceId: string;
+    /** The bucket it reads from and keeps derivatives in. */
+    bucketId: string;
+    /** How it reaches that bucket. */
+    origin: Service<string, StorageClient>;
+    /** Whether a key is one of the file server's open paths. */
+    serves: (key: string) => boolean;
+    paramsSchema?: TSchema;
+    /** Packages with native code, installed for the target. */
+    native: readonly string[];
+    logger: TLogger;
+    services: TServices;
+    constructs: string[];
+    timeout?: number;
+    memorySize?: number;
+  });
+  /** The pattern it answers, as written. */
+  get pattern(): TPattern;
+  /** The literal path the edge routes to it — `/i/`. */
+  get prefix(): string;
+  get native(): readonly string[];
+  get surfaceId(): string;
+  get bucketId(): string;
+}
+//#endregion
+//#region src/processors/ProcessorBuilder.d.ts
+/** A native package named in a way no installer could resolve. */
+declare class ProcessorNativeInvalid extends Error {
+  readonly packageName: string;
+  constructor(packageName: string);
+}
+interface ProcessorBuilderState<TLogger extends Logger> {
+  parsed: ParsedPattern;
+  surfaceId: string;
+  bucketId: string;
+  origin: Service<string, StorageClient>;
+  serves: (key: string) => boolean;
+  logger: TLogger;
+  paramsSchema?: StandardSchemaV1;
+  native: string[];
+  services: Service[];
+  constructs: string[];
+  timeout?: number;
+  memorySize?: number;
+}
+/**
+ * What `fileServer.process(pattern)` returns: a processor, built up one
+ * immutable step at a time and finished by `.handle()`.
+ */
+declare class ProcessorBuilder<TPattern extends string, TSchema extends StandardSchemaV1 | undefined = undefined, TServices extends Service[] = [], TLogger extends Logger = Logger> {
+  private readonly state;
+  constructor(state: ProcessorBuilderState<TLogger>);
+  /**
+   * The parameters' schema — the allowlist. Every request is parsed by it
+   * before anything runs, and one it refuses is answered 400.
+   */
+  params<T extends StandardSchemaV1>(schema: T): ProcessorBuilder<TPattern, T, TServices, TLogger>;
+  /** Constructs its handler reaches, as `services.<id>`. */
+  dependsOn<const T extends readonly Consumable[]>(constructs: T): ProcessorBuilder<TPattern, TSchema, [...TServices, ...ServicesOf<T>], TLogger>;
+  /**
+   * Packages with native code — `sharp` — installed for the target the
+   * processor runs on rather than bundled: linux in its image, arm64 on
+   * Lambda.
+   */
+  native(packages: readonly string[]): this;
+  /** Milliseconds a request may take, where the target bounds it. */
+  timeout(ms: number): this;
+  /** Megabytes of memory, where the target sets it. */
+  memorySize(mb: number): this;
+  handle(fn: ProcessorHandler<ProcessorParams<TPattern, TSchema>, TServices, TLogger>): Processor<TPattern, TSchema, TServices, TLogger>;
+}
+//#endregion
+export { parsePattern as _, ProcessorCache as a, ProcessorParams as c, ParsedPattern as d, PatternParams as f, matchPattern as g, fillPattern as h, Processor as i, ProcessorResult as l, ProcessorPatternInvalid as m, ProcessorNativeInvalid as n, ProcessorContext as o, ProcessorParamMissing as p, DERIVED_PREFIX as r, ProcessorHandler as s, ProcessorBuilder as t, SourceObject as u };
+//# sourceMappingURL=ProcessorBuilder-C62bIOwj.d.cts.map

package/dist/ProcessorBuilder-C62bIOwj.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProcessorBuilder-C62bIOwj.d.cts","names":[],"sources":["../src/processors/pattern.ts","../src/processors/Processor.ts","../src/processors/ProcessorBuilder.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;KAeY,kBAAkB,oBAC7B,8BAA8B,cAAc,SACzC,OAAO,sBAAsB;;KAIrB,cAAc,uBACxB,KAAK,kBAAkB;;cAIZ,gCAAgC;WAElC;WACA;EAFV,YACU,iBACA;;;UAYM;WACP;;WAEA;IACJ;IAAiB;;IACjB;IAAe;;;WAGX;;WAEA;;;iBAIM,aAAa,kBAAkB;;UAkE9B;EAChB,QAAQ;EACR;;;;;;iBAOe,aACf,QAAQ,eACR,eACE;;iBA0Ba,YACf,QAAQ,eACR,QAAQ,SAAS,kCACjB;;cAmBY,8BAA8B;WAEhC;WACA;EAFV,YACU,iBACA;;;;;KCtKC;;;;;EAIP;;;;;UAKY;EAChB,MAAM;EACN;;;;;EAKA,QAAQ;;;UAIQ;WACP;EACT,SAAS,QAAQ;EACjB,UAAU,QAAQ,eAAe;;EAEjC,eAAe;;UAGC,iBAChB,SACA,kBAAkB,WAClB,gBAAgB;EAEhB,QAAQ;EACR;EACA,QAAQ;EACR,QAAQ;EACR,UAAU,cAAc;;KAGb,iBACX,SACA,kBAAkB,WAClB,gBAAgB,WAEhB,SAAS,iBAAiB,SAAS,WAAW,aAC1C,QAAQ,mBAAmB;;KAGpB,gBACX,yBACA,gBAAgB,gCACb,gBAAgB,mBACjB,oBAAoB,WACpB,cAAc;;;;;;;;;;cAWJ,UACZ,kCACA,gBAAgB,0CAChB,kBAAkB,gBAClB,gBAAgB,SAAS,gBAChB,UAAU,oBAAoB;WAY7B,QAAQ;WACR,SAAS,iBACjB,gBAAgB,UAAU,UAC1B,WACA;WAEQ;;IAER;;IAEA;;IAEA,QAAQ,gBAAgB;;IAExB,SAAS;IACT,eAAe;;IAEf;IACA,QAAQ;IACR,UAAU;IACV;IACA;IACA;;EAjCF;SAEO,YAAY,eAAe,OAAO;EAQzC,YACU,QAAQ,eACR,SAAS,iBACjB,gBAAgB,UAAU,UAC1B,WACA,UAEQ;;IAER;;IAEA;;IAEA,QAAQ,gBAAgB;;IAExB,SAAS;IACT,eAAe;;IAEf;IACA,QAAQ;IACR,UAAU;IACV;IACA;IACA;;;MAsBE,WAAW;;MAKX;MAIA;MAIA;MAIA;;;;;cC/IQ,+BAA+B;WACtB;EAArB,YAAqB;;UAUZ,sBAAsB,gBAAgB;EAC/C,QAAQ;EACR;EACA;EACA,QAAQ,gBAAgB;EACxB,SAAS;EACT,QAAQ;EACR,eAAe;EACf;EACA,UAAU;EACV;EACA;EACA;;;;;;cAOY,iBACZ,yBACA,gBAAgB,0CAChB,kBAAkB,gBAClB,gBAAgB,SAAS;mBAEI;EAA7B,YAA6B,OAAO,sBAAsB;;;;;EAM1D,OAAO,UAAU,kBAChB,QAAQ,IACN,iBAAiB,UAAU,GAAG,WAAW;;EAK5C,gBAAgB,mBAAmB,cAClC,YAAY,IACV,iBACF,UACA,aACI,cAAc,WAAW,KAC7B;;;;;;EAqBD,OAAO;;EAaP,QAAQ;;EAKR,WAAW;EAIX,OACC,IAAI,iBACH,gBAAgB,UAAU,UAC1B,WACA,WAEC,UAAU,UAAU,SAAS,WAAW"}

package/dist/{Queue-B-dDXyjF.d.mts → Queue-BnK3UH8r.d.mts}

@@ -1,6 +1,6 @@
 import { n as StandardSchemaV1 } from "./index-DdRjYhiJ.mjs";
-import { t as Construct } from "./Construct-B7AXn0xH.mjs";
-import { t as DatabaseContext } from "./Function-B_9R7Zy1.mjs";
+import { t as Construct } from "./Construct-DySlwh8o.mjs";
+import { t as DatabaseContext } from "./Function-DfMzTGS4.mjs";
 import { Declaration } from "@geekmidas/manifest";
 import { EventPublisher, PublishableMessage } from "@geekmidas/events";
 import { Service, ServiceRecord } from "@geekmidas/services";
@@ -102,4 +102,4 @@ type QueueContext<TMessage extends StandardSchemaV1, TServices extends Service[]
 type QueueHandler<TMessage extends StandardSchemaV1, TServices extends Service[] = [], TLogger extends Logger = Logger, TDatabase = undefined> = (ctx: QueueContext<TMessage, TServices, TLogger, TDatabase>) => unknown | Promise<unknown>;
 //#endregion
 export { QueueMessage as i, QueueContext as n, QueueHandler as r, Queue as t };
-//# sourceMappingURL=Queue-B-dDXyjF.d.mts.map
+//# sourceMappingURL=Queue-BnK3UH8r.d.mts.map

package/dist/{Queue-B-dDXyjF.d.mts.map → Queue-BnK3UH8r.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"Queue-B-dDXyjF.d.mts","names":[],"sources":["../src/queue/Queue.ts"],"mappings":";;;;;;;;;;;;;;;KA0BY,aACX,sBACA,iBAAiB,oBACd,mBAAmB,OAAO,oBAAoB;;;;;;;;;;;;;;cAerC,MACZ,+BACA,iBAAiB,mBAAmB,kBACpC,kBAAkB,gBAClB,gBAAgB,SAAS,QACzB,uBACA,sDACS,UACT,oBAEA,8BAGA,sBACA;WA8CiB,MAAM;WACN,SAAS,aACxB,UACA,WACA,SACA;WAEe,eAAe;WACN;WACA,UAAU;WACV,QAAQ;;WAEjB;;WAEA;EA1DjB;SAEO,QACN,eACE,OAAO,cAAc,kBAAkB,WAAW;;;;;;;;;WAgB5C;;;;;;;;;;;WAYA,SAAS,QACjB,aAAa,QACb,eAAe,aAAa,OAAO;;;;;mBAOnB;EAEjB,YACiB,MAAM,OACN,SAAS,aACxB,UACA,WACA,SACA,YAEe,eAAe,UACN,kBACA,WAAU,WACV,SAAQ,SAEjB;;EAAA,gCAEA;;EAAA,4BAKhB;;;;;EAAA,uBAKA;;;;;EAAA,kBAAkB,QAAQ,sBAAsB;;;;;;;;;EAyCjD,WAAW;;;;;;KA8BA,aACX,iBAAiB,kBACjB,kBAAkB,gBAClB,gBAAgB,SAAS,QACzB;EAEA,UAAU,oBAAoB;EAC9B,UAAU,cAAc;EACxB,QAAQ;IACL,gBAAgB;KAER,aACX,iBAAiB,kBACjB,kBAAkB,gBAClB,gBAAgB,SAAS,QACzB,0BAEA,KAAK,aAAa,UAAU,WAAW,SAAS,yBAClC"}
+{"version":3,"file":"Queue-BnK3UH8r.d.mts","names":[],"sources":["../src/queue/Queue.ts"],"mappings":";;;;;;;;;;;;;;;KA0BY,aACX,sBACA,iBAAiB,oBACd,mBAAmB,OAAO,oBAAoB;;;;;;;;;;;;;;cAerC,MACZ,+BACA,iBAAiB,mBAAmB,kBACpC,kBAAkB,gBAClB,gBAAgB,SAAS,QACzB,uBACA,sDACS,UACT,oBAEA,8BAGA,sBACA;WA8CiB,MAAM;WACN,SAAS,aACxB,UACA,WACA,SACA;WAEe,eAAe;WACN;WACA,UAAU;WACV,QAAQ;;WAEjB;;WAEA;EA1DjB;SAEO,QACN,eACE,OAAO,cAAc,kBAAkB,WAAW;;;;;;;;;WAgB5C;;;;;;;;;;;WAYA,SAAS,QACjB,aAAa,QACb,eAAe,aAAa,OAAO;;;;;mBAOnB;EAEjB,YACiB,MAAM,OACN,SAAS,aACxB,UACA,WACA,SACA,YAEe,eAAe,UACN,kBACA,WAAU,WACV,SAAQ,SAEjB;;EAAA,gCAEA;;EAAA,4BAKhB;;;;;EAAA,uBAKA;;;;;EAAA,kBAAkB,QAAQ,sBAAsB;;;;;;;;;EAyCjD,WAAW;;;;;;KA8BA,aACX,iBAAiB,kBACjB,kBAAkB,gBAClB,gBAAgB,SAAS,QACzB;EAEA,UAAU,oBAAoB;EAC9B,UAAU,cAAc;EACxB,QAAQ;IACL,gBAAgB;KAER,aACX,iBAAiB,kBACjB,kBAAkB,gBAClB,gBAAgB,SAAS,QACzB,0BAEA,KAAK,aAAa,UAAU,WAAW,SAAS,yBAClC"}

package/dist/{Queue-JbIjVtTf.d.cts → Queue-C4rijiM7.d.cts}

@@ -1,6 +1,6 @@
 import { n as StandardSchemaV1 } from "./index-DdRjYhiJ.cjs";
-import { t as Construct } from "./Construct-CFW0zjdD.cjs";
-import { t as DatabaseContext } from "./Function-B0uZhZnU.cjs";
+import { t as Construct } from "./Construct-127M7yrl.cjs";
+import { t as DatabaseContext } from "./Function-BIEsY0Hm.cjs";
 import { Logger } from "@geekmidas/logger";
 import { InferStandardSchema } from "@geekmidas/schema";
 import { Service, ServiceRecord } from "@geekmidas/services";
@@ -102,4 +102,4 @@ type QueueContext<TMessage extends StandardSchemaV1, TServices extends Service[]
 type QueueHandler<TMessage extends StandardSchemaV1, TServices extends Service[] = [], TLogger extends Logger = Logger, TDatabase = undefined> = (ctx: QueueContext<TMessage, TServices, TLogger, TDatabase>) => unknown | Promise<unknown>;
 //#endregion
 export { QueueMessage as i, QueueContext as n, QueueHandler as r, Queue as t };
-//# sourceMappingURL=Queue-JbIjVtTf.d.cts.map
+//# sourceMappingURL=Queue-C4rijiM7.d.cts.map

package/dist/{Queue-JbIjVtTf.d.cts.map → Queue-C4rijiM7.d.cts.map}

@@ -1 +1 @@
-{"version":3,"file":"Queue-JbIjVtTf.d.cts","names":[],"sources":["../src/queue/Queue.ts"],"mappings":";;;;;;;;;;;;;;;KA0BY,aACX,sBACA,iBAAiB,oBACd,mBAAmB,OAAO,oBAAoB;;;;;;;;;;;;;;cAerC,MACZ,+BACA,iBAAiB,mBAAmB,kBACpC,kBAAkB,gBAClB,gBAAgB,SAAS,QACzB,uBACA,sDACS,UACT,oBAEA,8BAGA,sBACA;WA8CiB,MAAM;WACN,SAAS,aACxB,UACA,WACA,SACA;WAEe,eAAe;WACN;WACA,UAAU;WACV,QAAQ;;WAEjB;;WAEA;EA1DjB;SAEO,QACN,eACE,OAAO,cAAc,kBAAkB,WAAW;;;;;;;;;WAgB5C;;;;;;;;;;;WAYA,SAAS,QACjB,aAAa,QACb,eAAe,aAAa,OAAO;;;;;mBAOnB;EAEjB,YACiB,MAAM,OACN,SAAS,aACxB,UACA,WACA,SACA,YAEe,eAAe,UACN,kBACA,WAAU,WACV,SAAQ,SAEjB;;EAAA,gCAEA;;EAAA,4BAKhB;;;;;EAAA,uBAKA;;;;;EAAA,kBAAkB,QAAQ,sBAAsB;;;;;;;;;EAyCjD,WAAW;;;;;;KA8BA,aACX,iBAAiB,kBACjB,kBAAkB,gBAClB,gBAAgB,SAAS,QACzB;EAEA,UAAU,oBAAoB;EAC9B,UAAU,cAAc;EACxB,QAAQ;IACL,gBAAgB;KAER,aACX,iBAAiB,kBACjB,kBAAkB,gBAClB,gBAAgB,SAAS,QACzB,0BAEA,KAAK,aAAa,UAAU,WAAW,SAAS,yBAClC"}
+{"version":3,"file":"Queue-C4rijiM7.d.cts","names":[],"sources":["../src/queue/Queue.ts"],"mappings":";;;;;;;;;;;;;;;KA0BY,aACX,sBACA,iBAAiB,oBACd,mBAAmB,OAAO,oBAAoB;;;;;;;;;;;;;;cAerC,MACZ,+BACA,iBAAiB,mBAAmB,kBACpC,kBAAkB,gBAClB,gBAAgB,SAAS,QACzB,uBACA,sDACS,UACT,oBAEA,8BAGA,sBACA;WA8CiB,MAAM;WACN,SAAS,aACxB,UACA,WACA,SACA;WAEe,eAAe;WACN;WACA,UAAU;WACV,QAAQ;;WAEjB;;WAEA;EA1DjB;SAEO,QACN,eACE,OAAO,cAAc,kBAAkB,WAAW;;;;;;;;;WAgB5C;;;;;;;;;;;WAYA,SAAS,QACjB,aAAa,QACb,eAAe,aAAa,OAAO;;;;;mBAOnB;EAEjB,YACiB,MAAM,OACN,SAAS,aACxB,UACA,WACA,SACA,YAEe,eAAe,UACN,kBACA,WAAU,WACV,SAAQ,SAEjB;;EAAA,gCAEA;;EAAA,4BAKhB;;;;;EAAA,uBAKA;;;;;EAAA,kBAAkB,QAAQ,sBAAsB;;;;;;;;;EAyCjD,WAAW;;;;;;KA8BA,aACX,iBAAiB,kBACjB,kBAAkB,gBAClB,gBAAgB,SAAS,QACzB;EAEA,UAAU,oBAAoB;EAC9B,UAAU,cAAc;EACxB,QAAQ;IACL,gBAAgB;KAER,aACX,iBAAiB,kBACjB,kBAAkB,gBAClB,gBAAgB,SAAS,QACzB,0BAEA,KAAK,aAAa,UAAU,WAAW,SAAS,yBAClC"}

package/dist/{Queue-BhuofM3k.cjs → Queue-D4Iaidrs.cjs}

@@ -1,7 +1,7 @@
-const require_Construct = require("./Construct-DEOVauyA.cjs");
+const require_Construct = require("./Construct-DorKS0Ua.cjs");
 let _geekmidas_manifest = require("@geekmidas/manifest");
-let _geekmidas_events = require("@geekmidas/events");
 let _geekmidas_logger_console = require("@geekmidas/logger/console");
+let _geekmidas_events = require("@geekmidas/events");
 //#region src/queue/Queue.ts
 /**
 * A queue worker — a point-to-point SQS-style queue and its single consumer.
@@ -106,4 +106,4 @@ Object.defineProperty(exports, "Queue", {
 	}
 });
 
-//# sourceMappingURL=Queue-BhuofM3k.cjs.map
+//# sourceMappingURL=Queue-D4Iaidrs.cjs.map