@nest-batch/core 0.2.0 → 0.2.2

package/README.md

@@ -306,7 +306,8 @@ The barrel re-exports:
 - `./execution` — `JobLauncher`, `JobExecutor`, `InProcessExecutionStrategy`, `IExecutionStrategy`, `EXECUTION_STRATEGY`, `ChunkStepExecutor`, `TaskletStepExecutor`, `ListenerInvoker`, `RefResolver`.
 - `./transaction` — `TransactionManager` token and contract.
 - `./repository` — `JobRepository` token, contract, in-memory reference, ID generators.
-- `./decorators` — under the `BatchDecorators` namespace (`@Jobable`, `@ItemReader`, `@ItemProcessor`, `@ItemWriter`, `@Tasklet`, listener decorators, `@BatchScheduled`).
+- `./decorators` — under the `BatchDecorators` namespace (`@Jobable`, `@ItemReader`, `@ItemProcessor`, `@ItemWriter`, `@Tasklet`, listener decorators).
+- `./scheduling/batch-scheduled` — `@BatchScheduled` and its schedule option/error types are also re-exported directly from the package root.
 - `./module` — `NestBatchModule`, tokens, options.
 - `./builder` — fluent `BatchBuilder`, `JobBuilder`, `StepBuilder`, `FlowBuilder`.
 - `./explorer` — `BatchExplorer` (the metadata scanner).
@@ -329,8 +330,8 @@ injected at the DI boundary:
 
 | Concern                       | Package                 | Why                                                               |
 | ----------------------------- | ----------------------- | ----------------------------------------------------------------- |
-| **Persistence (PostgreSQL)**  | `@nest-batch/mikro-orm` | Ships the 6 batch meta tables, entities, and migrations.          |
-| **Persistence (TypeORM 1.0)** | `@nest-batch/typeorm`   | Ships the same 6 tables as TypeORM 1.0.0 entities + migration.    |
+| **Persistence (MikroORM)**    | `@nest-batch/mikro-orm` | Exposes the batch meta entities; the host owns migrations.        |
+| **Persistence (TypeORM 1.0)** | `@nest-batch/typeorm`   | Exposes the same table contract as TypeORM 1.0.0 entities.        |
 | **Transport (BullMQ)**        | `@nest-batch/bullmq`    | The Redis-backed execution strategy. Owns Queue/Worker lifecycle. |
 | **Drizzle**                   | _not in this release_   | Explicitly excluded and deferred. See `MIGRATION.md`.             |
 
@@ -364,5 +365,6 @@ pnpm --filter @nest-batch/core typecheck  # tsc --noEmit
 
 The boundary test (`tests/core/boundary/no-forbidden-imports.test.ts`)
 guards core's dependency-light promise. It fails the build if any
-forbidden package (`bullmq`, `mikro-orm`, `typeorm`, `drizzle-orm`,
-`cron`) shows up as a core import.
+forbidden integration package (`bullmq`, `mikro-orm`, `typeorm`,
+`drizzle-orm`) shows up as a core import. The small `cron` dependency
+is intentionally allowed for the built-in in-process scheduler bridge.

package/dist/src/adapters/in-process.adapter.d.ts

