@nest-batch/core 0.2.0

package/dist/src/decorators/flow.decorator.d.ts

@@ -0,0 +1,25 @@
+import 'reflect-metadata';
+import type { FlowExecutionStatus } from '../core/status';
+export interface OnTransitionOptions {
+    fromStep: string;
+    onStatus: FlowExecutionStatus | string;
+    toStep: string | null;
+}
+/**
+ * Declarative flow transition. The decorated method is a marker; the
+ * compiler reads its metadata to build a `TransitionDefinition`.
+ *
+ * Usage:
+ * ```typescript
+ * @Jobable({ id: 'my-job' })
+ * class MyJob {
+ *   @Stepable({ id: 'step1' }) @Tasklet() async step1() {}
+ *   @Stepable({ id: 'recovery' }) @Tasklet() async recovery() {}
+ *
+ *   @OnTransition({ fromStep: 'step1', onStatus: 'FAILED', toStep: 'recovery' })
+ *   onFail() {}
+ * }
+ * ```
+ */
+export declare function OnTransition(options: OnTransitionOptions): MethodDecorator;
+//# sourceMappingURL=flow.decorator.d.ts.map

package/dist/src/decorators/flow.decorator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flow.decorator.d.ts","sourceRoot":"","sources":["../../../src/decorators/flow.decorator.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC;AAE1B,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAE1D,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,mBAAmB,GAAG,MAAM,CAAC;IACvC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;CACvB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,mBAAmB,GAAG,eAAe,CAI1E"}

package/dist/src/decorators/flow.decorator.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "OnTransition", {
+    enumerable: true,
+    get: function() {
+        return OnTransition;
+    }
+});
+require("reflect-metadata");
+const _constants = require("./constants");
+function OnTransition(options) {
+    return (target, propertyKey, _descriptor)=>{
+        Reflect.defineMetadata(_constants.BATCH_TRANSITION_METADATA, options, target, propertyKey);
+    };
+}
+
+//# sourceMappingURL=flow.decorator.js.map

package/dist/src/decorators/flow.decorator.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/decorators/flow.decorator.ts"],"sourcesContent":["import 'reflect-metadata';\nimport { BATCH_TRANSITION_METADATA } from './constants';\nimport type { FlowExecutionStatus } from '../core/status';\n\nexport interface OnTransitionOptions {\n  fromStep: string;\n  onStatus: FlowExecutionStatus | string; // string allowed for enum name lookup\n  toStep: string | null;\n}\n\n/**\n * Declarative flow transition. The decorated method is a marker; the\n * compiler reads its metadata to build a `TransitionDefinition`.\n *\n * Usage:\n * ```typescript\n * @Jobable({ id: 'my-job' })\n * class MyJob {\n *   @Stepable({ id: 'step1' }) @Tasklet() async step1() {}\n *   @Stepable({ id: 'recovery' }) @Tasklet() async recovery() {}\n *\n *   @OnTransition({ fromStep: 'step1', onStatus: 'FAILED', toStep: 'recovery' })\n *   onFail() {}\n * }\n * ```\n */\nexport function OnTransition(options: OnTransitionOptions): MethodDecorator {\n  return (target: object, propertyKey: string | symbol, _descriptor: PropertyDescriptor) => {\n    Reflect.defineMetadata(BATCH_TRANSITION_METADATA, options, target, propertyKey);\n  };\n}\n"],"names":["OnTransition","options","target","propertyKey","_descriptor","Reflect","defineMetadata","BATCH_TRANSITION_METADATA"],"mappings":";;;;+BA0BgBA;;;eAAAA;;;QA1BT;2BACmC;AAyBnC,SAASA,aAAaC,OAA4B;IACvD,OAAO,CAACC,QAAgBC,aAA8BC;QACpDC,QAAQC,cAAc,CAACC,oCAAyB,EAAEN,SAASC,QAAQC;IACrE;AACF"}

package/dist/src/decorators/index.d.ts

@@ -0,0 +1,8 @@
+export * from './constants';
+export * from './job.decorator';
+export * from './step.decorator';
+export * from './tasklet.decorator';
+export * from './item.decorators';
+export * from './listener.decorators';
+export * from './flow.decorator';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/decorators/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/decorators/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC;AACjC,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,kBAAkB,CAAC"}

package/dist/src/decorators/index.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./constants"), exports);
+_export_star(require("./job.decorator"), exports);
+_export_star(require("./step.decorator"), exports);
+_export_star(require("./tasklet.decorator"), exports);
+_export_star(require("./item.decorators"), exports);
+_export_star(require("./listener.decorators"), exports);
+_export_star(require("./flow.decorator"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}
+
+//# sourceMappingURL=index.js.map

package/dist/src/decorators/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/decorators/index.ts"],"sourcesContent":["export * from './constants';\nexport * from './job.decorator';\nexport * from './step.decorator';\nexport * from './tasklet.decorator';\nexport * from './item.decorators';\nexport * from './listener.decorators';\nexport * from './flow.decorator';\n"],"names":[],"mappings":";;;;qBAAc;qBACA;qBACA;qBACA;qBACA;qBACA;qBACA"}

package/dist/src/decorators/item.decorators.d.ts

@@ -0,0 +1,32 @@
+import 'reflect-metadata';
+/**
+ * Marks a method as the `ItemReader.read()` handler for a chunk step.
+ *
+ * Contract:
+ *   - Method may return `Promise<T | null>` (null = EOF) OR
+ *     `AsyncIterable<T>` for streaming-style readers.
+ *   - Exactly one `@ItemReader()` per chunk step.
+ *   - Metadata stored on the prototype method under `BATCH_ITEM_READER_METADATA`
+ *     so the DefinitionCompiler can resolve it to a `ReaderRef`.
+ */
+export declare function ItemReader(): MethodDecorator;
+/**
+ * Marks a method as the `ItemProcessor.process(item)` handler for a chunk step.
+ *
+ * Contract:
+ *   - Receives a single item, returns the (possibly transformed) item.
+ *   - Returning `null` or `undefined` filters the item out of the chunk.
+ *   - Exactly one `@ItemProcessor()` per chunk step (or none — processor is optional).
+ *   - Metadata stored on the prototype method under `BATCH_ITEM_PROCESSOR_METADATA`.
+ */
+export declare function ItemProcessor(): MethodDecorator;
+/**
+ * Marks a method as the `ItemWriter.write(items)` handler for a chunk step.
+ *
+ * Contract:
+ *   - Receives an array of items for the chunk, returns `Promise<void>`.
+ *   - Exactly one `@ItemWriter()` per chunk step.
+ *   - Metadata stored on the prototype method under `BATCH_ITEM_WRITER_METADATA`.
+ */
+export declare function ItemWriter(): MethodDecorator;
+//# sourceMappingURL=item.decorators.d.ts.map

package/dist/src/decorators/item.decorators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"item.decorators.d.ts","sourceRoot":"","sources":["../../../src/decorators/item.decorators.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC;AAO1B;;;;;;;;;GASG;AACH,wBAAgB,UAAU,IAAI,eAAe,CAI5C;AAED;;;;;;;;GAQG;AACH,wBAAgB,aAAa,IAAI,eAAe,CAI/C;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,IAAI,eAAe,CAI5C"}

package/dist/src/decorators/item.decorators.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get ItemProcessor () {
+        return ItemProcessor;
+    },
+    get ItemReader () {
+        return ItemReader;
+    },
+    get ItemWriter () {
+        return ItemWriter;
+    }
+});
+require("reflect-metadata");
+const _constants = require("./constants");
+function ItemReader() {
+    return (target, propertyKey, _descriptor)=>{
+        Reflect.defineMetadata(_constants.BATCH_ITEM_READER_METADATA, true, target, propertyKey);
+    };
+}
+function ItemProcessor() {
+    return (target, propertyKey, _descriptor)=>{
+        Reflect.defineMetadata(_constants.BATCH_ITEM_PROCESSOR_METADATA, true, target, propertyKey);
+    };
+}
+function ItemWriter() {
+    return (target, propertyKey, _descriptor)=>{
+        Reflect.defineMetadata(_constants.BATCH_ITEM_WRITER_METADATA, true, target, propertyKey);
+    };
+}
+
+//# sourceMappingURL=item.decorators.js.map

