@semiont/make-meaning 0.5.29 → 0.5.30

package/dist/index.d.ts

@@ -337,6 +337,25 @@ declare class Stower {
     private handleYieldUpdate;
     private handleYieldMv;
     private handleMarkCreate;
+    /**
+     * Persist a detection unit's annotations as ONE acknowledged batch, then
+     * answer (JOB-RESTART-SAFETY P6).
+     *
+     * The difference from `mark:create` is the reply, and it is the whole point.
+     * `mark:create` is fire-and-forget: the worker's emit resolves when the bus
+     * accepts it, which says nothing about the event log, so a down Stower loses
+     * a unit silently and a flapping one hangs the worker forever. This answers
+     * only after every append has returned, so the worker can gate unit
+     * completion — and its checkpoint — on durability.
+     *
+     * Appends are sequential, not concurrent: the event log is the system of
+     * record and a batch that half-lands under concurrency is harder to reason
+     * about than one that stops at the first failure. A partial batch is
+     * reported as a failure and the worker retries the WHOLE unit, which is safe
+     * because ids are deterministic (P3) and the annotation fold is idempotent
+     * by id — re-appending what already landed changes nothing.
+     */
+    private handleMarkCommit;
     private handleMarkDelete;
     private handleMarkUpdateBody;
     private handleMarkArchive;

package/dist/index.js

@@ -11335,6 +11335,7 @@ var Stower = class {
       pipe("yield:update", (e) => this.handleYieldUpdate(e)),
       pipe("yield:mv", (e) => this.handleYieldMv(e)),
       pipe("mark:create", (e) => this.handleMarkCreate(e)),
+      pipe("mark:commit", (e) => this.handleMarkCommit(e)),
       pipe("mark:delete", (e) => this.handleMarkDelete(e)),
       pipe("mark:update-body", (e) => this.handleMarkUpdateBody(e)),
       pipe("frame:add-entity-type", (e) => this.handleAddEntityType(e)),
@@ -11560,6 +11561,61 @@ var Stower = class {
       });
     }
   }
+  /**
+   * Persist a detection unit's annotations as ONE acknowledged batch, then
+   * answer (JOB-RESTART-SAFETY P6).
+   *
+   * The difference from `mark:create` is the reply, and it is the whole point.
+   * `mark:create` is fire-and-forget: the worker's emit resolves when the bus
+   * accepts it, which says nothing about the event log, so a down Stower loses
+   * a unit silently and a flapping one hangs the worker forever. This answers
+   * only after every append has returned, so the worker can gate unit
+   * completion — and its checkpoint — on durability.
+   *
+   * Appends are sequential, not concurrent: the event log is the system of
+   * record and a batch that half-lands under concurrency is harder to reason
+   * about than one that stops at the first failure. A partial batch is
+   * reported as a failure and the worker retries the WHOLE unit, which is safe
+   * because ids are deterministic (P3) and the annotation fold is idempotent
+   * by id — re-appending what already landed changes nothing.
+   */
+  async handleMarkCommit(event) {
+    if (!event._userId) {
+      throw new Error("mark:commit missing _userId (gateway injection)");
+    }
+    const annotations = event.annotations ?? [];
+    try {
+      let persisted = 0;
+      for (const annotation of annotations) {
+        await this.stores.eventStore.appendEvent({
+          type: "mark:added",
+          resourceId: resourceId(event.resourceId),
+          userId: userId(event._userId),
+          version: 1,
+          payload: { annotation }
+        });
+        persisted++;
+      }
+      this.logger.debug("Committed annotation batch", {
+        correlationId: event.correlationId,
+        resourceId: event.resourceId,
+        persisted
+      });
+      this.eventBus.get("mark:commit-ok").next({
+        correlationId: event.correlationId,
+        response: { persisted, annotationIds: annotations.map((a) => String(a.id)) }
+      });
+    } catch (error) {
+      this.logger.error("Failed to commit annotation batch", {
+        correlationId: event.correlationId,
+        error: errField(error)
+      });
+      this.eventBus.get("mark:commit-failed").next({
+        correlationId: event.correlationId,
+        message: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
   async handleMarkDelete(event) {
     if (!event._userId) {
       throw new Error("mark:delete missing _userId (gateway injection)");
@@ -13194,7 +13250,7 @@ function registerJobCommandHandlers(eventBus, jobQueue, state, parentLogger) {
   });
   eventBus.get("job:fail").subscribe(async (event) => {
     try {
-      const outcome = await jobQueue.failJob(jobId(event.jobId), event.error);
+      const outcome = await jobQueue.failJob(jobId(event.jobId), event.error, event.completedUnits, event.failureClass);
       if (outcome === "retried") {
         logger.info("Job re-queued for retry", { jobId: event.jobId });
       } else if (outcome === null) {
@@ -13220,16 +13276,45 @@ function registerJobCommandHandlers(eventBus, jobQueue, state, parentLogger) {
       });
     }
   });
+  eventBus.get("job:checkpoint").subscribe(async (event) => {
+    try {
+      await jobQueue.checkpointUnits(jobId(event.jobId), event.completedUnits);
+    } catch (error) {
+      logger.error("Failed to checkpoint job units", {
+        jobId: event.jobId,
+        error: error.message
+      });
+    }
+  });
   eventBus.get("job:cancel-requested").subscribe(async (event) => {
     try {
-      const cancelled = await jobQueue.cancelPendingJobs(event.jobType);
-      logger.info("Cancel requested", { jobType: event.jobType, cancelled });
+      let cancelled;
+      if (event.jobId) {
+        const target = await jobQueue.getJob(jobId(event.jobId));
+        if (!target) {
+          cancelled = 0;
+        } else if (target.status === "pending") {
+          cancelled = await jobQueue.cancelJob(jobId(event.jobId)) ? 1 : 0;
+        } else if (target.status === "running") {
+          logger.info("Cancel of running job delegated to its worker", { jobId: event.jobId });
+          cancelled = 1;
+        } else {
+          cancelled = 0;
+        }
+        logger.info("Cancel requested", { jobId: event.jobId, cancelled });
+      } else if (event.jobType) {
+        cancelled = await jobQueue.cancelPendingJobs(event.jobType);
+        logger.info("Cancel requested", { jobType: event.jobType, cancelled });
+      } else {
+        cancelled = 0;
+      }
       eventBus.get("job:cancel-ok").next({
         correlationId: event.correlationId,
         response: { cancelled }
       });
     } catch (error) {
-      logger.error("Failed to cancel pending jobs", {
+      logger.error("Failed to cancel jobs", {
+        jobId: event.jobId,
         jobType: event.jobType,
         error: error.message
       });
@@ -13239,6 +13324,17 @@ function registerJobCommandHandlers(eventBus, jobQueue, state, parentLogger) {
       });
     }
   });
+  eventBus.get("job:cancel").subscribe(async (event) => {
+    try {
+      await jobQueue.cancelJob(jobId(event.jobId));
+      logger.info("Job cancelled by its worker", { jobId: event.jobId });
+    } catch (error) {
+      logger.error("Failed to cancel job", {
+        jobId: event.jobId,
+        error: error.message
+      });
+    }
+  });
 }
 
 // src/handlers/index.ts