@@ -76,6 +76,16 @@ export declare class InProcessModule {
  * some "config" into it, you almost certainly want a real transport
  * adapter instead.
  *
+ * ## Scheduling
+ *
+ * `InProcessSchedule` is registered as a transport global provider.
+ * It consumes `BatchScheduleRegistry` after discovery/bootstrap and
+ * turns non-inert `@BatchScheduled` cron ticks into
+ * `JobLauncher.launch(...)` calls in this same process. That gives
+ * single-process apps a real cron path without Redis or another
+ * queue. It is intentionally not a distributed lock: multiple app
+ * replicas will each run their own timer.
+ *
  * ## DI scope
  *
  * The module is `global: true` and exports both the strategy class
@@ -94,23 +104,16 @@ export declare class InProcessModule {
  *      pattern uniform across the engine and its adapters — the host
  *      author only needs to learn one module-visibility model.
  *
- * ## Why `globalProviders` is omitted
+ * ## Why `globalProviders` is used
  *
  * The `BatchAdapter` interface allows a `globalProviders` field for
  * runtime classes (e.g. `JobExecutor`, `InProcessExecutionStrategy`)
  * that the adapter's *own* module needs to inject but that the host
- * should also be able to inject. The recommended path is to list
- * them in the adapter's own `DynamicModule.exports` — which is what
- * this adapter does. `JobLauncher` (registered by `NestBatchModule`,
- * not by this adapter) injects the strategy by the `EXECUTION_STRATEGY`
- * token, which is exported here, so the runtime resolution chain
- * works without the core module having to know which adapter is
- * active.
- *
- * If a future in-process feature needs to expose a new provider to
- * the host (e.g. an inline scheduler), prefer adding it to
- * `exports` and updating the `BatchAdapter.globalProviders` decision
- * — do not push it onto the host app's `providers` array.
+ * should also be able to inject. This adapter lists
+ * `InProcessExecutionStrategy`, `InProcessSchedule`, and the
+ * `EXECUTION_STRATEGY` binding there so `NestBatchModule` can merge
+ * them into the same provider graph as `JobLauncher`,
+ * `BatchScheduleRegistry`, and the executor subgraph.
  *
  * ## Concurrency
  *

package/dist/src/adapters/in-process.adapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"in-process.adapter.d.ts","sourceRoot":"","sources":["../../../src/adapters/in-process.adapter.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAOtD;;;;;;;;;GASG;AACH,qBACa,eAAe;CAAG;AAE/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2GG;AACH,qBAAa,gBAAgB;IAC3B;;;;;;;;;;;;;;OAcG;IACH,MAAM,CAAC,OAAO,IAAI,YAAY;CAU/B"}
+{"version":3,"file":"in-process.adapter.d.ts","sourceRoot":"","sources":["../../../src/adapters/in-process.adapter.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAQtD;;;;;;;;;GASG;AACH,qBACa,eAAe;CAAG;AAE/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8GG;AACH,qBAAa,gBAAgB;IAC3B;;;;;;;;;;;;;;OAcG;IACH,MAAM,CAAC,OAAO,IAAI,YAAY;CAW/B"}

package/dist/src/adapters/in-process.adapter.js

@@ -18,6 +18,7 @@ _export(exports, {
 });
 const _common = require("@nestjs/common");
 const _inprocessexecutionstrategy = require("../execution/in-process-execution-strategy");
+const _inprocessschedule = require("../execution/in-process-schedule");
 function _ts_decorate(decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -50,6 +51,7 @@ let InProcessAdapter = class InProcessAdapter {
             module: buildInProcessDynamicModule(),
             globalProviders: [
                 _inprocessexecutionstrategy.InProcessExecutionStrategy,
+                _inprocessschedule.InProcessSchedule,
                 _inprocessexecutionstrategy.IN_PROCESS_EXECUTION_STRATEGY_PROVIDER
             ]
         };

package/dist/src/adapters/in-process.adapter.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/adapters/in-process.adapter.ts"],"sourcesContent":["import { Module, type DynamicModule } from '@nestjs/common';\n\nimport type { BatchAdapter } from '../module/adapter';\nimport { EXECUTION_STRATEGY } from '../execution/execution-strategy';\nimport {\n  IN_PROCESS_EXECUTION_STRATEGY_PROVIDER,\n  InProcessExecutionStrategy,\n} from '../execution/in-process-execution-strategy';\n\n/**\n * Empty Nest module class that owns the in-process execution-strategy\n * providers.\n *\n * The class has no body on purpose: it is purely a `DynamicModule`\n * carrier for the `forRoot()` factory below. Nest's module system\n * requires *some* class to identify the module — the empty class is\n * the minimum possible surface and keeps the runtime allocation at\n * one class (no decorators, no lifecycle hooks, no metadata).\n */\n@Module({})\nexport class InProcessModule {}\n\n/**\n * `InProcessAdapter` — the default transport adapter for\n * `@nest-batch/core`.\n *\n * This is the **no-Redis** transport: jobs run synchronously inside\n * the launching process via `JobExecutor.execute(...)`, on the same\n * event loop that called `JobLauncher.launch(...)`. There is no\n * queue, no worker, no Redis connection, no AOF / Lua scripts /\n * stream events. The whole point of this adapter is to be the\n * \"no transport runtime at all\" option.\n *\n * Use it when:\n *\n *   - You do not need horizontal scale-out (one process, one\n *     launcher, jobs run inline).\n *   - You want the cheapest possible deployment — no extra\n *     infrastructure, no extra process to supervise.\n *   - You are building a library / dev-time harness and the queue\n *     runtime would be in the way.\n *   - You are migrating an existing batch app and want to validate\n *     the engine end-to-end before turning on a real transport.\n *\n * Switch to `@nest-batch/bullmq` (or a future transport) when you\n * need cross-process work distribution, technical retry at the\n * transport layer, or a queue-backed backpressure model. The\n * `IExecutionStrategy` polymorphism means the application code does\n * not change — only the `transport` slot in `adapters: { ... }` does.\n *\n * ## Why a dedicated adapter (and not a built-in default)?\n *\n * The new factory-pattern API takes `adapters: { persistence,\n * transport }` and both slots are *required* (see\n * `BatchAdaptersConfig`). Shipping the in-process transport as a\n * dedicated `BatchAdapter` rather than a hidden implicit default\n * keeps the `AppModule` wiring explicit at the call site — you can\n * read the host's `imports` array and see exactly which transport is\n * active. That pays off the first time you debug a \"why is this\n * running inline?\" question and need to grep for the transport.\n *\n * ## Wiring\n *\n * ```ts\n * import { Module } from '@nestjs/common';\n * import { NestBatchModule, InProcessAdapter } from '@nest-batch/core';\n * import { MikroOrmAdapter } from '@nest-batch/mikro-orm';\n *\n * @Module({\n *   imports: [\n *     NestBatchModule.forRoot({\n *       adapters: {\n *         persistence: MikroOrmAdapter,\n *         transport: InProcessAdapter,\n *       },\n *     }),\n *   ],\n * })\n * class AppModule {}\n * ```\n *\n * `InProcessAdapter.forRoot()` takes no options — the in-process\n * transport has no connection params, no credentials, no knobs to\n * tune. If you find yourself reaching for a `useFactory` to plumb\n * some \"config\" into it, you almost certainly want a real transport\n * adapter instead.\n *\n * ## DI scope\n *\n * The module is `global: true` and exports both the strategy class\n * and the `EXECUTION_STRATEGY` token. Three reasons for the `global`\n * flag:\n *\n *   1. `JobLauncher` (registered by `NestBatchModule`) is `@Inject(\n *      EXECUTION_STRATEGY )` — it needs the token visible at the\n *      application level, not just inside the adapter's own module.\n *   2. The host application is the only place that may want to\n *      inspect the strategy at runtime (e.g. for a `/healthz`\n *      endpoint reporting which transport is active). The `global`\n *      flag makes that work without forcing the host to re-import\n *      this module from every sub-module.\n *   3. Mirroring `NestBatchModule`'s own `global: true` keeps the\n *      pattern uniform across the engine and its adapters — the host\n *      author only needs to learn one module-visibility model.\n *\n * ## Why `globalProviders` is omitted\n *\n * The `BatchAdapter` interface allows a `globalProviders` field for\n * runtime classes (e.g. `JobExecutor`, `InProcessExecutionStrategy`)\n * that the adapter's *own* module needs to inject but that the host\n * should also be able to inject. The recommended path is to list\n * them in the adapter's own `DynamicModule.exports` — which is what\n * this adapter does. `JobLauncher` (registered by `NestBatchModule`,\n * not by this adapter) injects the strategy by the `EXECUTION_STRATEGY`\n * token, which is exported here, so the runtime resolution chain\n * works without the core module having to know which adapter is\n * active.\n *\n * If a future in-process feature needs to expose a new provider to\n * the host (e.g. an inline scheduler), prefer adding it to\n * `exports` and updating the `BatchAdapter.globalProviders` decision\n * — do not push it onto the host app's `providers` array.\n *\n * ## Concurrency\n *\n * The default in-process strategy runs jobs on the caller's event\n * loop. A long-running step will block the launching process. This\n * is the contract: no concurrency, no parallelism, no out-of-band\n * execution. If you need concurrency, switch transports.\n */\nexport class InProcessAdapter {\n  /**\n   * Build the `BatchAdapter` value the new factory-pattern\n   * `NestBatchModule.forRoot({ adapters: { transport, ... } })`\n   * expects.\n   *\n   * No options are accepted on purpose — the in-process transport\n   * has nothing to configure. The method is static so the adapter\n   * can be referenced as a value (`adapters: { transport:\n   * InProcessAdapter }`) without needing an instance, mirroring\n   * the shape of the sibling adapter packages' own factories.\n   *\n   * @returns A `BatchAdapter` whose `module` is a `global: true`\n   *   `DynamicModule` exposing `InProcessExecutionStrategy` and the\n   *   `EXECUTION_STRATEGY` token to the host application.\n   */\n  static forRoot(): BatchAdapter {\n    return {\n      name: 'in-process',\n      module: buildInProcessDynamicModule(),\n      globalProviders: [\n        InProcessExecutionStrategy,\n        IN_PROCESS_EXECUTION_STRATEGY_PROVIDER,\n      ],\n    };\n  }\n}\n\n/**\n * Build the `DynamicModule` payload for the in-process transport.\n *\n * Extracted from `InProcessAdapter.forRoot()` so the provider /\n * export list lives in one place — easier to read, easier to keep\n * the two arrays in sync if a new provider is ever added.\n *\n * The `EXECUTION_STRATEGY` token is exported (not just listed in\n * `providers`) so that host code can resolve the strategy directly\n * via `moduleRef.get(EXECUTION_STRATEGY)` — useful for `/healthz`\n * endpoints that need to report which transport is wired up.\n *\n * `InProcessExecutionStrategy` is also exported so host code can\n * inject the concrete class (not just the token) when type-strict\n * consumers prefer the class form.\n */\nfunction buildInProcessDynamicModule(): DynamicModule {\n  return {\n    module: InProcessModule,\n    global: true,\n    providers: [IN_PROCESS_EXECUTION_STRATEGY_PROVIDER],\n    exports: [IN_PROCESS_EXECUTION_STRATEGY_PROVIDER],\n  };\n}\n"],"names":["InProcessAdapter","InProcessModule","forRoot","name","module","buildInProcessDynamicModule","globalProviders","InProcessExecutionStrategy","IN_PROCESS_EXECUTION_STRATEGY_PROVIDER","global","providers","exports"],"mappings":";;;;;;;;;;;QAkIaA;eAAAA;;QA9GAC;eAAAA;;;wBApB8B;4CAOpC;;;;;;;AAaA,IAAA,AAAMA,kBAAN,MAAMA;AAAiB;;;;AA8GvB,IAAA,AAAMD,mBAAN,MAAMA;IACX;;;;;;;;;;;;;;GAcC,GACD,OAAOE,UAAwB;QAC7B,OAAO;YACLC,MAAM;YACNC,QAAQC;YACRC,iBAAiB;gBACfC,sDAA0B;gBAC1BC,kEAAsC;aACvC;QACH;IACF;AACF;AAEA;;;;;;;;;;;;;;;CAeC,GACD,SAASH;IACP,OAAO;QACLD,QAAQH;QACRQ,QAAQ;QACRC,WAAW;YAACF,kEAAsC;SAAC;QACnDG,SAAS;YAACH,kEAAsC;SAAC;IACnD;AACF"}
+{"version":3,"sources":["../../../src/adapters/in-process.adapter.ts"],"sourcesContent":["import { Module, type DynamicModule } from '@nestjs/common';\n\nimport type { BatchAdapter } from '../module/adapter';\nimport { EXECUTION_STRATEGY } from '../execution/execution-strategy';\nimport {\n  IN_PROCESS_EXECUTION_STRATEGY_PROVIDER,\n  InProcessExecutionStrategy,\n} from '../execution/in-process-execution-strategy';\nimport { InProcessSchedule } from '../execution/in-process-schedule';\n\n/**\n * Empty Nest module class that owns the in-process execution-strategy\n * providers.\n *\n * The class has no body on purpose: it is purely a `DynamicModule`\n * carrier for the `forRoot()` factory below. Nest's module system\n * requires *some* class to identify the module — the empty class is\n * the minimum possible surface and keeps the runtime allocation at\n * one class (no decorators, no lifecycle hooks, no metadata).\n */\n@Module({})\nexport class InProcessModule {}\n\n/**\n * `InProcessAdapter` — the default transport adapter for\n * `@nest-batch/core`.\n *\n * This is the **no-Redis** transport: jobs run synchronously inside\n * the launching process via `JobExecutor.execute(...)`, on the same\n * event loop that called `JobLauncher.launch(...)`. There is no\n * queue, no worker, no Redis connection, no AOF / Lua scripts /\n * stream events. The whole point of this adapter is to be the\n * \"no transport runtime at all\" option.\n *\n * Use it when:\n *\n *   - You do not need horizontal scale-out (one process, one\n *     launcher, jobs run inline).\n *   - You want the cheapest possible deployment — no extra\n *     infrastructure, no extra process to supervise.\n *   - You are building a library / dev-time harness and the queue\n *     runtime would be in the way.\n *   - You are migrating an existing batch app and want to validate\n *     the engine end-to-end before turning on a real transport.\n *\n * Switch to `@nest-batch/bullmq` (or a future transport) when you\n * need cross-process work distribution, technical retry at the\n * transport layer, or a queue-backed backpressure model. The\n * `IExecutionStrategy` polymorphism means the application code does\n * not change — only the `transport` slot in `adapters: { ... }` does.\n *\n * ## Why a dedicated adapter (and not a built-in default)?\n *\n * The new factory-pattern API takes `adapters: { persistence,\n * transport }` and both slots are *required* (see\n * `BatchAdaptersConfig`). Shipping the in-process transport as a\n * dedicated `BatchAdapter` rather than a hidden implicit default\n * keeps the `AppModule` wiring explicit at the call site — you can\n * read the host's `imports` array and see exactly which transport is\n * active. That pays off the first time you debug a \"why is this\n * running inline?\" question and need to grep for the transport.\n *\n * ## Wiring\n *\n * ```ts\n * import { Module } from '@nestjs/common';\n * import { NestBatchModule, InProcessAdapter } from '@nest-batch/core';\n * import { MikroOrmAdapter } from '@nest-batch/mikro-orm';\n *\n * @Module({\n *   imports: [\n *     NestBatchModule.forRoot({\n *       adapters: {\n *         persistence: MikroOrmAdapter,\n *         transport: InProcessAdapter,\n *       },\n *     }),\n *   ],\n * })\n * class AppModule {}\n * ```\n *\n * `InProcessAdapter.forRoot()` takes no options — the in-process\n * transport has no connection params, no credentials, no knobs to\n * tune. If you find yourself reaching for a `useFactory` to plumb\n * some \"config\" into it, you almost certainly want a real transport\n * adapter instead.\n *\n * ## Scheduling\n *\n * `InProcessSchedule` is registered as a transport global provider.\n * It consumes `BatchScheduleRegistry` after discovery/bootstrap and\n * turns non-inert `@BatchScheduled` cron ticks into\n * `JobLauncher.launch(...)` calls in this same process. That gives\n * single-process apps a real cron path without Redis or another\n * queue. It is intentionally not a distributed lock: multiple app\n * replicas will each run their own timer.\n *\n * ## DI scope\n *\n * The module is `global: true` and exports both the strategy class\n * and the `EXECUTION_STRATEGY` token. Three reasons for the `global`\n * flag:\n *\n *   1. `JobLauncher` (registered by `NestBatchModule`) is `@Inject(\n *      EXECUTION_STRATEGY )` — it needs the token visible at the\n *      application level, not just inside the adapter's own module.\n *   2. The host application is the only place that may want to\n *      inspect the strategy at runtime (e.g. for a `/healthz`\n *      endpoint reporting which transport is active). The `global`\n *      flag makes that work without forcing the host to re-import\n *      this module from every sub-module.\n *   3. Mirroring `NestBatchModule`'s own `global: true` keeps the\n *      pattern uniform across the engine and its adapters — the host\n *      author only needs to learn one module-visibility model.\n *\n * ## Why `globalProviders` is used\n *\n * The `BatchAdapter` interface allows a `globalProviders` field for\n * runtime classes (e.g. `JobExecutor`, `InProcessExecutionStrategy`)\n * that the adapter's *own* module needs to inject but that the host\n * should also be able to inject. This adapter lists\n * `InProcessExecutionStrategy`, `InProcessSchedule`, and the\n * `EXECUTION_STRATEGY` binding there so `NestBatchModule` can merge\n * them into the same provider graph as `JobLauncher`,\n * `BatchScheduleRegistry`, and the executor subgraph.\n *\n * ## Concurrency\n *\n * The default in-process strategy runs jobs on the caller's event\n * loop. A long-running step will block the launching process. This\n * is the contract: no concurrency, no parallelism, no out-of-band\n * execution. If you need concurrency, switch transports.\n */\nexport class InProcessAdapter {\n  /**\n   * Build the `BatchAdapter` value the new factory-pattern\n   * `NestBatchModule.forRoot({ adapters: { transport, ... } })`\n   * expects.\n   *\n   * No options are accepted on purpose — the in-process transport\n   * has nothing to configure. The method is static so the adapter\n   * can be referenced as a value (`adapters: { transport:\n   * InProcessAdapter }`) without needing an instance, mirroring\n   * the shape of the sibling adapter packages' own factories.\n   *\n   * @returns A `BatchAdapter` whose `module` is a `global: true`\n   *   `DynamicModule` exposing `InProcessExecutionStrategy` and the\n   *   `EXECUTION_STRATEGY` token to the host application.\n   */\n  static forRoot(): BatchAdapter {\n    return {\n      name: 'in-process',\n      module: buildInProcessDynamicModule(),\n      globalProviders: [\n        InProcessExecutionStrategy,\n        InProcessSchedule,\n        IN_PROCESS_EXECUTION_STRATEGY_PROVIDER,\n      ],\n    };\n  }\n}\n\n/**\n * Build the `DynamicModule` payload for the in-process transport.\n *\n * Extracted from `InProcessAdapter.forRoot()` so the provider /\n * export list lives in one place — easier to read, easier to keep\n * the two arrays in sync if a new provider is ever added.\n *\n * The `EXECUTION_STRATEGY` token is exported (not just listed in\n * `providers`) so that host code can resolve the strategy directly\n * via `moduleRef.get(EXECUTION_STRATEGY)` — useful for `/healthz`\n * endpoints that need to report which transport is wired up.\n *\n * `InProcessExecutionStrategy` is also exported so host code can\n * inject the concrete class (not just the token) when type-strict\n * consumers prefer the class form.\n */\nfunction buildInProcessDynamicModule(): DynamicModule {\n  return {\n    module: InProcessModule,\n    global: true,\n    providers: [IN_PROCESS_EXECUTION_STRATEGY_PROVIDER],\n    exports: [IN_PROCESS_EXECUTION_STRATEGY_PROVIDER],\n  };\n}\n"],"names":["InProcessAdapter","InProcessModule","forRoot","name","module","buildInProcessDynamicModule","globalProviders","InProcessExecutionStrategy","InProcessSchedule","IN_PROCESS_EXECUTION_STRATEGY_PROVIDER","global","providers","exports"],"mappings":";;;;;;;;;;;QAsIaA;eAAAA;;QAjHAC;eAAAA;;;wBArB8B;4CAOpC;mCAC2B;;;;;;;AAa3B,IAAA,AAAMA,kBAAN,MAAMA;AAAiB;;;;AAiHvB,IAAA,AAAMD,mBAAN,MAAMA;IACX;;;;;;;;;;;;;;GAcC,GACD,OAAOE,UAAwB;QAC7B,OAAO;YACLC,MAAM;YACNC,QAAQC;YACRC,iBAAiB;gBACfC,sDAA0B;gBAC1BC,oCAAiB;gBACjBC,kEAAsC;aACvC;QACH;IACF;AACF;AAEA;;;;;;;;;;;;;;;CAeC,GACD,SAASJ;IACP,OAAO;QACLD,QAAQH;QACRS,QAAQ;QACRC,WAAW;YAACF,kEAAsC;SAAC;QACnDG,SAAS;YAACH,kEAAsC;SAAC;IACnD;AACF"}

package/dist/src/compiler/definition-compiler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definition-compiler.d.ts","sourceRoot":"","sources":["../../../src/compiler/definition-compiler.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC;AAE1B,OAAO,EAEL,KAAK,aAAa,EAWnB,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,UAAU,EAAyB,MAAM,gBAAgB,CAAC;AAGnE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAMhE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAExD;;;;;;;;GAQG;AACH,qBAAa,qBAAsB,SAAQ,UAAU;IACnD,QAAQ,CAAC,IAAI,wBAAwB;gBACzB,KAAK,EAAE,MAAM;CAG1B;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBACa,kBAAkB;IAC7B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAuC;IAC9D,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA6B;IAEvD;;;OAGG;IACH,qBAAqB,CAAC,UAAU,EAAE,aAAa,GAAG,aAAa;IAiD/D;;;OAGG;IACH,wBAAwB,CAAC,MAAM,EAAE,gBAAgB,GAAG,aAAa;IAqBjE;;;;;;;;;;;;;;;;;OAiBG;IACH,OAAO,CAAC,gBAAgB;IAkBxB;;;;;;;OAOG;IACH,OAAO,CAAC,gBAAgB;IAoBxB;;;;;;OAMG;IACH,OAAO,CAAC,cAAc;IA+DtB,OAAO,CAAC,kBAAkB;IAsB1B;;;;;;;;OAQG;IACH,OAAO,CAAC,cAAc;CAavB"}
+{"version":3,"file":"definition-compiler.d.ts","sourceRoot":"","sources":["../../../src/compiler/definition-compiler.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC;AAE1B,OAAO,EAEL,KAAK,aAAa,EAWnB,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,UAAU,EAAyB,MAAM,gBAAgB,CAAC;AAGnE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAMhE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAExD;;;;;;;;GAQG;AACH,qBAAa,qBAAsB,SAAQ,UAAU;IACnD,QAAQ,CAAC,IAAI,wBAAwB;gBACzB,KAAK,EAAE,MAAM;CAG1B;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBACa,kBAAkB;IAC7B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAuC;IAC9D,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA6B;IAEvD;;;OAGG;IACH,qBAAqB,CAAC,UAAU,EAAE,aAAa,GAAG,aAAa;IAkD/D;;;OAGG;IACH,wBAAwB,CAAC,MAAM,EAAE,gBAAgB,GAAG,aAAa;IAqBjE;;;;;;;;;;;;;;;;;OAiBG;IACH,OAAO,CAAC,gBAAgB;IAkBxB;;;;;;;OAOG;IACH,OAAO,CAAC,gBAAgB;IAoBxB;;;;;;OAMG;IACH,OAAO,CAAC,cAAc;IAqEtB,OAAO,CAAC,kBAAkB;IAsB1B;;;;;;;;OAQG;IACH,OAAO,CAAC,cAAc;CAavB"}

package/dist/src/compiler/definition-compiler.js

@@ -58,6 +58,9 @@ let DefinitionCompiler = class DefinitionCompiler {
         const listenerDefs = discovered.listenerMethods.map((l)=>({
                 kind: l.kind,
                 phase: l.phase,
+                ...l.skipKind !== undefined ? {
+                    skipKind: l.skipKind
+                } : {},
                 nonCritical: l.nonCritical,
                 ref: this.buildListenerRef(discovered, classToken, l.methodName)
             }));

package/dist/src/compiler/definition-compiler.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/compiler/definition-compiler.ts"],"sourcesContent":["import 'reflect-metadata';\nimport { Injectable, Logger } from '@nestjs/common';\nimport {\n  RefKind,\n  type JobDefinition,\n  type StepDefinition,\n  type ChunkStepDefinition,\n  type TaskletStepDefinition,\n  type ReaderRef,\n  type ProcessorRef,\n  type WriterRef,\n  type TaskletRef,\n  type ListenerRef,\n  type ListenerDefinition,\n  type TransitionDefinition,\n} from '../core/ir';\nimport { FlowExecutionStatus } from '../core/status';\nimport { BatchError, InvalidFlowGraphError } from '../core/errors';\nimport { DefinitionValidator } from '../core/validation/definition-validator';\nimport { validatePartitions, InvalidPartitionsError } from '../partition-helpers';\nimport type { DiscoveredJob } from '../explorer/batch-explorer';\nimport {\n  BATCH_ITEM_READER_METADATA,\n  BATCH_ITEM_PROCESSOR_METADATA,\n  BATCH_ITEM_WRITER_METADATA,\n} from '../decorators/constants';\nimport type { JobBuilderConfig } from './builder-types';\n\n/**\n * Thrown when a chunk step on a discovered class cannot resolve a required\n * item handler method (`@ItemReader` or `@ItemWriter`) on the class prototype.\n *\n * Distinct from `InvalidFlowGraphError` because this is a *static* class-shape\n * problem (the class is missing a decorator), not a flow-graph problem\n * (transitions, start, reachability). The `code` is stable for callers\n * that want to switch on it.\n */\nexport class ProviderNotFoundError extends BatchError {\n  readonly code = 'PROVIDER_NOT_FOUND';\n  constructor(token: string) {\n    super(`Provider not found: ${token}`, { token });\n  }\n}\n\n/**\n * `DefinitionCompiler` is the bridge between metadata-rich sources\n * (decorator-discovered classes, fluent builder configs) and the\n * `JobDefinition` IR consumed by the rest of the runtime.\n *\n * Two compilation paths share the same output type:\n *\n *   - `compileFromDiscovered(discovered)` walks the class prototype\n *     (resolved by `BatchExplorer` in Task 7) and binds reader /\n *     processor / writer / tasklet / listener methods into `Ref`s.\n *   - `compileFromBuilderConfig(config)` accepts a plain-data config\n *     from the builder API and copies it into a `JobDefinition`.\n *\n * Both paths run the same `DefinitionValidator` before returning, so\n * downstream consumers can assume the IR is structurally sound.\n *\n * The compiler does NOT register the job — that is `JobRegistry`'s job\n * (Task 9). The compiler is pure: it produces IR, nothing else.\n */\n@Injectable()\nexport class DefinitionCompiler {\n  private readonly logger = new Logger(DefinitionCompiler.name);\n  private readonly validator = new DefinitionValidator();\n\n  /**\n   * Compile from a discovered class. Resolves reader/processor/writer methods\n   * on the class prototype and assembles StepDefinitions. Validates before returning.\n   */\n  compileFromDiscovered(discovered: DiscoveredJob): JobDefinition {\n    const steps: Record<string, StepDefinition> = {};\n    const startStepId = discovered.stepMethods[0]?.options.id ?? '';\n    const classToken = discovered.classRef.name;\n\n    for (const step of discovered.stepMethods) {\n      if (step.isTasklet) {\n        steps[step.options.id] = this.buildTaskletStep(discovered, classToken, step);\n      } else {\n        steps[step.options.id] = this.buildChunkStep(discovered, classToken, step);\n      }\n    }\n\n    const listenerDefs: ListenerDefinition[] = discovered.listenerMethods.map((l) => ({\n      kind: l.kind,\n      phase: l.phase,\n      nonCritical: l.nonCritical,\n      ref: this.buildListenerRef(discovered, classToken, l.methodName),\n    }));\n\n    const transitions: TransitionDefinition[] = discovered.transitionMethods.map((t) => ({\n      fromStepId: t.fromStep,\n      onStatus:\n        (FlowExecutionStatus as Record<string, FlowExecutionStatus>)[t.onStatus] ??\n        FlowExecutionStatus.UNKNOWN,\n      toStepId: t.toStep,\n    }));\n\n    const job: JobDefinition = {\n      id: discovered.jobOptions.id,\n      steps,\n      startStepId,\n      transitions,\n      deciders: [],\n      listeners: listenerDefs,\n      restartable: discovered.jobOptions.restartable ?? false,\n      allowDuplicateInstances: discovered.jobOptions.allowDuplicateInstances ?? false,\n    };\n\n    this.logger.log(\n      `Compiled job \"${job.id}\" from \"${classToken}\": ${\n        Object.keys(steps).length\n      } step(s), ${listenerDefs.length} listener(s), ${transitions.length} transition(s)`,\n    );\n\n    this.validator.validate(job);\n    return job;\n  }\n\n  /**\n   * Compile from a builder config. Used by the fluent Builder API.\n   * Same validation as `compileFromDiscovered`.\n   */\n  compileFromBuilderConfig(config: JobBuilderConfig): JobDefinition {\n    const steps: Record<string, StepDefinition> = {};\n    for (const s of config.steps) {\n      steps[s.id] = s;\n    }\n    const job: JobDefinition = {\n      id: config.id,\n      steps,\n      startStepId: config.startStepId,\n      transitions: config.transitions,\n      deciders: config.deciders ?? [],\n      listeners: config.listeners,\n      restartable: config.restartable,\n      allowDuplicateInstances: config.allowDuplicateInstances,\n    };\n    this.validator.validate(job);\n    return job;\n  }\n\n  // --- private helpers --------------------------------------------------\n\n  /**\n   * Resolve a listener method on a discovered class to a callable\n   * `ListenerRef`. Mirrors the tasklet-ref resolution in\n   * `buildTaskletStep`: if the DI container has already instantiated\n   * the class (which is the case by the time the explorer walks\n   * providers at `onModuleInit`), the method is pre-bound to the\n   * instance and the returned ref is a `BuilderLambda` carrying the\n   * bound function. This lets the runtime resolver map call the\n   * listener directly without holding onto the instance or a\n   * `ModuleRef`.\n   *\n   * When the instance is not yet available (factory providers that\n   * have not been instantiated, late-bound providers, etc.) the ref\n   * stays as a `Method` and the runtime resolver will throw a\n   * deterministic error if it cannot resolve the class. The\n   * pre-binding is a pure optimisation for the common\n   * `providers: [MyClass]` case — the test suite exercises that path.\n   */\n  private buildListenerRef(\n    discovered: DiscoveredJob,\n    classToken: string,\n    methodName: string,\n  ): ListenerRef {\n    const instance = discovered.instance as\n      | Record<string, (...args: unknown[]) => unknown>\n      | undefined;\n    const method = instance?.[methodName];\n    if (method) {\n      return {\n        kind: RefKind.BuilderLambda,\n        fn: method.bind(discovered.instance) as (...args: any[]) => unknown,\n      };\n    }\n    return { kind: RefKind.Method, classToken, methodName };\n  }\n\n  /**\n   * Build a `TaskletStepDefinition` for a `@Stepable` + `@Tasklet` method.\n   *\n   * If a DI-resolved instance is available on the `DiscoveredJob`, the\n   * tasklet ref is a `BuilderLambda` (bound function) so the executor\n   * can call it directly. Otherwise we fall back to a `Method` ref that\n   * the executor resolves at runtime against the DI container.\n   */\n  private buildTaskletStep(\n    discovered: DiscoveredJob,\n    classToken: string,\n    step: DiscoveredJob['stepMethods'][number],\n  ): TaskletStepDefinition {\n    const instance = discovered.instance as\n      | Record<string, (...args: unknown[]) => unknown>\n      | undefined;\n    const method = instance?.[step.methodName];\n    const taskletRef: TaskletRef = method\n      ? { kind: RefKind.BuilderLambda, fn: () => method.bind(discovered.instance) }\n      : { kind: RefKind.Method, classToken, methodName: step.methodName };\n    return {\n      kind: 'tasklet',\n      id: step.options.id,\n      tasklet: taskletRef,\n      listeners: [],\n    };\n  }\n\n  /**\n   * Build a `ChunkStepDefinition` for a `@Stepable` (no `@Tasklet`) method.\n   * Requires `@ItemReader` and `@ItemWriter` on the class; `@ItemProcessor`\n   * is optional.\n   *\n   * Throws `ProviderNotFoundError` if a required handler is missing.\n   */\n  private buildChunkStep(\n    discovered: DiscoveredJob,\n    classToken: string,\n    step: DiscoveredJob['stepMethods'][number],\n  ): ChunkStepDefinition {\n    const reader = this.findItemMethod(discovered, BATCH_ITEM_READER_METADATA);\n    const processor = this.findItemMethod(discovered, BATCH_ITEM_PROCESSOR_METADATA);\n    const writer = this.findItemMethod(discovered, BATCH_ITEM_WRITER_METADATA);\n\n    if (!reader) {\n      throw new ProviderNotFoundError(\n        `@ItemReader for job ${discovered.jobOptions.id} (step ${step.options.id})`,\n      );\n    }\n    if (!writer) {\n      throw new ProviderNotFoundError(\n        `@ItemWriter for job ${discovered.jobOptions.id} (step ${step.options.id})`,\n      );\n    }\n\n    const readerRef: ReaderRef = this.buildItemMethodRef(discovered, classToken, reader);\n    const writerRef: WriterRef = this.buildItemMethodRef(discovered, classToken, writer);\n\n    // Validate the partition config at compile time so a typo\n    // (e.g. `count: 0`) fails at module load rather than at\n    // runtime when the launcher pre-creates the execution.\n    // `DefinitionValidator.validate` does the same check later\n    // (the IR is the source of truth), but the compiler is the\n    // first place we have the value in hand and we want the\n    // earliest possible failure for a decorator-discovered job.\n    try {\n      validatePartitions(step.options.partitions);\n    } catch (err) {\n      if (err instanceof InvalidPartitionsError) {\n        throw new InvalidFlowGraphError(\n          'INVALID_PARTITIONS',\n          `Step \"${step.options.id}\" has invalid partitions: ${err.message}`,\n          { jobId: discovered.jobOptions.id, stepId: step.options.id, partitions: step.options.partitions },\n        );\n      }\n      throw err;\n    }\n\n    return {\n      kind: 'chunk',\n      id: step.options.id,\n      chunkSize: step.options.chunkSize ?? 100,\n      reader: readerRef,\n      writer: writerRef,\n      skipPolicy: step.options.skipPolicy,\n      retryPolicy: step.options.retryPolicy,\n      listeners: [],\n      ...(step.options.partitions !== undefined\n        ? { partitions: step.options.partitions }\n        : {}),\n      ...(processor\n        ? {\n            processor: this.buildItemMethodRef(discovered, classToken, processor) satisfies ProcessorRef,\n          }\n        : {}),\n    };\n  }\n\n  private buildItemMethodRef(\n    discovered: DiscoveredJob,\n    classToken: string,\n    methodName: string,\n  ): ReaderRef | ProcessorRef | WriterRef {\n    const instance = discovered.instance as\n      | Record<string, (...args: unknown[]) => unknown>\n      | undefined;\n    const method = instance?.[methodName];\n    if (method) {\n      return {\n        kind: RefKind.BuilderLambda,\n        fn: () => method.bind(discovered.instance),\n      };\n    }\n    return {\n      kind: RefKind.Method,\n      classToken,\n      methodName,\n    };\n  }\n\n  /**\n   * Walks the prototype chain (including inherited prototypes, stopping\n   * at `Object.prototype`) looking for a method carrying the given\n   * `BATCH_ITEM_*` metadata key.\n   *\n   * Returns the method name or `undefined`. The explorer only records\n   * `@Stepable` / listener / transition methods; item handlers are\n   * resolved here at compile time.\n   */\n  private findItemMethod(discovered: DiscoveredJob, metadataKey: string): string | undefined {\n    const proto = discovered.classRef.prototype as object | undefined;\n    if (!proto) return undefined;\n    let p: object | null = proto;\n    while (p && p !== Object.prototype) {\n      for (const name of Object.getOwnPropertyNames(p)) {\n        if (name === 'constructor') continue;\n        if (Reflect.getMetadata(metadataKey, p, name) === true) return name;\n      }\n      p = Object.getPrototypeOf(p);\n    }\n    return undefined;\n  }\n}\n"],"names":["DefinitionCompiler","ProviderNotFoundError","BatchError","code","token","logger","Logger","name","validator","DefinitionValidator","compileFromDiscovered","discovered","steps","startStepId","stepMethods","options","id","classToken","classRef","step","isTasklet","buildTaskletStep","buildChunkStep","listenerDefs","listenerMethods","map","l","kind","phase","nonCritical","ref","buildListenerRef","methodName","transitions","transitionMethods","t","fromStepId","fromStep","onStatus","FlowExecutionStatus","UNKNOWN","toStepId","toStep","job","jobOptions","deciders","listeners","restartable","allowDuplicateInstances","log","Object","keys","length","validate","compileFromBuilderConfig","config","s","instance","method","RefKind","BuilderLambda","fn","bind","Method","taskletRef","tasklet","reader","findItemMethod","BATCH_ITEM_READER_METADATA","processor","BATCH_ITEM_PROCESSOR_METADATA","writer","BATCH_ITEM_WRITER_METADATA","readerRef","buildItemMethodRef","writerRef","validatePartitions","partitions","err","InvalidPartitionsError","InvalidFlowGraphError","message","jobId","stepId","chunkSize","skipPolicy","retryPolicy","undefined","metadataKey","proto","prototype","p","getOwnPropertyNames","Reflect","getMetadata","getPrototypeOf"],"mappings":"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"}
+{"version":3,"sources":["../../../src/compiler/definition-compiler.ts"],"sourcesContent":["import 'reflect-metadata';\nimport { Injectable, Logger } from '@nestjs/common';\nimport {\n  RefKind,\n  type JobDefinition,\n  type StepDefinition,\n  type ChunkStepDefinition,\n  type TaskletStepDefinition,\n  type ReaderRef,\n  type ProcessorRef,\n  type WriterRef,\n  type TaskletRef,\n  type ListenerRef,\n  type ListenerDefinition,\n  type TransitionDefinition,\n} from '../core/ir';\nimport { FlowExecutionStatus } from '../core/status';\nimport { BatchError, InvalidFlowGraphError } from '../core/errors';\nimport { DefinitionValidator } from '../core/validation/definition-validator';\nimport { validatePartitions, InvalidPartitionsError } from '../partition-helpers';\nimport type { DiscoveredJob } from '../explorer/batch-explorer';\nimport {\n  BATCH_ITEM_READER_METADATA,\n  BATCH_ITEM_PROCESSOR_METADATA,\n  BATCH_ITEM_WRITER_METADATA,\n} from '../decorators/constants';\nimport type { JobBuilderConfig } from './builder-types';\n\n/**\n * Thrown when a chunk step on a discovered class cannot resolve a required\n * item handler method (`@ItemReader` or `@ItemWriter`) on the class prototype.\n *\n * Distinct from `InvalidFlowGraphError` because this is a *static* class-shape\n * problem (the class is missing a decorator), not a flow-graph problem\n * (transitions, start, reachability). The `code` is stable for callers\n * that want to switch on it.\n */\nexport class ProviderNotFoundError extends BatchError {\n  readonly code = 'PROVIDER_NOT_FOUND';\n  constructor(token: string) {\n    super(`Provider not found: ${token}`, { token });\n  }\n}\n\n/**\n * `DefinitionCompiler` is the bridge between metadata-rich sources\n * (decorator-discovered classes, fluent builder configs) and the\n * `JobDefinition` IR consumed by the rest of the runtime.\n *\n * Two compilation paths share the same output type:\n *\n *   - `compileFromDiscovered(discovered)` walks the class prototype\n *     (resolved by `BatchExplorer` in Task 7) and binds reader /\n *     processor / writer / tasklet / listener methods into `Ref`s.\n *   - `compileFromBuilderConfig(config)` accepts a plain-data config\n *     from the builder API and copies it into a `JobDefinition`.\n *\n * Both paths run the same `DefinitionValidator` before returning, so\n * downstream consumers can assume the IR is structurally sound.\n *\n * The compiler does NOT register the job — that is `JobRegistry`'s job\n * (Task 9). The compiler is pure: it produces IR, nothing else.\n */\n@Injectable()\nexport class DefinitionCompiler {\n  private readonly logger = new Logger(DefinitionCompiler.name);\n  private readonly validator = new DefinitionValidator();\n\n  /**\n   * Compile from a discovered class. Resolves reader/processor/writer methods\n   * on the class prototype and assembles StepDefinitions. Validates before returning.\n   */\n  compileFromDiscovered(discovered: DiscoveredJob): JobDefinition {\n    const steps: Record<string, StepDefinition> = {};\n    const startStepId = discovered.stepMethods[0]?.options.id ?? '';\n    const classToken = discovered.classRef.name;\n\n    for (const step of discovered.stepMethods) {\n      if (step.isTasklet) {\n        steps[step.options.id] = this.buildTaskletStep(discovered, classToken, step);\n      } else {\n        steps[step.options.id] = this.buildChunkStep(discovered, classToken, step);\n      }\n    }\n\n    const listenerDefs: ListenerDefinition[] = discovered.listenerMethods.map((l) => ({\n      kind: l.kind,\n      phase: l.phase,\n      ...(l.skipKind !== undefined ? { skipKind: l.skipKind } : {}),\n      nonCritical: l.nonCritical,\n      ref: this.buildListenerRef(discovered, classToken, l.methodName),\n    }));\n\n    const transitions: TransitionDefinition[] = discovered.transitionMethods.map((t) => ({\n      fromStepId: t.fromStep,\n      onStatus:\n        (FlowExecutionStatus as Record<string, FlowExecutionStatus>)[t.onStatus] ??\n        FlowExecutionStatus.UNKNOWN,\n      toStepId: t.toStep,\n    }));\n\n    const job: JobDefinition = {\n      id: discovered.jobOptions.id,\n      steps,\n      startStepId,\n      transitions,\n      deciders: [],\n      listeners: listenerDefs,\n      restartable: discovered.jobOptions.restartable ?? false,\n      allowDuplicateInstances: discovered.jobOptions.allowDuplicateInstances ?? false,\n    };\n\n    this.logger.log(\n      `Compiled job \"${job.id}\" from \"${classToken}\": ${\n        Object.keys(steps).length\n      } step(s), ${listenerDefs.length} listener(s), ${transitions.length} transition(s)`,\n    );\n\n    this.validator.validate(job);\n    return job;\n  }\n\n  /**\n   * Compile from a builder config. Used by the fluent Builder API.\n   * Same validation as `compileFromDiscovered`.\n   */\n  compileFromBuilderConfig(config: JobBuilderConfig): JobDefinition {\n    const steps: Record<string, StepDefinition> = {};\n    for (const s of config.steps) {\n      steps[s.id] = s;\n    }\n    const job: JobDefinition = {\n      id: config.id,\n      steps,\n      startStepId: config.startStepId,\n      transitions: config.transitions,\n      deciders: config.deciders ?? [],\n      listeners: config.listeners,\n      restartable: config.restartable,\n      allowDuplicateInstances: config.allowDuplicateInstances,\n    };\n    this.validator.validate(job);\n    return job;\n  }\n\n  // --- private helpers --------------------------------------------------\n\n  /**\n   * Resolve a listener method on a discovered class to a callable\n   * `ListenerRef`. Mirrors the tasklet-ref resolution in\n   * `buildTaskletStep`: if the DI container has already instantiated\n   * the class (which is the case by the time the explorer walks\n   * providers at `onModuleInit`), the method is pre-bound to the\n   * instance and the returned ref is a `BuilderLambda` carrying the\n   * bound function. This lets the runtime resolver map call the\n   * listener directly without holding onto the instance or a\n   * `ModuleRef`.\n   *\n   * When the instance is not yet available (factory providers that\n   * have not been instantiated, late-bound providers, etc.) the ref\n   * stays as a `Method` and the runtime resolver will throw a\n   * deterministic error if it cannot resolve the class. The\n   * pre-binding is a pure optimisation for the common\n   * `providers: [MyClass]` case — the test suite exercises that path.\n   */\n  private buildListenerRef(\n    discovered: DiscoveredJob,\n    classToken: string,\n    methodName: string,\n  ): ListenerRef {\n    const instance = discovered.instance as\n      | Record<string, (...args: unknown[]) => unknown>\n      | undefined;\n    const method = instance?.[methodName];\n    if (method) {\n      return {\n        kind: RefKind.BuilderLambda,\n        fn: method.bind(discovered.instance) as (...args: any[]) => unknown,\n      };\n    }\n    return { kind: RefKind.Method, classToken, methodName };\n  }\n\n  /**\n   * Build a `TaskletStepDefinition` for a `@Stepable` + `@Tasklet` method.\n   *\n   * If a DI-resolved instance is available on the `DiscoveredJob`, the\n   * tasklet ref is a `BuilderLambda` (bound function) so the executor\n   * can call it directly. Otherwise we fall back to a `Method` ref that\n   * the executor resolves at runtime against the DI container.\n   */\n  private buildTaskletStep(\n    discovered: DiscoveredJob,\n    classToken: string,\n    step: DiscoveredJob['stepMethods'][number],\n  ): TaskletStepDefinition {\n    const instance = discovered.instance as\n      | Record<string, (...args: unknown[]) => unknown>\n      | undefined;\n    const method = instance?.[step.methodName];\n    const taskletRef: TaskletRef = method\n      ? { kind: RefKind.BuilderLambda, fn: () => method.bind(discovered.instance) }\n      : { kind: RefKind.Method, classToken, methodName: step.methodName };\n    return {\n      kind: 'tasklet',\n      id: step.options.id,\n      tasklet: taskletRef,\n      listeners: [],\n    };\n  }\n\n  /**\n   * Build a `ChunkStepDefinition` for a `@Stepable` (no `@Tasklet`) method.\n   * Requires `@ItemReader` and `@ItemWriter` on the class; `@ItemProcessor`\n   * is optional.\n   *\n   * Throws `ProviderNotFoundError` if a required handler is missing.\n   */\n  private buildChunkStep(\n    discovered: DiscoveredJob,\n    classToken: string,\n    step: DiscoveredJob['stepMethods'][number],\n  ): ChunkStepDefinition {\n    const reader = this.findItemMethod(discovered, BATCH_ITEM_READER_METADATA);\n    const processor = this.findItemMethod(discovered, BATCH_ITEM_PROCESSOR_METADATA);\n    const writer = this.findItemMethod(discovered, BATCH_ITEM_WRITER_METADATA);\n\n    if (!reader) {\n      throw new ProviderNotFoundError(\n        `@ItemReader for job ${discovered.jobOptions.id} (step ${step.options.id})`,\n      );\n    }\n    if (!writer) {\n      throw new ProviderNotFoundError(\n        `@ItemWriter for job ${discovered.jobOptions.id} (step ${step.options.id})`,\n      );\n    }\n\n    const readerRef: ReaderRef = this.buildItemMethodRef(discovered, classToken, reader);\n    const writerRef: WriterRef = this.buildItemMethodRef(discovered, classToken, writer);\n\n    // Validate the partition config at compile time so a typo\n    // (e.g. `count: 0`) fails at module load rather than at\n    // runtime when the launcher pre-creates the execution.\n    // `DefinitionValidator.validate` does the same check later\n    // (the IR is the source of truth), but the compiler is the\n    // first place we have the value in hand and we want the\n    // earliest possible failure for a decorator-discovered job.\n    try {\n      validatePartitions(step.options.partitions);\n    } catch (err) {\n      if (err instanceof InvalidPartitionsError) {\n        throw new InvalidFlowGraphError(\n          'INVALID_PARTITIONS',\n          `Step \"${step.options.id}\" has invalid partitions: ${err.message}`,\n          {\n            jobId: discovered.jobOptions.id,\n            stepId: step.options.id,\n            partitions: step.options.partitions,\n          },\n        );\n      }\n      throw err;\n    }\n\n    return {\n      kind: 'chunk',\n      id: step.options.id,\n      chunkSize: step.options.chunkSize ?? 100,\n      reader: readerRef,\n      writer: writerRef,\n      skipPolicy: step.options.skipPolicy,\n      retryPolicy: step.options.retryPolicy,\n      listeners: [],\n      ...(step.options.partitions !== undefined ? { partitions: step.options.partitions } : {}),\n      ...(processor\n        ? {\n            processor: this.buildItemMethodRef(\n              discovered,\n              classToken,\n              processor,\n            ) satisfies ProcessorRef,\n          }\n        : {}),\n    };\n  }\n\n  private buildItemMethodRef(\n    discovered: DiscoveredJob,\n    classToken: string,\n    methodName: string,\n  ): ReaderRef | ProcessorRef | WriterRef {\n    const instance = discovered.instance as\n      | Record<string, (...args: unknown[]) => unknown>\n      | undefined;\n    const method = instance?.[methodName];\n    if (method) {\n      return {\n        kind: RefKind.BuilderLambda,\n        fn: () => method.bind(discovered.instance),\n      };\n    }\n    return {\n      kind: RefKind.Method,\n      classToken,\n      methodName,\n    };\n  }\n\n  /**\n   * Walks the prototype chain (including inherited prototypes, stopping\n   * at `Object.prototype`) looking for a method carrying the given\n   * `BATCH_ITEM_*` metadata key.\n   *\n   * Returns the method name or `undefined`. The explorer only records\n   * `@Stepable` / listener / transition methods; item handlers are\n   * resolved here at compile time.\n   */\n  private findItemMethod(discovered: DiscoveredJob, metadataKey: string): string | undefined {\n    const proto = discovered.classRef.prototype as object | undefined;\n    if (!proto) return undefined;\n    let p: object | null = proto;\n    while (p && p !== Object.prototype) {\n      for (const name of Object.getOwnPropertyNames(p)) {\n        if (name === 'constructor') continue;\n        if (Reflect.getMetadata(metadataKey, p, name) === true) return name;\n      }\n      p = Object.getPrototypeOf(p);\n    }\n    return undefined;\n  }\n}\n"],"names":["DefinitionCompiler","ProviderNotFoundError","BatchError","code","token","logger","Logger","name","validator","DefinitionValidator","compileFromDiscovered","discovered","steps","startStepId","stepMethods","options","id","classToken","classRef","step","isTasklet","buildTaskletStep","buildChunkStep","listenerDefs","listenerMethods","map","l","kind","phase","skipKind","undefined","nonCritical","ref","buildListenerRef","methodName","transitions","transitionMethods","t","fromStepId","fromStep","onStatus","FlowExecutionStatus","UNKNOWN","toStepId","toStep","job","jobOptions","deciders","listeners","restartable","allowDuplicateInstances","log","Object","keys","length","validate","compileFromBuilderConfig","config","s","instance","method","RefKind","BuilderLambda","fn","bind","Method","taskletRef","tasklet","reader","findItemMethod","BATCH_ITEM_READER_METADATA","processor","BATCH_ITEM_PROCESSOR_METADATA","writer","BATCH_ITEM_WRITER_METADATA","readerRef","buildItemMethodRef","writerRef","validatePartitions","partitions","err","InvalidPartitionsError","InvalidFlowGraphError","message","jobId","stepId","chunkSize","skipPolicy","retryPolicy","metadataKey","proto","prototype","p","getOwnPropertyNames","Reflect","getMetadata","getPrototypeOf"],"mappings":"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"}

package/dist/src/core/ir/listener-definition.d.ts

@@ -1,10 +1,12 @@
 import type { ListenerRef } from './refs';
 export type ListenerKind = 'job' | 'step' | 'chunk' | 'item-read' | 'item-process' | 'item-write' | 'skip' | 'transition';
 export type ListenerPhase = 'before' | 'after' | 'on-error';
+export type SkipSubKind = 'read' | 'process' | 'write';
 export interface ListenerDefinition {
     kind: ListenerKind;
     ref: ListenerRef;
     phase: ListenerPhase;
+    skipKind?: SkipSubKind;
     nonCritical?: boolean;
 }
 //# sourceMappingURL=listener-definition.d.ts.map

package/dist/src/core/ir/listener-definition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"listener-definition.d.ts","sourceRoot":"","sources":["../../../../src/core/ir/listener-definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AAE1C,MAAM,MAAM,YAAY,GACpB,KAAK,GACL,MAAM,GACN,OAAO,GACP,WAAW,GACX,cAAc,GACd,YAAY,GACZ,MAAM,GACN,YAAY,CAAC;AACjB,MAAM,MAAM,aAAa,GAAG,QAAQ,GAAG,OAAO,GAAG,UAAU,CAAC;AAE5D,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,YAAY,CAAC;IACnB,GAAG,EAAE,WAAW,CAAC;IACjB,KAAK,EAAE,aAAa,CAAC;IACrB,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB"}
+{"version":3,"file":"listener-definition.d.ts","sourceRoot":"","sources":["../../../../src/core/ir/listener-definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AAE1C,MAAM,MAAM,YAAY,GACpB,KAAK,GACL,MAAM,GACN,OAAO,GACP,WAAW,GACX,cAAc,GACd,YAAY,GACZ,MAAM,GACN,YAAY,CAAC;AACjB,MAAM,MAAM,aAAa,GAAG,QAAQ,GAAG,OAAO,GAAG,UAAU,CAAC;AAC5D,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,SAAS,GAAG,OAAO,CAAC;AAEvD,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,YAAY,CAAC;IACnB,GAAG,EAAE,WAAW,CAAC;IACjB,KAAK,EAAE,aAAa,CAAC;IACrB,QAAQ,CAAC,EAAE,WAAW,CAAC;IACvB,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB"}

package/dist/src/core/item/interfaces.d.ts

@@ -1,18 +1,27 @@
-import type { ExecutionContext } from '../repository/types';
+import type { ExecutionContext, JobParameters } from '../repository/types';
 type MaybePromise<T> = T | Promise<T>;
 /**
  * Reads one item at a time. Returns `null` to signal EOF.
  * For async iteration, use `AsyncIterable.read()` (not yet supported in MVP).
  */
+export interface ItemExecutionContext {
+    readonly jobExecutionId: string;
+    readonly stepExecutionId: string;
+    readonly stepName: string;
+    readonly jobParameters: JobParameters;
+    readonly chunkIndex?: number;
+    getExecutionContext(): Promise<ExecutionContext>;
+    saveExecutionContext(ctx: ExecutionContext): Promise<void>;
+}
 export interface ItemReader<T = unknown> {
-    read(): Promise<T | null>;
+    read(ctx?: ItemExecutionContext): Promise<T | null>;
 }
 /**
  * Processes one item. Returns `null`/`undefined` to filter the item out of the chunk.
  * Throws to indicate the item should be skipped (via SkipPolicy) or retried (via RetryPolicy).
  */
 export interface ItemProcessor<I = unknown, O = unknown> {
-    process(item: I): Promise<O | null | undefined>;
+    process(item: I, ctx?: ItemExecutionContext): Promise<O | null | undefined>;
 }
 /**
  * Writes a batch of items. Called once per chunk (after processing).
@@ -24,7 +33,7 @@ export interface ItemProcessor<I = unknown, O = unknown> {
  * count and assumes no per-item skips.
  */
 export interface ItemWriter<T = unknown> {
-    write(items: T[]): Promise<WriterResult | void>;
+    write(items: T[], ctx?: ItemExecutionContext): Promise<WriterResult | void>;
 }
 export interface WriterResult {
     written: number;
@@ -50,6 +59,7 @@ export interface ItemStream {
 export interface TaskletContext {
     readonly jobExecutionId: string;
     readonly stepExecutionId: string;
+    readonly jobParameters: JobParameters;
     getExecutionContext(): Promise<ExecutionContext>;
     saveExecutionContext(ctx: ExecutionContext): Promise<void>;
 }

package/dist/src/core/item/interfaces.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"interfaces.d.ts","sourceRoot":"","sources":["../../../../src/core/item/interfaces.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAkB,MAAM,qBAAqB,CAAC;AAE5E,KAAK,YAAY,CAAC,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;AAEtC;;;GAGG;AACH,MAAM,WAAW,UAAU,CAAC,CAAC,GAAG,OAAO;IACrC,IAAI,IAAI,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;CAC3B;AAED;;;GAGG;AACH,MAAM,WAAW,aAAa,CAAC,CAAC,GAAG,OAAO,EAAE,CAAC,GAAG,OAAO;IACrD,OAAO,CAAC,IAAI,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,GAAG,SAAS,CAAC,CAAC;CACjD;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,UAAU,CAAC,CAAC,GAAG,OAAO;IACrC,KAAK,CAAC,KAAK,EAAE,CAAC,EAAE,GAAG,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAAC;CACjD;AAED,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,UAAU;IACzB,IAAI,CAAC,OAAO,EAAE,gBAAgB,GAAG,YAAY,CAAC,IAAI,CAAC,CAAC;IACpD,MAAM,CAAC,OAAO,EAAE,gBAAgB,GAAG,YAAY,CAAC,gBAAgB,GAAG,IAAI,CAAC,CAAC;IACzE,KAAK,IAAI,YAAY,CAAC,IAAI,CAAC,CAAC;CAC7B;AAED;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,mBAAmB,IAAI,OAAO,CAAC,gBAAgB,CAAC,CAAC;IACjD,oBAAoB,CAAC,GAAG,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC5D;AAED;;;GAGG;AACH,MAAM,WAAW,OAAO;IACtB,OAAO,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CAChD"}
+{"version":3,"file":"interfaces.d.ts","sourceRoot":"","sources":["../../../../src/core/item/interfaces.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAkB,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAE3F,KAAK,YAAY,CAAC,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;AAEtC;;;GAGG;AACH,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,aAAa,EAAE,aAAa,CAAC;IACtC,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,mBAAmB,IAAI,OAAO,CAAC,gBAAgB,CAAC,CAAC;IACjD,oBAAoB,CAAC,GAAG,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC5D;AAED,MAAM,WAAW,UAAU,CAAC,CAAC,GAAG,OAAO;IACrC,IAAI,CAAC,GAAG,CAAC,EAAE,oBAAoB,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;CACrD;AAED;;;GAGG;AACH,MAAM,WAAW,aAAa,CAAC,CAAC,GAAG,OAAO,EAAE,CAAC,GAAG,OAAO;IACrD,OAAO,CAAC,IAAI,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE,oBAAoB,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,GAAG,SAAS,CAAC,CAAC;CAC7E;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,UAAU,CAAC,CAAC,GAAG,OAAO;IACrC,KAAK,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE,GAAG,CAAC,EAAE,oBAAoB,GAAG,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAAC;CAC7E;AAED,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,UAAU;IACzB,IAAI,CAAC,OAAO,EAAE,gBAAgB,GAAG,YAAY,CAAC,IAAI,CAAC,CAAC;IACpD,MAAM,CAAC,OAAO,EAAE,gBAAgB,GAAG,YAAY,CAAC,gBAAgB,GAAG,IAAI,CAAC,CAAC;IACzE,KAAK,IAAI,YAAY,CAAC,IAAI,CAAC,CAAC;CAC7B;AAED;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,aAAa,EAAE,aAAa,CAAC;IACtC,mBAAmB,IAAI,OAAO,CAAC,gBAAgB,CAAC,CAAC;IACjD,oBAAoB,CAAC,GAAG,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC5D;AAED;;;GAGG;AACH,MAAM,WAAW,OAAO;IACtB,OAAO,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CAChD"}

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

@@ -1,5 +1,5 @@
 import 'reflect-metadata';
-import type { ListenerKind, ListenerPhase } from '../core/ir/listener-definition';
+import type { ListenerKind, ListenerPhase, SkipSubKind } from '../core/ir/listener-definition';
 /**
  * Stored under `BATCH_LISTENER_METADATA` for each listener method.
  * Mirrors `ListenerDefinition` minus the resolved `ref` (which the
@@ -7,12 +7,13 @@ import type { ListenerKind, ListenerPhase } from '../core/ir/listener-definition
  *
  * 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.
+ * `phase: 'after'` as a placeholder so the metadata shape stays uniform,
+ * plus `skipKind` so read/process/write skip events remain distinguishable.
  */
 export interface ListenerOptions {
     kind: ListenerKind;
     phase: ListenerPhase;
+    skipKind?: SkipSubKind;
     nonCritical?: boolean;
 }
 /** Fires before a job execution starts. */

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

@@ -1 +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"}
+{"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,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAE/F;;;;;;;;;GASG;AACH,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,YAAY,CAAC;IACnB,KAAK,EAAE,aAAa,CAAC;IACrB,QAAQ,CAAC,EAAE,WAAW,CAAC;IACvB,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAoBD,2CAA2C;AAC3C,eAAO,MAAM,SAAS,QAAO,eAAsE,CAAC;AAEpG,mEAAmE;AACnE,eAAO,MAAM,QAAQ,QAAO,eAAqE,CAAC;AAMlG,4CAA4C;AAC5C,eAAO,MAAM,UAAU,QAAO,eACwB,CAAC;AAEvD,oEAAoE;AACpE,eAAO,MAAM,SAAS,QAAO,eAAsE,CAAC;AAMpG,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,eACyC,CAAC;AAExE,8CAA8C;AAC9C,eAAO,MAAM,aAAa,QAAO,eACyC,CAAC;AAE3E,qCAAqC;AACrC,eAAO,MAAM,WAAW,QAAO,eACyC,CAAC"}

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

@@ -143,15 +143,18 @@ const OnWriteError = ()=>listenerDecorator({
     });
 const OnSkipRead = ()=>listenerDecorator({
         kind: 'skip',
-        phase: 'after'
+        phase: 'after',
+        skipKind: 'read'
     });
 const OnSkipProcess = ()=>listenerDecorator({
         kind: 'skip',
-        phase: 'after'
+        phase: 'after',
+        skipKind: 'process'
     });
 const OnSkipWrite = ()=>listenerDecorator({
         kind: 'skip',
-        phase: 'after'
+        phase: 'after',
+        skipKind: 'write'
     });
 
 //# sourceMappingURL=listener.decorators.js.map

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

@@ -1 +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"}
+{"version":3,"sources":["../../../src/decorators/listener.decorators.ts"],"sourcesContent":["import 'reflect-metadata';\nimport { BATCH_LISTENER_METADATA } from './constants';\nimport type { ListenerKind, ListenerPhase, SkipSubKind } 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 * plus `skipKind` so read/process/write skip events remain distinguishable.\n */\nexport interface ListenerOptions {\n  kind: ListenerKind;\n  phase: ListenerPhase;\n  skipKind?: SkipSubKind;\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 => listenerDecorator({ kind: 'job', phase: 'before' });\n\n/** Fires after a job execution finishes (regardless of status). */\nexport const AfterJob = (): MethodDecorator => 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 => 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, plus `skipKind` for runtime dispatch.\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', skipKind: 'read' });\n\n/** Fires when a processed item is skipped. */\nexport const OnSkipProcess = (): MethodDecorator =>\n  listenerDecorator({ kind: 'skip', phase: 'after', skipKind: 'process' });\n\n/** Fires when a write is skipped. */\nexport const OnSkipWrite = (): MethodDecorator =>\n  listenerDecorator({ kind: 'skip', phase: 'after', skipKind: 'write' });\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","skipKind"],"mappings":";;;;;;;;;;;QAiEaA;eAAAA;;QAtBAC;eAAAA;;QAsDAC;eAAAA;;QAhBAC;eAAAA;;QA3BAC;eAAAA;;QA2DAC;eAAAA;;QApDAC;eAAAA;;QArBAC;eAAAA;;QAqDAC;eAAAA;;QAhBAC;eAAAA;;QA3BAC;eAAAA;;QA2DAC;eAAAA;;QAxCAC;eAAAA;;QAgCAC;eAAAA;;QAhBAC;eAAAA;;QAiDAC;eAAAA;;QAJAC;eAAAA;;QAQAC;eAAAA;;QArBAC;eAAAA;;;QArHN;2BACiC;AAoBxC,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,IAAuBmB,kBAAkB;QAAEE,MAAM;QAAOC,OAAO;IAAS;AAG1F,MAAM5B,WAAW,IAAuByB,kBAAkB;QAAEE,MAAM;QAAOC,OAAO;IAAQ;AAOxF,MAAMnB,aAAa,IACxBgB,kBAAkB;QAAEE,MAAM;QAAQC,OAAO;IAAS;AAG7C,MAAMzB,YAAY,IAAuBsB,kBAAkB;QAAEE,MAAM;QAAQC,OAAO;IAAQ;AAO1F,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;QAASC,UAAU;IAAO;AAG9D,MAAMf,gBAAgB,IAC3BW,kBAAkB;QAAEE,MAAM;QAAQC,OAAO;QAASC,UAAU;IAAU;AAGjE,MAAMb,cAAc,IACzBS,kBAAkB;QAAEE,MAAM;QAAQC,OAAO;QAASC,UAAU;IAAQ"}

package/dist/src/execution/chunk-step-executor.d.ts

@@ -1,5 +1,5 @@
 import type { ChunkStepDefinition } from '../core/ir';
-import type { JobRepository } from '../core/repository';
+import type { JobParameters, JobRepository } from '../core/repository';
 import type { TransactionManager } from '../core/transaction';
 import { StepStatus } from '../core/status';
 import type { ResolverMap } from './listener-invoker';
@@ -10,9 +10,13 @@ export interface ChunkExecutionContext {
     /** Step execution id, used to scope the chunk-progress checkpoint in the
      *  step's ExecutionContext (saved as `{ lastChunkIndex }`). */
     stepExecutionId: string;
+    stepName?: string;
+    jobParameters?: JobParameters;
     jobRepository: JobRepository;
     transactionManager: TransactionManager;
     listenerInvoker: ListenerInvoker;
+    /** Full listener resolver map keyed by `${phase}:${kind}:${name}`. */
+    listenerResolvers?: ResolverMap;
     /** Map of resolved reader/processor/writer functions by name. */
     resolvers: Map<string, (...args: unknown[]) => unknown | Promise<unknown>>;
     jobExecutionId2: string;
@@ -63,6 +67,8 @@ export interface ChunkExecutionResult {
 }
 export declare class ChunkStepExecutor {
     execute(step: ChunkStepDefinition, context: ChunkExecutionContext): Promise<ChunkExecutionResult>;
+    private buildListenerContext;
+    private buildItemContext;
     private updateStreams;
     private closeStreams;
     /**

package/dist/src/execution/chunk-step-executor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk-step-executor.d.ts","sourceRoot":"","sources":["../../../src/execution/chunk-step-executor.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAsC,MAAM,YAAY,CAAC;AAG1F,OAAO,KAAK,EAAoB,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAC1E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAC9D,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAO5C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,EAAwB,KAAK,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAE9E,MAAM,WAAW,qBAAqB;IACpC,cAAc,EAAE,MAAM,CAAC;IACvB;mEAC+D;IAC/D,eAAe,EAAE,MAAM,CAAC;IACxB,aAAa,EAAE,aAAa,CAAC;IAC7B,kBAAkB,EAAE,kBAAkB,CAAC;IACvC,eAAe,EAAE,eAAe,CAAC;IACjC,iEAAiE;IACjE,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC;IAC3E,eAAe,EAAE,MAAM,CAAC;IACxB,0FAA0F;IAC1F,qBAAqB,CAAC,EAAE,WAAW,CAAC;IACpC;;;;;OAKG;IACH,iBAAiB,CAAC,EAAE,iBAAiB,CAAC;IACtC;;;;;;;OAOG;IACH,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B;;;;;;;;OAQG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;;;;OAKG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,UAAU,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;CACrB;AAwDD,qBACa,iBAAiB;IACtB,OAAO,CACX,IAAI,EAAE,mBAAmB,EACzB,OAAO,EAAE,qBAAqB,GAC7B,OAAO,CAAC,oBAAoB,CAAC;YAoRlB,aAAa;YAcb,YAAY;IAM1B;;;;;;;;;;;;OAYG;YACW,QAAQ;IAkFtB,OAAO,CAAC,aAAa;IAuBrB,OAAO,CAAC,gBAAgB;IAuBxB,OAAO,CAAC,aAAa;CAsBtB"}
+{"version":3,"file":"chunk-step-executor.d.ts","sourceRoot":"","sources":["../../../src/execution/chunk-step-executor.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAsC,MAAM,YAAY,CAAC;AAS1F,OAAO,KAAK,EAAoB,aAAa,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACzF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAC9D,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAO5C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,EAAwB,KAAK,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAE9E,MAAM,WAAW,qBAAqB;IACpC,cAAc,EAAE,MAAM,CAAC;IACvB;mEAC+D;IAC/D,eAAe,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B,aAAa,EAAE,aAAa,CAAC;IAC7B,kBAAkB,EAAE,kBAAkB,CAAC;IACvC,eAAe,EAAE,eAAe,CAAC;IACjC,sEAAsE;IACtE,iBAAiB,CAAC,EAAE,WAAW,CAAC;IAChC,iEAAiE;IACjE,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC;IAC3E,eAAe,EAAE,MAAM,CAAC;IACxB,0FAA0F;IAC1F,qBAAqB,CAAC,EAAE,WAAW,CAAC;IACpC;;;;;OAKG;IACH,iBAAiB,CAAC,EAAE,iBAAiB,CAAC;IACtC;;;;;;;OAOG;IACH,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B;;;;;;;;OAQG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;;;;OAKG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,UAAU,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;CACrB;AA2DD,qBACa,iBAAiB;IACtB,OAAO,CACX,IAAI,EAAE,mBAAmB,EACzB,OAAO,EAAE,qBAAqB,GAC7B,OAAO,CAAC,oBAAoB,CAAC;IA+YhC,OAAO,CAAC,oBAAoB;IAoB5B,OAAO,CAAC,gBAAgB;YAsBV,aAAa;YAcb,YAAY;IAM1B;;;;;;;;;;;;OAYG;YACW,QAAQ;IAsFtB,OAAO,CAAC,aAAa;IA2BrB,OAAO,CAAC,gBAAgB;IA2BxB,OAAO,CAAC,aAAa;CA0BtB"}