package/dist/src/decorators/item.decorators.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/decorators/item.decorators.ts"],"sourcesContent":["import 'reflect-metadata';\nimport {\n  BATCH_ITEM_READER_METADATA,\n  BATCH_ITEM_PROCESSOR_METADATA,\n  BATCH_ITEM_WRITER_METADATA,\n} from './constants';\n\n/**\n * Marks a method as the `ItemReader.read()` handler for a chunk step.\n *\n * Contract:\n *   - Method may return `Promise<T | null>` (null = EOF) OR\n *     `AsyncIterable<T>` for streaming-style readers.\n *   - Exactly one `@ItemReader()` per chunk step.\n *   - Metadata stored on the prototype method under `BATCH_ITEM_READER_METADATA`\n *     so the DefinitionCompiler can resolve it to a `ReaderRef`.\n */\nexport function ItemReader(): MethodDecorator {\n  return (target: object, propertyKey: string | symbol, _descriptor: PropertyDescriptor) => {\n    Reflect.defineMetadata(BATCH_ITEM_READER_METADATA, true, target, propertyKey);\n  };\n}\n\n/**\n * Marks a method as the `ItemProcessor.process(item)` handler for a chunk step.\n *\n * Contract:\n *   - Receives a single item, returns the (possibly transformed) item.\n *   - Returning `null` or `undefined` filters the item out of the chunk.\n *   - Exactly one `@ItemProcessor()` per chunk step (or none — processor is optional).\n *   - Metadata stored on the prototype method under `BATCH_ITEM_PROCESSOR_METADATA`.\n */\nexport function ItemProcessor(): MethodDecorator {\n  return (target: object, propertyKey: string | symbol, _descriptor: PropertyDescriptor) => {\n    Reflect.defineMetadata(BATCH_ITEM_PROCESSOR_METADATA, true, target, propertyKey);\n  };\n}\n\n/**\n * Marks a method as the `ItemWriter.write(items)` handler for a chunk step.\n *\n * Contract:\n *   - Receives an array of items for the chunk, returns `Promise<void>`.\n *   - Exactly one `@ItemWriter()` per chunk step.\n *   - Metadata stored on the prototype method under `BATCH_ITEM_WRITER_METADATA`.\n */\nexport function ItemWriter(): MethodDecorator {\n  return (target: object, propertyKey: string | symbol, _descriptor: PropertyDescriptor) => {\n    Reflect.defineMetadata(BATCH_ITEM_WRITER_METADATA, true, target, propertyKey);\n  };\n}\n"],"names":["ItemProcessor","ItemReader","ItemWriter","target","propertyKey","_descriptor","Reflect","defineMetadata","BATCH_ITEM_READER_METADATA","BATCH_ITEM_PROCESSOR_METADATA","BATCH_ITEM_WRITER_METADATA"],"mappings":";;;;;;;;;;;QAgCgBA;eAAAA;;QAfAC;eAAAA;;QA6BAC;eAAAA;;;QA9CT;2BAKA;AAYA,SAASD;IACd,OAAO,CAACE,QAAgBC,aAA8BC;QACpDC,QAAQC,cAAc,CAACC,qCAA0B,EAAE,MAAML,QAAQC;IACnE;AACF;AAWO,SAASJ;IACd,OAAO,CAACG,QAAgBC,aAA8BC;QACpDC,QAAQC,cAAc,CAACE,wCAA6B,EAAE,MAAMN,QAAQC;IACtE;AACF;AAUO,SAASF;IACd,OAAO,CAACC,QAAgBC,aAA8BC;QACpDC,QAAQC,cAAc,CAACG,qCAA0B,EAAE,MAAMP,QAAQC;IACnE;AACF"}

package/dist/src/decorators/job.decorator.d.ts

@@ -0,0 +1,11 @@
+export interface JobableOptions {
+    id: string;
+    restartable?: boolean;
+    allowDuplicateInstances?: boolean;
+}
+/**
+ * Class decorator that marks a class as a batch job.
+ * Metadata: { id, restartable, allowDuplicateInstances }
+ */
+export declare function Jobable(options: JobableOptions): ClassDecorator;
+//# sourceMappingURL=job.decorator.d.ts.map

package/dist/src/decorators/job.decorator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"job.decorator.d.ts","sourceRoot":"","sources":["../../../src/decorators/job.decorator.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,uBAAuB,CAAC,EAAE,OAAO,CAAC;CACnC;AAED;;;GAGG;AACH,wBAAgB,OAAO,CAAC,OAAO,EAAE,cAAc,GAAG,cAAc,CAE/D"}

package/dist/src/decorators/job.decorator.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Jobable", {
+    enumerable: true,
+    get: function() {
+        return Jobable;
+    }
+});
+const _common = require("@nestjs/common");
+const _constants = require("./constants");
+function Jobable(options) {
+    return (0, _common.SetMetadata)(_constants.BATCH_JOB_METADATA, options);
+}
+
+//# sourceMappingURL=job.decorator.js.map

package/dist/src/decorators/job.decorator.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/decorators/job.decorator.ts"],"sourcesContent":["import { SetMetadata } from '@nestjs/common';\nimport { BATCH_JOB_METADATA } from './constants';\n\nexport interface JobableOptions {\n  id: string;\n  restartable?: boolean;\n  allowDuplicateInstances?: boolean;\n}\n\n/**\n * Class decorator that marks a class as a batch job.\n * Metadata: { id, restartable, allowDuplicateInstances }\n */\nexport function Jobable(options: JobableOptions): ClassDecorator {\n  return SetMetadata(BATCH_JOB_METADATA, options);\n}\n"],"names":["Jobable","options","SetMetadata","BATCH_JOB_METADATA"],"mappings":";;;;+BAagBA;;;eAAAA;;;wBAbY;2BACO;AAY5B,SAASA,QAAQC,OAAuB;IAC7C,OAAOC,IAAAA,mBAAW,EAACC,6BAAkB,EAAEF;AACzC"}

package/dist/src/decorators/listener.decorators.d.ts

@@ -0,0 +1,56 @@
+import 'reflect-metadata';
+import type { ListenerKind, ListenerPhase } from '../core/ir/listener-definition';
+/**
+ * Stored under `BATCH_LISTENER_METADATA` for each listener method.
+ * Mirrors `ListenerDefinition` minus the resolved `ref` (which the
+ * DefinitionCompiler fills in by walking the class).
+ *
+ * The `skip` kind is special: it has no before/after/on-error phase,
+ * it is a single fire-and-forget callback per skip event. We record
+ * `phase: 'after'` as a placeholder so the metadata shape stays uniform;
+ * the skip dispatch table is built in Task 25.
+ */
+export interface ListenerOptions {
+    kind: ListenerKind;
+    phase: ListenerPhase;
+    nonCritical?: boolean;
+}
+/** Fires before a job execution starts. */
+export declare const BeforeJob: () => MethodDecorator;
+/** Fires after a job execution finishes (regardless of status). */
+export declare const AfterJob: () => MethodDecorator;
+/** Fires before a step execution starts. */
+export declare const BeforeStep: () => MethodDecorator;
+/** Fires after a step execution finishes (regardless of status). */
+export declare const AfterStep: () => MethodDecorator;
+/** Fires before each chunk (read-process-write cycle) starts. */
+export declare const BeforeChunk: () => MethodDecorator;
+/** Fires after each chunk finishes successfully. */
+export declare const AfterChunk: () => MethodDecorator;
+/** Fires when a chunk throws (allows rollback hooks / telemetry). */
+export declare const OnChunkError: () => MethodDecorator;
+/** Fires before each item is read. */
+export declare const BeforeRead: () => MethodDecorator;
+/** Fires after each item is successfully read. */
+export declare const AfterRead: () => MethodDecorator;
+/** Fires when the reader throws. */
+export declare const OnReadError: () => MethodDecorator;
+/** Fires before each item is processed. */
+export declare const BeforeProcess: () => MethodDecorator;
+/** Fires after each item is successfully processed. */
+export declare const AfterProcess: () => MethodDecorator;
+/** Fires when the processor throws. */
+export declare const OnProcessError: () => MethodDecorator;
+/** Fires before the writer receives a chunk. */
+export declare const BeforeWrite: () => MethodDecorator;
+/** Fires after the writer successfully writes a chunk. */
+export declare const AfterWrite: () => MethodDecorator;
+/** Fires when the writer throws. */
+export declare const OnWriteError: () => MethodDecorator;
+/** Fires when a read is skipped (after the skip policy decides to skip). */
+export declare const OnSkipRead: () => MethodDecorator;
+/** Fires when a processed item is skipped. */
+export declare const OnSkipProcess: () => MethodDecorator;
+/** Fires when a write is skipped. */
+export declare const OnSkipWrite: () => MethodDecorator;
+//# sourceMappingURL=listener.decorators.d.ts.map

package/dist/src/decorators/listener.decorators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"listener.decorators.d.ts","sourceRoot":"","sources":["../../../src/decorators/listener.decorators.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC;AAE1B,OAAO,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAElF;;;;;;;;;GASG;AACH,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,YAAY,CAAC;IACnB,KAAK,EAAE,aAAa,CAAC;IACrB,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAoBD,2CAA2C;AAC3C,eAAO,MAAM,SAAS,QAAO,eACwB,CAAC;AAEtD,mEAAmE;AACnE,eAAO,MAAM,QAAQ,QAAO,eACwB,CAAC;AAMrD,4CAA4C;AAC5C,eAAO,MAAM,UAAU,QAAO,eACwB,CAAC;AAEvD,oEAAoE;AACpE,eAAO,MAAM,SAAS,QAAO,eACwB,CAAC;AAMtD,iEAAiE;AACjE,eAAO,MAAM,WAAW,QAAO,eACwB,CAAC;AAExD,oDAAoD;AACpD,eAAO,MAAM,UAAU,QAAO,eACwB,CAAC;AAEvD,qEAAqE;AACrE,eAAO,MAAM,YAAY,QAAO,eACyB,CAAC;AAM1D,sCAAsC;AACtC,eAAO,MAAM,UAAU,QAAO,eAC6B,CAAC;AAE5D,kDAAkD;AAClD,eAAO,MAAM,SAAS,QAAO,eAC6B,CAAC;AAE3D,oCAAoC;AACpC,eAAO,MAAM,WAAW,QAAO,eAC8B,CAAC;AAM9D,2CAA2C;AAC3C,eAAO,MAAM,aAAa,QAAO,eAC6B,CAAC;AAE/D,uDAAuD;AACvD,eAAO,MAAM,YAAY,QAAO,eAC6B,CAAC;AAE9D,uCAAuC;AACvC,eAAO,MAAM,cAAc,QAAO,eAC8B,CAAC;AAMjE,gDAAgD;AAChD,eAAO,MAAM,WAAW,QAAO,eAC6B,CAAC;AAE7D,0DAA0D;AAC1D,eAAO,MAAM,UAAU,QAAO,eAC6B,CAAC;AAE5D,oCAAoC;AACpC,eAAO,MAAM,YAAY,QAAO,eAC8B,CAAC;AAW/D,4EAA4E;AAC5E,eAAO,MAAM,UAAU,QAAO,eACuB,CAAC;AAEtD,8CAA8C;AAC9C,eAAO,MAAM,aAAa,QAAO,eACoB,CAAC;AAEtD,qCAAqC;AACrC,eAAO,MAAM,WAAW,QAAO,eACsB,CAAC"}

package/dist/src/decorators/listener.decorators.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get AfterChunk () {
+        return AfterChunk;
+    },
+    get AfterJob () {
+        return AfterJob;
+    },
+    get AfterProcess () {
+        return AfterProcess;
+    },
+    get AfterRead () {
+        return AfterRead;
+    },
+    get AfterStep () {
+        return AfterStep;
+    },
+    get AfterWrite () {
+        return AfterWrite;
+    },
+    get BeforeChunk () {
+        return BeforeChunk;
+    },
+    get BeforeJob () {
+        return BeforeJob;
+    },
+    get BeforeProcess () {
+        return BeforeProcess;
+    },
+    get BeforeRead () {
+        return BeforeRead;
+    },
+    get BeforeStep () {
+        return BeforeStep;
+    },
+    get BeforeWrite () {
+        return BeforeWrite;
+    },
+    get OnChunkError () {
+        return OnChunkError;
+    },
+    get OnProcessError () {
+        return OnProcessError;
+    },
+    get OnReadError () {
+        return OnReadError;
+    },
+    get OnSkipProcess () {
+        return OnSkipProcess;
+    },
+    get OnSkipRead () {
+        return OnSkipRead;
+    },
+    get OnSkipWrite () {
+        return OnSkipWrite;
+    },
+    get OnWriteError () {
+        return OnWriteError;
+    }
+});
+require("reflect-metadata");
+const _constants = require("./constants");
+function defineListener(target, propertyKey, options) {
+    Reflect.defineMetadata(_constants.BATCH_LISTENER_METADATA, options, target, propertyKey);
+}
+function listenerDecorator(options) {
+    return (target, propertyKey, _descriptor)=>{
+        defineListener(target, propertyKey, options);
+    };
+}
+const BeforeJob = ()=>listenerDecorator({
+        kind: 'job',
+        phase: 'before'
+    });
+const AfterJob = ()=>listenerDecorator({
+        kind: 'job',
+        phase: 'after'
+    });
+const BeforeStep = ()=>listenerDecorator({
+        kind: 'step',
+        phase: 'before'
+    });
+const AfterStep = ()=>listenerDecorator({
+        kind: 'step',
+        phase: 'after'
+    });
+const BeforeChunk = ()=>listenerDecorator({
+        kind: 'chunk',
+        phase: 'before'
+    });
+const AfterChunk = ()=>listenerDecorator({
+        kind: 'chunk',
+        phase: 'after'
+    });
+const OnChunkError = ()=>listenerDecorator({
+        kind: 'chunk',
+        phase: 'on-error'
+    });
+const BeforeRead = ()=>listenerDecorator({
+        kind: 'item-read',
+        phase: 'before'
+    });
+const AfterRead = ()=>listenerDecorator({
+        kind: 'item-read',
+        phase: 'after'
+    });
+const OnReadError = ()=>listenerDecorator({
+        kind: 'item-read',
+        phase: 'on-error'
+    });
+const BeforeProcess = ()=>listenerDecorator({
+        kind: 'item-process',
+        phase: 'before'
+    });
+const AfterProcess = ()=>listenerDecorator({
+        kind: 'item-process',
+        phase: 'after'
+    });
+const OnProcessError = ()=>listenerDecorator({
+        kind: 'item-process',
+        phase: 'on-error'
+    });
+const BeforeWrite = ()=>listenerDecorator({
+        kind: 'item-write',
+        phase: 'before'
+    });
+const AfterWrite = ()=>listenerDecorator({
+        kind: 'item-write',
+        phase: 'after'
+    });
+const OnWriteError = ()=>listenerDecorator({
+        kind: 'item-write',
+        phase: 'on-error'
+    });
+const OnSkipRead = ()=>listenerDecorator({
+        kind: 'skip',
+        phase: 'after'
+    });
+const OnSkipProcess = ()=>listenerDecorator({
+        kind: 'skip',
+        phase: 'after'
+    });
+const OnSkipWrite = ()=>listenerDecorator({
+        kind: 'skip',
+        phase: 'after'
+    });
+
+//# sourceMappingURL=listener.decorators.js.map

package/dist/src/decorators/listener.decorators.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/decorators/listener.decorators.ts"],"sourcesContent":["import 'reflect-metadata';\nimport { BATCH_LISTENER_METADATA } from './constants';\nimport type { ListenerKind, ListenerPhase } from '../core/ir/listener-definition';\n\n/**\n * Stored under `BATCH_LISTENER_METADATA` for each listener method.\n * Mirrors `ListenerDefinition` minus the resolved `ref` (which the\n * DefinitionCompiler fills in by walking the class).\n *\n * The `skip` kind is special: it has no before/after/on-error phase,\n * it is a single fire-and-forget callback per skip event. We record\n * `phase: 'after'` as a placeholder so the metadata shape stays uniform;\n * the skip dispatch table is built in Task 25.\n */\nexport interface ListenerOptions {\n  kind: ListenerKind;\n  phase: ListenerPhase;\n  nonCritical?: boolean;\n}\n\nfunction defineListener(\n  target: object,\n  propertyKey: string | symbol,\n  options: ListenerOptions,\n): void {\n  Reflect.defineMetadata(BATCH_LISTENER_METADATA, options, target, propertyKey);\n}\n\nfunction listenerDecorator(options: ListenerOptions): MethodDecorator {\n  return (target: object, propertyKey: string | symbol, _descriptor: PropertyDescriptor) => {\n    defineListener(target, propertyKey, options);\n  };\n}\n\n// ---------------------------------------------------------------------------\n// Job-level listeners (2)\n// ---------------------------------------------------------------------------\n\n/** Fires before a job execution starts. */\nexport const BeforeJob = (): MethodDecorator =>\n  listenerDecorator({ kind: 'job', phase: 'before' });\n\n/** Fires after a job execution finishes (regardless of status). */\nexport const AfterJob = (): MethodDecorator =>\n  listenerDecorator({ kind: 'job', phase: 'after' });\n\n// ---------------------------------------------------------------------------\n// Step-level listeners (2)\n// ---------------------------------------------------------------------------\n\n/** Fires before a step execution starts. */\nexport const BeforeStep = (): MethodDecorator =>\n  listenerDecorator({ kind: 'step', phase: 'before' });\n\n/** Fires after a step execution finishes (regardless of status). */\nexport const AfterStep = (): MethodDecorator =>\n  listenerDecorator({ kind: 'step', phase: 'after' });\n\n// ---------------------------------------------------------------------------\n// Chunk-level listeners (3)\n// ---------------------------------------------------------------------------\n\n/** Fires before each chunk (read-process-write cycle) starts. */\nexport const BeforeChunk = (): MethodDecorator =>\n  listenerDecorator({ kind: 'chunk', phase: 'before' });\n\n/** Fires after each chunk finishes successfully. */\nexport const AfterChunk = (): MethodDecorator =>\n  listenerDecorator({ kind: 'chunk', phase: 'after' });\n\n/** Fires when a chunk throws (allows rollback hooks / telemetry). */\nexport const OnChunkError = (): MethodDecorator =>\n  listenerDecorator({ kind: 'chunk', phase: 'on-error' });\n\n// ---------------------------------------------------------------------------\n// ItemRead listeners (3)\n// ---------------------------------------------------------------------------\n\n/** Fires before each item is read. */\nexport const BeforeRead = (): MethodDecorator =>\n  listenerDecorator({ kind: 'item-read', phase: 'before' });\n\n/** Fires after each item is successfully read. */\nexport const AfterRead = (): MethodDecorator =>\n  listenerDecorator({ kind: 'item-read', phase: 'after' });\n\n/** Fires when the reader throws. */\nexport const OnReadError = (): MethodDecorator =>\n  listenerDecorator({ kind: 'item-read', phase: 'on-error' });\n\n// ---------------------------------------------------------------------------\n// ItemProcess listeners (3)\n// ---------------------------------------------------------------------------\n\n/** Fires before each item is processed. */\nexport const BeforeProcess = (): MethodDecorator =>\n  listenerDecorator({ kind: 'item-process', phase: 'before' });\n\n/** Fires after each item is successfully processed. */\nexport const AfterProcess = (): MethodDecorator =>\n  listenerDecorator({ kind: 'item-process', phase: 'after' });\n\n/** Fires when the processor throws. */\nexport const OnProcessError = (): MethodDecorator =>\n  listenerDecorator({ kind: 'item-process', phase: 'on-error' });\n\n// ---------------------------------------------------------------------------\n// ItemWrite listeners (3)\n// ---------------------------------------------------------------------------\n\n/** Fires before the writer receives a chunk. */\nexport const BeforeWrite = (): MethodDecorator =>\n  listenerDecorator({ kind: 'item-write', phase: 'before' });\n\n/** Fires after the writer successfully writes a chunk. */\nexport const AfterWrite = (): MethodDecorator =>\n  listenerDecorator({ kind: 'item-write', phase: 'after' });\n\n/** Fires when the writer throws. */\nexport const OnWriteError = (): MethodDecorator =>\n  listenerDecorator({ kind: 'item-write', phase: 'on-error' });\n\n// ---------------------------------------------------------------------------\n// Skip listeners (3)\n//\n// Skip listeners are not phase-based — each kind handles a distinct skip\n// event emitted by the corresponding read/process/write. We store them\n// under `kind: 'skip'` with `phase: 'after'` as a placeholder so the\n// metadata shape is uniform; the dispatch table is built in Task 25.\n// ---------------------------------------------------------------------------\n\n/** Fires when a read is skipped (after the skip policy decides to skip). */\nexport const OnSkipRead = (): MethodDecorator =>\n  listenerDecorator({ kind: 'skip', phase: 'after' });\n\n/** Fires when a processed item is skipped. */\nexport const OnSkipProcess = (): MethodDecorator =>\n  listenerDecorator({ kind: 'skip', phase: 'after' });\n\n/** Fires when a write is skipped. */\nexport const OnSkipWrite = (): MethodDecorator =>\n  listenerDecorator({ kind: 'skip', phase: 'after' });\n"],"names":["AfterChunk","AfterJob","AfterProcess","AfterRead","AfterStep","AfterWrite","BeforeChunk","BeforeJob","BeforeProcess","BeforeRead","BeforeStep","BeforeWrite","OnChunkError","OnProcessError","OnReadError","OnSkipProcess","OnSkipRead","OnSkipWrite","OnWriteError","defineListener","target","propertyKey","options","Reflect","defineMetadata","BATCH_LISTENER_METADATA","listenerDecorator","_descriptor","kind","phase"],"mappings":";;;;;;;;;;;QAmEaA;eAAAA;;QAxBAC;eAAAA;;QAwDAC;eAAAA;;QAhBAC;eAAAA;;QA5BAC;eAAAA;;QA4DAC;eAAAA;;QApDAC;eAAAA;;QAxBAC;eAAAA;;QAwDAC;eAAAA;;QAhBAC;eAAAA;;QA5BAC;eAAAA;;QA4DAC;eAAAA;;QAxCAC;eAAAA;;QAgCAC;eAAAA;;QAhBAC;eAAAA;;QAiDAC;eAAAA;;QAJAC;eAAAA;;QAQAC;eAAAA;;QArBAC;eAAAA;;;QAvHN;2BACiC;AAmBxC,SAASC,eACPC,MAAc,EACdC,WAA4B,EAC5BC,OAAwB;IAExBC,QAAQC,cAAc,CAACC,kCAAuB,EAAEH,SAASF,QAAQC;AACnE;AAEA,SAASK,kBAAkBJ,OAAwB;IACjD,OAAO,CAACF,QAAgBC,aAA8BM;QACpDR,eAAeC,QAAQC,aAAaC;IACtC;AACF;AAOO,MAAMf,YAAY,IACvBmB,kBAAkB;QAAEE,MAAM;QAAOC,OAAO;IAAS;AAG5C,MAAM5B,WAAW,IACtByB,kBAAkB;QAAEE,MAAM;QAAOC,OAAO;IAAQ;AAO3C,MAAMnB,aAAa,IACxBgB,kBAAkB;QAAEE,MAAM;QAAQC,OAAO;IAAS;AAG7C,MAAMzB,YAAY,IACvBsB,kBAAkB;QAAEE,MAAM;QAAQC,OAAO;IAAQ;AAO5C,MAAMvB,cAAc,IACzBoB,kBAAkB;QAAEE,MAAM;QAASC,OAAO;IAAS;AAG9C,MAAM7B,aAAa,IACxB0B,kBAAkB;QAAEE,MAAM;QAASC,OAAO;IAAQ;AAG7C,MAAMjB,eAAe,IAC1Bc,kBAAkB;QAAEE,MAAM;QAASC,OAAO;IAAW;AAOhD,MAAMpB,aAAa,IACxBiB,kBAAkB;QAAEE,MAAM;QAAaC,OAAO;IAAS;AAGlD,MAAM1B,YAAY,IACvBuB,kBAAkB;QAAEE,MAAM;QAAaC,OAAO;IAAQ;AAGjD,MAAMf,cAAc,IACzBY,kBAAkB;QAAEE,MAAM;QAAaC,OAAO;IAAW;AAOpD,MAAMrB,gBAAgB,IAC3BkB,kBAAkB;QAAEE,MAAM;QAAgBC,OAAO;IAAS;AAGrD,MAAM3B,eAAe,IAC1BwB,kBAAkB;QAAEE,MAAM;QAAgBC,OAAO;IAAQ;AAGpD,MAAMhB,iBAAiB,IAC5Ba,kBAAkB;QAAEE,MAAM;QAAgBC,OAAO;IAAW;AAOvD,MAAMlB,cAAc,IACzBe,kBAAkB;QAAEE,MAAM;QAAcC,OAAO;IAAS;AAGnD,MAAMxB,aAAa,IACxBqB,kBAAkB;QAAEE,MAAM;QAAcC,OAAO;IAAQ;AAGlD,MAAMX,eAAe,IAC1BQ,kBAAkB;QAAEE,MAAM;QAAcC,OAAO;IAAW;AAYrD,MAAMb,aAAa,IACxBU,kBAAkB;QAAEE,MAAM;QAAQC,OAAO;IAAQ;AAG5C,MAAMd,gBAAgB,IAC3BW,kBAAkB;QAAEE,MAAM;QAAQC,OAAO;IAAQ;AAG5C,MAAMZ,cAAc,IACzBS,kBAAkB;QAAEE,MAAM;QAAQC,OAAO;IAAQ"}

package/dist/src/decorators/step.decorator.d.ts

@@ -0,0 +1,25 @@
+import 'reflect-metadata';
+import type { ChunkPartitionConfig, RetryPolicyConfig, SkipPolicyConfig } from '../core/ir';
+export interface StepableOptions {
+    id: string;
+    chunkSize?: number;
+    skipPolicy?: SkipPolicyConfig;
+    retryPolicy?: RetryPolicyConfig;
+    /**
+     * Optional partition configuration forwarded to the compiled
+     * `ChunkStepDefinition.partitions`. See `docs/RELEASE-0.2.0.md §6`
+     * and `packages/core/src/partition-helpers.ts` for the contract.
+     * Tasklet steps ignore this field.
+     */
+    partitions?: ChunkPartitionConfig;
+}
+/**
+ * Method decorator that marks a method as a batch step.
+ * When `chunkSize` is 0/undefined and `@Tasklet()` is also present, the step is a tasklet step.
+ * Otherwise, the method must NOT be marked with `@Tasklet()` and step is a chunk step (uses the class-level reader/processor/writer).
+ *
+ * NOTE: The actual chunk step is assembled by the `DefinitionCompiler` from
+ * class-level `@ItemReader`/`@ItemProcessor`/`@ItemWriter` methods.
+ */
+export declare function Stepable(options: StepableOptions): MethodDecorator;
+//# sourceMappingURL=step.decorator.d.ts.map

package/dist/src/decorators/step.decorator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"step.decorator.d.ts","sourceRoot":"","sources":["../../../src/decorators/step.decorator.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC;AAE1B,OAAO,KAAK,EAAE,oBAAoB,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAE5F,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,gBAAgB,CAAC;IAC9B,WAAW,CAAC,EAAE,iBAAiB,CAAC;IAChC;;;;;OAKG;IACH,UAAU,CAAC,EAAE,oBAAoB,CAAC;CACnC;AAED;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CAAC,OAAO,EAAE,eAAe,GAAG,eAAe,CAMlE"}

package/dist/src/decorators/step.decorator.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Stepable", {
+    enumerable: true,
+    get: function() {
+        return Stepable;
+    }
+});
+require("reflect-metadata");
+const _constants = require("./constants");
+function Stepable(options) {
+    return (target, propertyKey, descriptor)=>{
+        Reflect.defineMetadata(_constants.BATCH_STEP_METADATA, options, target, propertyKey);
+        // Also stash on the function itself so explorer can read both
+        Reflect.defineMetadata(_constants.BATCH_STEP_METADATA, options, descriptor.value);
+    };
+}
+
+//# sourceMappingURL=step.decorator.js.map

package/dist/src/decorators/step.decorator.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/decorators/step.decorator.ts"],"sourcesContent":["import 'reflect-metadata';\nimport { BATCH_STEP_METADATA } from './constants';\nimport type { ChunkPartitionConfig, RetryPolicyConfig, SkipPolicyConfig } from '../core/ir';\n\nexport interface StepableOptions {\n  id: string;\n  chunkSize?: number; // 0 or undefined = tasklet step\n  skipPolicy?: SkipPolicyConfig;\n  retryPolicy?: RetryPolicyConfig;\n  /**\n   * Optional partition configuration forwarded to the compiled\n   * `ChunkStepDefinition.partitions`. See `docs/RELEASE-0.2.0.md §6`\n   * and `packages/core/src/partition-helpers.ts` for the contract.\n   * Tasklet steps ignore this field.\n   */\n  partitions?: ChunkPartitionConfig;\n}\n\n/**\n * Method decorator that marks a method as a batch step.\n * When `chunkSize` is 0/undefined and `@Tasklet()` is also present, the step is a tasklet step.\n * Otherwise, the method must NOT be marked with `@Tasklet()` and step is a chunk step (uses the class-level reader/processor/writer).\n *\n * NOTE: The actual chunk step is assembled by the `DefinitionCompiler` from\n * class-level `@ItemReader`/`@ItemProcessor`/`@ItemWriter` methods.\n */\nexport function Stepable(options: StepableOptions): MethodDecorator {\n  return (target: object, propertyKey: string | symbol, descriptor: PropertyDescriptor) => {\n    Reflect.defineMetadata(BATCH_STEP_METADATA, options, target, propertyKey);\n    // Also stash on the function itself so explorer can read both\n    Reflect.defineMetadata(BATCH_STEP_METADATA, options, descriptor.value as object);\n  };\n}\n"],"names":["Stepable","options","target","propertyKey","descriptor","Reflect","defineMetadata","BATCH_STEP_METADATA","value"],"mappings":";;;;+BA0BgBA;;;eAAAA;;;QA1BT;2BAC6B;AAyB7B,SAASA,SAASC,OAAwB;IAC/C,OAAO,CAACC,QAAgBC,aAA8BC;QACpDC,QAAQC,cAAc,CAACC,8BAAmB,EAAEN,SAASC,QAAQC;QAC7D,8DAA8D;QAC9DE,QAAQC,cAAc,CAACC,8BAAmB,EAAEN,SAASG,WAAWI,KAAK;IACvE;AACF"}

package/dist/src/decorators/tasklet.decorator.d.ts

@@ -0,0 +1,7 @@
+import 'reflect-metadata';
+/**
+ * Method decorator that marks a `@Stepable` method as a tasklet handler
+ * (single execution, not a chunk loop).
+ */
+export declare function Tasklet(): MethodDecorator;
+//# sourceMappingURL=tasklet.decorator.d.ts.map

package/dist/src/decorators/tasklet.decorator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tasklet.decorator.d.ts","sourceRoot":"","sources":["../../../src/decorators/tasklet.decorator.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC;AAG1B;;;GAGG;AACH,wBAAgB,OAAO,IAAI,eAAe,CAMzC"}

package/dist/src/decorators/tasklet.decorator.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Tasklet", {
+    enumerable: true,
+    get: function() {
+        return Tasklet;
+    }
+});
+require("reflect-metadata");
+const _constants = require("./constants");
+function Tasklet() {
+    return (target, propertyKey, descriptor)=>{
+        Reflect.defineMetadata(_constants.BATCH_TASKLET_METADATA, true, descriptor.value);
+        // Also stash on the prototype method so explorer can read both
+        Reflect.defineMetadata(_constants.BATCH_TASKLET_METADATA, true, target, propertyKey);
+    };
+}
+
+//# sourceMappingURL=tasklet.decorator.js.map

package/dist/src/decorators/tasklet.decorator.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/decorators/tasklet.decorator.ts"],"sourcesContent":["import 'reflect-metadata';\nimport { BATCH_TASKLET_METADATA } from './constants';\n\n/**\n * Method decorator that marks a `@Stepable` method as a tasklet handler\n * (single execution, not a chunk loop).\n */\nexport function Tasklet(): MethodDecorator {\n  return (target: object, propertyKey: string | symbol, descriptor: PropertyDescriptor) => {\n    Reflect.defineMetadata(BATCH_TASKLET_METADATA, true, descriptor.value as object);\n    // Also stash on the prototype method so explorer can read both\n    Reflect.defineMetadata(BATCH_TASKLET_METADATA, true, target, propertyKey);\n  };\n}\n"],"names":["Tasklet","target","propertyKey","descriptor","Reflect","defineMetadata","BATCH_TASKLET_METADATA","value"],"mappings":";;;;+BAOgBA;;;eAAAA;;;QAPT;2BACgC;AAMhC,SAASA;IACd,OAAO,CAACC,QAAgBC,aAA8BC;QACpDC,QAAQC,cAAc,CAACC,iCAAsB,EAAE,MAAMH,WAAWI,KAAK;QACrE,+DAA+D;QAC/DH,QAAQC,cAAc,CAACC,iCAAsB,EAAE,MAAML,QAAQC;IAC/D;AACF"}

package/dist/src/execution/batch-worker-runner.d.ts

@@ -0,0 +1,27 @@
+import type { JobParameters, JobExecution } from '../core/repository';
+import { JobRepository } from '../core/repository';
+import { JobStatus } from '../core/status';
+import { JobRegistry } from '../registry/job-registry';
+import { JobExecutor } from './job-executor';
+export interface BatchWorkerRunOptions {
+    readonly jobExecutionId?: string;
+    readonly executionId?: string;
+    readonly jobId?: string;
+    readonly params?: JobParameters;
+    readonly partitionIndex?: number;
+    readonly partitionCount?: number;
+}
+export interface BatchWorkerRunResult {
+    readonly jobExecution: JobExecution;
+    readonly status: JobStatus;
+    readonly processExitCode: number;
+}
+export declare class BatchWorkerRunner {
+    private readonly registry;
+    private readonly repository;
+    private readonly jobExecutor;
+    constructor(registry: JobRegistry, repository: JobRepository, jobExecutor: JobExecutor);
+    run(options: BatchWorkerRunOptions): Promise<BatchWorkerRunResult>;
+}
+export declare function parseBatchWorkerArgs(argv: readonly string[]): BatchWorkerRunOptions;
+//# sourceMappingURL=batch-worker-runner.d.ts.map

package/dist/src/execution/batch-worker-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"batch-worker-runner.d.ts","sourceRoot":"","sources":["../../../src/execution/batch-worker-runner.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACtE,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAEvD,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAG7C,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,CAAC,EAAE,aAAa,CAAC;IAChC,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;CAClC;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,YAAY,EAAE,YAAY,CAAC;IACpC,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC;IAC3B,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;CAClC;AAED,qBACa,iBAAiB;IAE1B,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,WAAW;gBAFX,QAAQ,EAAE,WAAW,EACrB,UAAU,EAAE,aAAa,EACzB,WAAW,EAAE,WAAW;IAGrC,GAAG,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,oBAAoB,CAAC;CAmDzE;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,qBAAqB,CAgDnF"}