@codixus/server 0.1.6 → 0.1.8

package/dist/index.cjs

@@ -33,16 +33,21 @@ __export(index_exports, {
   CodixusError: () => import_shared4.CodixusError,
   CodixusServer: () => CodixusServer,
   ErrorCodes: () => import_shared4.ErrorCodes,
+  JourneyError: () => JourneyError,
   Model: () => Model,
   Query: () => Query,
   RestErrorCode: () => RestErrorCode,
   SubCollection: () => SubCollection,
   createExpoTransport: () => createExpoTransport,
   model: () => model,
-  validate: () => validate
+  validate: () => validate,
+  validateJourneyDefinition: () => validateJourneyDefinition
 });
 module.exports = __toCommonJS(index_exports);
 
+// src/codixus-server.ts
+var import_node_crypto11 = require("crypto");
+
 // src/db/connection.ts
 var import_mongodb = require("mongodb");
 var ConnectionManager = class {
@@ -224,7 +229,7 @@ function createGuard(jwt, banService) {
 var import_express = require("express");
 var import_shared2 = require("@codixus/shared");
 var import_shared3 = require("@codixus/shared");
-function createAuthRouter(jwt, banService, db, config) {
+function createAuthRouter(jwt, banService, db, config, onAuthenticated) {
   const router = (0, import_express.Router)();
   const usersCol = db.collection(config.usersCollection);
   const refreshTokensCol = db.collection("refresh_tokens");
@@ -286,6 +291,11 @@ function createAuthRouter(jwt, banService, db, config) {
           );
         }
       }
+      await onAuthenticated?.({
+        deviceId,
+        isNewUser,
+        usersCollection: config.usersCollection
+      });
       const tokens = await jwt.sign(deviceId);
       const tokenHash = JwtService.hashToken(tokens.refreshToken);
       await refreshTokensCol.insertOne({
@@ -1322,7 +1332,7 @@ function checkAuth(req, res) {
 function isNonEmptyString(value) {
   return typeof value === "string" && value.length > 0;
 }
-function createPushRouter(db) {
+function createPushRouter(db, onRegistered) {
   const router = (0, import_express3.Router)();
   const devicesCol = db.collection("push_devices");
   const deliveriesCol = db.collection("push_deliveries");
@@ -1351,6 +1361,7 @@ function createPushRouter(db) {
       if (permissionStatus !== void 0)
         update.permissionStatus = permissionStatus;
       await devicesCol.updateOne({ token }, { $set: update });
+      await onRegistered?.({ deviceId, token, platform });
       res.json({ success: true });
       return;
     }
@@ -1388,6 +1399,7 @@ function createPushRouter(db) {
         update.permissionStatus = permissionStatus;
       await devicesCol.updateOne({ token }, { $set: update });
     }
+    await onRegistered?.({ deviceId, token, platform });
     res.json({ success: true });
   });
   router.post("/unregister", async (req, res) => {
@@ -1427,17 +1439,470 @@ function isDuplicateKeyError(err) {
 
 // src/admin/router.ts
 var import_express4 = require("express");
-var import_node_crypto7 = require("crypto");
+var import_node_crypto8 = require("crypto");
 var import_zod = require("zod");
 
-// src/admin/guard.ts
+// src/journeys/service.ts
 var import_node_crypto6 = require("crypto");
+var EVENT_NAME_RE = /^[a-z][a-z0-9_]{0,63}$/;
+var STEP_ID_RE = /^[a-zA-Z0-9][a-zA-Z0-9_-]{0,63}$/;
+var MAX_STEPS = 20;
+var MAX_OFFSET_SECONDS = 365 * 24 * 60 * 60;
+var MAX_ATTEMPTS = 5;
+var RETRY_DELAYS_MS = [6e4, 3e5, 9e5, 36e5];
+var PERMANENT_ERRORS = /* @__PURE__ */ new Set([
+  "INVALID_PAYLOAD",
+  "InvalidCredentials",
+  "MessageTooBig"
+]);
+var JourneyError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "JourneyError";
+  }
+  code;
+};
+var JourneyService = class {
+  constructor(db, push) {
+    this.push = push;
+    this.journeys = db.collection("push_journeys");
+    this.revisions = db.collection("push_journey_revisions");
+    this.runs = db.collection("push_journey_runs");
+    this.events = db.collection("push_events");
+  }
+  push;
+  journeys;
+  revisions;
+  runs;
+  events;
+  async ensureIndexes() {
+    await this.journeys.createIndex({ status: 1, liveEntryEvent: 1, liveSince: 1 });
+    await this.revisions.createIndex({ journeyId: 1, revision: 1 }, { unique: true });
+    await this.runs.createIndex(
+      { journeyId: 1, revision: 1, eventId: 1 },
+      { unique: true }
+    );
+    await this.runs.createIndex({ status: 1, nextRunAt: 1, lockedUntil: 1 });
+    await this.runs.createIndex({ deviceId: 1, createdAt: -1 });
+  }
+  async create(input) {
+    const name = validateName(input.name);
+    const definition = validateJourneyDefinition(input.definition);
+    const now = /* @__PURE__ */ new Date();
+    const journey = {
+      _id: (0, import_node_crypto6.randomUUID)(),
+      name,
+      status: "draft",
+      draft: definition,
+      revisionCounter: 0,
+      createdAt: now,
+      updatedAt: now
+    };
+    await this.journeys.insertOne(journey);
+    return journey;
+  }
+  async list() {
+    return this.journeys.find().sort({ updatedAt: -1 }).toArray();
+  }
+  async get(id) {
+    return this.journeys.findOne({ _id: id });
+  }
+  async updateDraft(id, input) {
+    const existing = await this.requireJourney(id);
+    const name = input.name === void 0 ? existing.name : validateName(input.name);
+    const definition = input.definition === void 0 ? existing.draft : validateJourneyDefinition(input.definition);
+    await this.journeys.updateOne(
+      { _id: id },
+      { $set: { name, draft: definition, updatedAt: /* @__PURE__ */ new Date() } }
+    );
+    return await this.requireJourney(id);
+  }
+  async publish(id) {
+    const existing = await this.requireJourney(id);
+    const publishedAt = /* @__PURE__ */ new Date();
+    const revision = existing.revisionCounter + 1;
+    const snapshot = cloneDefinition(existing.draft);
+    const revisionDoc = {
+      _id: (0, import_node_crypto6.randomUUID)(),
+      journeyId: id,
+      revision,
+      name: existing.name,
+      definition: snapshot,
+      publishedAt
+    };
+    await this.revisions.insertOne(revisionDoc);
+    const update = await this.journeys.updateOne(
+      { _id: id, revisionCounter: existing.revisionCounter },
+      {
+        $set: {
+          status: "live",
+          liveRevision: revision,
+          liveEntryEvent: snapshot.entryEvent,
+          liveSince: publishedAt,
+          publishedAt,
+          updatedAt: publishedAt
+        },
+        $inc: { revisionCounter: 1 }
+      }
+    );
+    if (update.matchedCount === 0) {
+      await this.revisions.deleteOne({ _id: revisionDoc._id });
+      throw new JourneyError("INVALID_STATE", "Journey was published concurrently");
+    }
+    await this.runs.updateMany(
+      { journeyId: id, status: "paused" },
+      { $set: { status: "active", updatedAt: publishedAt } }
+    );
+    return this.requireJourney(id);
+  }
+  async pause(id) {
+    const update = await this.journeys.updateOne(
+      { _id: id, status: "live" },
+      { $set: { status: "paused", updatedAt: /* @__PURE__ */ new Date() } }
+    );
+    if (update.matchedCount === 0) {
+      await this.requireJourney(id);
+      throw new JourneyError("INVALID_STATE", "Only live journeys can be paused");
+    }
+    await this.runs.updateMany(
+      { journeyId: id, status: "active" },
+      {
+        $set: { status: "paused", updatedAt: /* @__PURE__ */ new Date() },
+        $unset: { lockToken: "", lockedUntil: "" }
+      }
+    );
+    return this.requireJourney(id);
+  }
+  async resume(id) {
+    const now = /* @__PURE__ */ new Date();
+    const update = await this.journeys.updateOne(
+      { _id: id, status: "paused", liveRevision: { $exists: true } },
+      { $set: { status: "live", liveSince: now, updatedAt: now } }
+    );
+    if (update.matchedCount === 0) {
+      await this.requireJourney(id);
+      throw new JourneyError("INVALID_STATE", "Only paused journeys can be resumed");
+    }
+    await this.runs.updateMany(
+      { journeyId: id, status: "paused" },
+      { $set: { status: "active", updatedAt: now } }
+    );
+    return this.requireJourney(id);
+  }
+  async enrollEvent(event) {
+    for (const enrollment of event.journeyEnrollments ?? []) {
+      const revision = await this.revisions.findOne({
+        journeyId: enrollment.journeyId,
+        revision: enrollment.revision
+      });
+      const firstStep = revision?.definition.steps[0];
+      if (!revision || !firstStep) continue;
+      const now = /* @__PURE__ */ new Date();
+      const run = {
+        _id: (0, import_node_crypto6.randomUUID)(),
+        journeyId: enrollment.journeyId,
+        revision: enrollment.revision,
+        eventId: event._id,
+        deviceId: event.deviceId,
+        eventOccurredAt: event.occurredAt,
+        status: "active",
+        nextStepIndex: 0,
+        nextRunAt: addSeconds(event.occurredAt, firstStep.offsetSeconds),
+        attempts: 0,
+        createdAt: now,
+        updatedAt: now
+      };
+      try {
+        await this.runs.insertOne(run);
+      } catch (error) {
+        if (!isDuplicateKeyError2(error)) throw error;
+      }
+    }
+  }
+  async resolveEnrollments(eventName) {
+    const journeys = await this.journeys.find({ status: "live", liveEntryEvent: eventName }).project({ _id: 1, liveRevision: 1 }).toArray();
+    return journeys.flatMap(
+      (journey) => journey.liveRevision === void 0 ? [] : [{ journeyId: journey._id, revision: journey.liveRevision }]
+    );
+  }
+  async processDue(options = {}) {
+    const now = options.now ?? /* @__PURE__ */ new Date();
+    const limit = Math.max(1, Math.min(options.limit ?? 100, 500));
+    const leaseMs = Math.max(options.leaseMs ?? 6e4, 1e3);
+    let processed = 0;
+    for (let index = 0; index < limit; index += 1) {
+      const lockToken = (0, import_node_crypto6.randomUUID)();
+      const run = await this.runs.findOneAndUpdate(
+        {
+          status: "active",
+          nextRunAt: { $lte: now },
+          $or: [
+            { lockedUntil: { $exists: false } },
+            { lockedUntil: { $lte: now } }
+          ]
+        },
+        {
+          $set: {
+            lockToken,
+            lockedUntil: new Date(now.getTime() + leaseMs),
+            updatedAt: now
+          }
+        },
+        { sort: { nextRunAt: 1 }, returnDocument: "after" }
+      );
+      if (!run) break;
+      await this.processLockedRun(run, lockToken, now);
+      processed += 1;
+    }
+    return { processed };
+  }
+  async testSend(input) {
+    const journey = await this.requireJourney(input.journeyId);
+    const step = journey.draft.steps.find((candidate) => candidate.id === input.stepId);
+    if (!step) throw new JourneyError("NOT_FOUND", "Journey step not found");
+    return this.push.send({
+      deviceId: input.deviceId,
+      title: step.title,
+      body: step.body,
+      data: step.data,
+      imageUrl: step.imageUrl,
+      idempotencyKey: `journey-test:${journey._id}:${step.id}:${input.deviceId}:${(0, import_node_crypto6.randomUUID)()}`,
+      journeyId: journey._id,
+      journeyStepId: step.id,
+      isTest: true
+    });
+  }
+  async processLockedRun(run, lockToken, now) {
+    try {
+      const journey = await this.journeys.findOne({ _id: run.journeyId });
+      if (!journey || journey.status !== "live") {
+        await this.runs.updateOne(
+          { _id: run._id, lockToken },
+          {
+            $set: { status: "paused", updatedAt: now },
+            $unset: { lockToken: "", lockedUntil: "" }
+          }
+        );
+        return;
+      }
+      const revision = await this.revisions.findOne({
+        journeyId: run.journeyId,
+        revision: run.revision
+      });
+      const step = revision?.definition.steps[run.nextStepIndex];
+      if (!revision || !step) {
+        await this.failRun(run._id, lockToken, now, "REVISION_NOT_FOUND");
+        return;
+      }
+      if (!await this.matchesAudience(run.deviceId, revision.definition)) {
+        await this.runs.updateOne(
+          { _id: run._id, lockToken },
+          {
+            $set: { status: "exited", completedAt: now, updatedAt: now },
+            $unset: { lockToken: "", lockedUntil: "" }
+          }
+        );
+        return;
+      }
+      const data = step.data ? { ...step.data } : {};
+      if (!("journeyId" in data)) data.journeyId = run.journeyId;
+      if (!("journeyStepId" in data)) data.journeyStepId = step.id;
+      const results = await this.push.send({
+        deviceId: run.deviceId,
+        title: step.title,
+        body: step.body,
+        imageUrl: step.imageUrl,
+        data,
+        idempotencyKey: `journey:${run._id}:step:${step.id}:attempt:${run.attempts}`,
+        journeyId: run.journeyId,
+        journeyRevision: run.revision,
+        journeyStepId: step.id,
+        isTest: false
+      });
+      if (results.some((result) => result.status === "submitted")) {
+        const nextIndex = run.nextStepIndex + 1;
+        const nextStep = revision.definition.steps[nextIndex];
+        if (!nextStep) {
+          await this.runs.updateOne(
+            { _id: run._id, lockToken },
+            {
+              $set: {
+                status: "completed",
+                nextStepIndex: nextIndex,
+                attempts: 0,
+                completedAt: now,
+                updatedAt: now
+              },
+              $unset: { lockToken: "", lockedUntil: "", lastError: "" }
+            }
+          );
+          return;
+        }
+        await this.runs.updateOne(
+          { _id: run._id, lockToken },
+          {
+            $set: {
+              nextStepIndex: nextIndex,
+              nextRunAt: addSeconds(run.eventOccurredAt, nextStep.offsetSeconds),
+              attempts: 0,
+              updatedAt: now
+            },
+            $unset: { lockToken: "", lockedUntil: "", lastError: "" }
+          }
+        );
+        return;
+      }
+      const errorCode = results.find((result) => result.errorCode)?.errorCode ?? "TRANSIENT";
+      if (PERMANENT_ERRORS.has(errorCode)) {
+        await this.failRun(run._id, lockToken, now, errorCode);
+        return;
+      }
+      await this.retryRun(run, lockToken, now, errorCode);
+    } catch (error) {
+      await this.retryRun(
+        run,
+        lockToken,
+        now,
+        error instanceof Error ? error.message : "TRANSIENT"
+      );
+    }
+  }
+  async matchesAudience(deviceId, definition) {
+    if (!definition.audience) return true;
+    const exists = await this.events.findOne({
+      deviceId,
+      name: definition.audience.eventName
+    });
+    return definition.audience.operator === "has_event" ? !!exists : !exists;
+  }
+  async retryRun(run, lockToken, now, errorCode) {
+    const attempts = run.attempts + 1;
+    if (attempts >= MAX_ATTEMPTS) {
+      await this.failRun(run._id, lockToken, now, errorCode, attempts);
+      return;
+    }
+    const delay = RETRY_DELAYS_MS[Math.min(attempts - 1, RETRY_DELAYS_MS.length - 1)];
+    await this.runs.updateOne(
+      { _id: run._id, lockToken },
+      {
+        $set: {
+          attempts,
+          nextRunAt: new Date(now.getTime() + delay),
+          lastError: errorCode,
+          updatedAt: now
+        },
+        $unset: { lockToken: "", lockedUntil: "" }
+      }
+    );
+  }
+  async failRun(id, lockToken, now, errorCode, attempts) {
+    const set = {
+      status: "failed",
+      lastError: errorCode,
+      completedAt: now,
+      updatedAt: now
+    };
+    if (attempts !== void 0) set.attempts = attempts;
+    await this.runs.updateOne(
+      { _id: id, lockToken },
+      { $set: set, $unset: { lockToken: "", lockedUntil: "" } }
+    );
+  }
+  async requireJourney(id) {
+    const journey = await this.journeys.findOne({ _id: id });
+    if (!journey) throw new JourneyError("NOT_FOUND", "Journey not found");
+    return journey;
+  }
+};
+function validateJourneyDefinition(input) {
+  if (!input || typeof input !== "object" || Array.isArray(input)) {
+    throw new JourneyError("INVALID_INPUT", "Invalid journey definition");
+  }
+  if (!EVENT_NAME_RE.test(input.entryEvent)) {
+    throw new JourneyError("INVALID_INPUT", "Invalid entry event");
+  }
+  if (!Array.isArray(input.steps) || input.steps.length < 1 || input.steps.length > MAX_STEPS) {
+    throw new JourneyError("INVALID_INPUT", "A journey needs 1-20 steps");
+  }
+  if (input.audience) {
+    if (input.audience.operator !== "has_event" && input.audience.operator !== "not_has_event" || !EVENT_NAME_RE.test(input.audience.eventName)) {
+      throw new JourneyError("INVALID_INPUT", "Invalid audience");
+    }
+  }
+  const stepIds = /* @__PURE__ */ new Set();
+  let previousOffset = -1;
+  for (const step of input.steps) {
+    if (!step || typeof step !== "object" || !STEP_ID_RE.test(step.id)) {
+      throw new JourneyError("INVALID_INPUT", "Invalid step id");
+    }
+    if (stepIds.has(step.id)) {
+      throw new JourneyError("INVALID_INPUT", "Duplicate step id");
+    }
+    stepIds.add(step.id);
+    if (!Number.isInteger(step.offsetSeconds) || step.offsetSeconds < 0 || step.offsetSeconds > MAX_OFFSET_SECONDS || step.offsetSeconds < previousOffset) {
+      throw new JourneyError("INVALID_INPUT", "Invalid step offset");
+    }
+    previousOffset = step.offsetSeconds;
+    if (typeof step.title !== "string" || step.title.length < 1 || step.title.length > 100) {
+      throw new JourneyError("INVALID_INPUT", "Invalid step title");
+    }
+    if (typeof step.body !== "string" || step.body.length < 1 || step.body.length > 1e3) {
+      throw new JourneyError("INVALID_INPUT", "Invalid step body");
+    }
+    validateHttpsUrl(step.imageUrl);
+    if (step.data !== void 0) {
+      if (!step.data || typeof step.data !== "object" || Array.isArray(step.data)) {
+        throw new JourneyError("INVALID_INPUT", "Invalid step data");
+      }
+      if ("deliveryId" in step.data || "journeyId" in step.data || "journeyStepId" in step.data) {
+        throw new JourneyError("INVALID_INPUT", "Step data uses reserved keys");
+      }
+      try {
+        if (Buffer.byteLength(JSON.stringify(step.data), "utf8") > 3072) {
+          throw new JourneyError("INVALID_INPUT", "Step data is too large");
+        }
+      } catch (error) {
+        if (error instanceof JourneyError) throw error;
+        throw new JourneyError("INVALID_INPUT", "Invalid step data");
+      }
+    }
+  }
+  return cloneDefinition(input);
+}
+function validateName(name) {
+  if (typeof name !== "string" || name.trim().length < 1 || name.trim().length > 100) {
+    throw new JourneyError("INVALID_INPUT", "Invalid journey name");
+  }
+  return name.trim();
+}
+function validateHttpsUrl(value) {
+  if (value === void 0) return;
+  try {
+    const url = new URL(value);
+    if (url.protocol !== "https:" || value.length > 2048) throw new Error("invalid");
+  } catch {
+    throw new JourneyError("INVALID_INPUT", "Invalid image URL");
+  }
+}
+function cloneDefinition(definition) {
+  return structuredClone(definition);
+}
+function addSeconds(date, seconds) {
+  return new Date(date.getTime() + seconds * 1e3);
+}
+function isDuplicateKeyError2(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === 11e3;
+}
+
+// src/admin/guard.ts
+var import_node_crypto7 = require("crypto");
 var ADMIN_HEADER = "x-codixus-admin";
 function digestToken(token) {
-  return (0, import_node_crypto6.createHash)("sha256").update(token, "utf8").digest();
+  return (0, import_node_crypto7.createHash)("sha256").update(token, "utf8").digest();
 }
 function tokensMatch(provided, expected) {
-  return (0, import_node_crypto6.timingSafeEqual)(digestToken(provided), digestToken(expected));
+  return (0, import_node_crypto7.timingSafeEqual)(digestToken(provided), digestToken(expected));
 }
 function readHeader(req) {
   const value = req.headers[ADMIN_HEADER];
@@ -1482,13 +1947,20 @@ var PUSH_DELIVERY_FIELDS = [
   "title",
   "body",
   "data",
+  "imageUrl",
   "status",
   "ticketId",
   "errorCode",
+  "errorMessage",
   "idempotencyKey",
   "createdAt",
   "openedAt",
-  "receiptedAt"
+  "receiptedAt",
+  "updatedAt",
+  "journeyId",
+  "journeyRevision",
+  "journeyStepId",
+  "isTest"
 ];
 function param2(req, name) {
   const val = req.params[name];
@@ -1655,6 +2127,19 @@ function notFound(res) {
 function invalidBody(res) {
   res.status(400).json({ success: false, error: "Invalid request body" });
 }
+function journeyFailure(res, error) {
+  if (error instanceof JourneyError) {
+    if (error.code === "NOT_FOUND") {
+      notFound(res);
+      return;
+    }
+    if (error.code === "INVALID_STATE") {
+      res.status(409).json({ success: false, error: "INVALID_STATE" });
+      return;
+    }
+  }
+  invalidBody(res);
+}
 function createAdminRouter(deps) {
   const router = (0, import_express4.Router)();
   router.use(createAdminGuard(deps.token));
@@ -1713,7 +2198,7 @@ function createAdminRouter(deps) {
     }
     const doc = { ...body };
     if (!doc._id) {
-      doc._id = (0, import_node_crypto7.randomUUID)();
+      doc._id = (0, import_node_crypto8.randomUUID)();
     }
     await deps.db.collection(name).insertOne(doc);
     res.status(200).json({ success: true, data: doc });
@@ -1814,7 +2299,7 @@ function createAdminRouter(deps) {
       notFound(res);
       return;
     }
-    const { deviceId, title, body, data } = req.body ?? {};
+    const { deviceId, title, body, data, imageUrl } = req.body ?? {};
     if (!isNonEmptyString2(deviceId) || !isNonEmptyString2(title) || !isNonEmptyString2(body)) {
       invalidBody(res);
       return;
@@ -1829,8 +2314,100 @@ function createAdminRouter(deps) {
     if (data !== void 0) {
       input.data = data;
     }
-    await deps.pushSend(input);
-    res.status(200).json({ success: true });
+    if (imageUrl !== void 0) {
+      if (!isNonEmptyString2(imageUrl)) {
+        invalidBody(res);
+        return;
+      }
+      input.imageUrl = imageUrl;
+    }
+    try {
+      const results = await deps.pushSend(input);
+      res.status(200).json({ success: true, data: results });
+    } catch {
+      invalidBody(res);
+    }
+  });
+  router.get("/push/journeys", async (_req, res) => {
+    if (!deps.hasPush || !deps.journeys) {
+      notFound(res);
+      return;
+    }
+    res.json({ success: true, data: await deps.journeys.list() });
+  });
+  router.post("/push/journeys", async (req, res) => {
+    if (!deps.hasPush || !deps.journeys) {
+      notFound(res);
+      return;
+    }
+    try {
+      const journey = await deps.journeys.create(req.body ?? {});
+      res.status(201).json({ success: true, data: journey });
+    } catch (error) {
+      journeyFailure(res, error);
+    }
+  });
+  router.get("/push/journeys/:id", async (req, res) => {
+    if (!deps.hasPush || !deps.journeys) {
+      notFound(res);
+      return;
+    }
+    const journey = await deps.journeys.get(param2(req, "id"));
+    if (!journey) {
+      notFound(res);
+      return;
+    }
+    res.json({ success: true, data: journey });
+  });
+  router.patch("/push/journeys/:id", async (req, res) => {
+    if (!deps.hasPush || !deps.journeys) {
+      notFound(res);
+      return;
+    }
+    try {
+      const journey = await deps.journeys.updateDraft(param2(req, "id"), req.body ?? {});
+      res.json({ success: true, data: journey });
+    } catch (error) {
+      journeyFailure(res, error);
+    }
+  });
+  for (const action of ["publish", "pause", "resume"]) {
+    router.post(
+      `/push/journeys/:id/${action}`,
+      async (req, res) => {
+        if (!deps.hasPush || !deps.journeys) {
+          notFound(res);
+          return;
+        }
+        try {
+          const journey = await deps.journeys[action](param2(req, "id"));
+          res.json({ success: true, data: journey });
+        } catch (error) {
+          journeyFailure(res, error);
+        }
+      }
+    );
+  }
+  router.post("/push/journeys/:id/test", async (req, res) => {
+    if (!deps.hasPush || !deps.journeys) {
+      notFound(res);
+      return;
+    }
+    const { deviceId, stepId } = req.body ?? {};
+    if (!isNonEmptyString2(deviceId) || !isNonEmptyString2(stepId)) {
+      invalidBody(res);
+      return;
+    }
+    try {
+      const results = await deps.journeys.testSend({
+        journeyId: param2(req, "id"),
+        deviceId,
+        stepId
+      });
+      res.json({ success: true, data: results });
+    } catch (error) {
+      journeyFailure(res, error);
+    }
   });
   router.get("/push/deliveries", async (req, res) => {
     if (!deps.hasPush) {
@@ -1850,7 +2427,7 @@ function createAdminRouter(deps) {
 }
 
 // src/push/service.ts
-var import_node_crypto8 = require("crypto");
+var import_node_crypto9 = require("crypto");
 var PERMANENT_DISABLE_CODES = /* @__PURE__ */ new Set([
   "DeviceNotRegistered",
   "InvalidCredentials"
@@ -1866,77 +2443,110 @@ var PushService = class {
   devicesCol;
   deliveriesCol;
   async send(input) {
+    validateImageUrl(input.imageUrl);
     const deviceIds = Array.isArray(input.deviceId) ? [...new Set(input.deviceId)] : [input.deviceId];
-    if (deviceIds.length === 0) return;
+    if (deviceIds.length === 0) return [];
     const digest = computeDigest(
       input.title,
       input.body,
       input.idempotencyKey
     );
     const pending = [];
+    const results = [];
     for (const deviceId of deviceIds) {
       const devices = await this.devicesCol.find({ deviceId, enabled: true }).toArray();
+      if (devices.length === 0) {
+        results.push({ deviceId, status: "skipped", errorCode: "NO_DEVICE" });
+      }
       for (const device of devices) {
         const idempotencyKey = `${deviceId}:${device.token}:${digest}`;
-        const existing = await this.deliveriesCol.findOne({ idempotencyKey });
-        if (existing) continue;
-        const deliveryId = (0, import_node_crypto8.randomUUID)();
+        const deliveryId = (0, import_node_crypto9.randomUUID)();
         const data = input.data ? { ...input.data } : {};
         if (!("deliveryId" in data)) {
           data.deliveryId = deliveryId;
         }
-        pending.push({
-          token: device.token,
+        const now = /* @__PURE__ */ new Date();
+        const doc = {
+          _id: deliveryId,
           deviceId,
           provider: device.provider,
-          deliveryId,
+          token: device.token,
+          title: input.title,
+          body: input.body,
+          data,
+          status: "sending",
           idempotencyKey,
-          message: {
-            token: device.token,
-            title: input.title,
-            body: input.body,
-            data
-          }
-        });
+          createdAt: now,
+          updatedAt: now
+        };
+        if (input.imageUrl !== void 0) doc.imageUrl = input.imageUrl;
+        if (input.journeyId !== void 0) doc.journeyId = input.journeyId;
+        if (input.journeyRevision !== void 0) {
+          doc.journeyRevision = input.journeyRevision;
+        }
+        if (input.journeyStepId !== void 0) {
+          doc.journeyStepId = input.journeyStepId;
+        }
+        if (input.isTest !== void 0) doc.isTest = input.isTest;
+        try {
+          await this.deliveriesCol.insertOne(doc);
+        } catch (error) {
+          if (!isDuplicateKeyError3(error)) throw error;
+          const existing = await this.deliveriesCol.findOne({ idempotencyKey });
+          if (existing) results.push(resultFromDelivery(existing));
+          continue;
+        }
+        const message = {
+          token: device.token,
+          title: input.title,
+          body: input.body,
+          data
+        };
+        if (input.imageUrl !== void 0) message.imageUrl = input.imageUrl;
+        pending.push({ doc, message });
       }
     }
-    if (pending.length === 0) return;
+    if (pending.length === 0) return results;
     const messages = pending.map((p) => p.message);
-    const tickets = await this.transport.send(messages);
+    let tickets;
+    try {
+      tickets = await this.transport.send(messages);
+    } catch (error) {
+      tickets = messages.map((message) => ({
+        token: message.token,
+        status: "error",
+        errorCode: "TRANSIENT",
+        errorMessage: readableError(error)
+      }));
+    }
     for (let i = 0; i < pending.length; i++) {
       const item = pending[i];
       const ticket = tickets[i];
       if (ticket && ticket.status === "error" && ticket.errorCode && PERMANENT_DISABLE_CODES.has(ticket.errorCode)) {
         await this.devicesCol.updateOne(
-          { token: item.token },
+          { token: item.doc.token },
           { $set: { enabled: false, updatedAt: /* @__PURE__ */ new Date() } }
         );
       }
-      const doc = {
-        _id: item.deliveryId,
-        deviceId: item.deviceId,
-        token: item.token,
-        provider: item.provider,
-        title: input.title,
-        body: input.body,
-        data: item.message.data,
+      const update = {
         status: "failed",
-        idempotencyKey: item.idempotencyKey,
-        createdAt: /* @__PURE__ */ new Date()
+        updatedAt: /* @__PURE__ */ new Date()
       };
       if (ticket && ticket.status === "ok") {
-        doc.status = "submitted";
-        if (ticket.ticketId) doc.ticketId = ticket.ticketId;
+        update.status = "submitted";
+        if (ticket.ticketId) update.ticketId = ticket.ticketId;
       } else {
-        doc.errorCode = ticket?.errorCode ?? "TRANSIENT";
-        if (ticket?.ticketId) doc.ticketId = ticket.ticketId;
-      }
-      try {
-        await this.deliveriesCol.insertOne(doc);
-      } catch (err) {
-        if (!isDuplicateKeyError2(err)) throw err;
+        update.errorCode = ticket?.errorCode ?? "TRANSIENT";
+        if (ticket?.errorMessage) update.errorMessage = ticket.errorMessage;
+        if (ticket?.ticketId) update.ticketId = ticket.ticketId;
       }
+      await this.deliveriesCol.updateOne(
+        { _id: item.doc._id },
+        { $set: update }
+      );
+      results.push(resultFromDelivery({ ...item.doc, ...update }));
     }
+    return results;
   }
   async sendTo(input) {
     const devices = await this.devicesCol.find({ $and: [input.filter, { enabled: true }] }).toArray();
@@ -1948,13 +2558,14 @@ var PushService = class {
         deviceIds.push(device.deviceId);
       }
     }
-    if (deviceIds.length === 0) return;
-    await this.send({
+    if (deviceIds.length === 0) return [];
+    return this.send({
       deviceId: deviceIds,
       title: input.title,
       body: input.body,
       data: input.data,
-      idempotencyKey: input.idempotencyKey
+      idempotencyKey: input.idempotencyKey,
+      imageUrl: input.imageUrl
     });
   }
   async pollReceipts() {
@@ -1999,6 +2610,7 @@ var PushService = class {
             $set: {
               status: "failed",
               errorCode,
+              ...receipt.errorMessage ? { errorMessage: receipt.errorMessage } : {},
               receiptedAt: now
             }
           }
@@ -2016,16 +2628,201 @@ var PushService = class {
     return this.devicesCol.find(filter).toArray();
   }
 };
+function resultFromDelivery(delivery) {
+  if (delivery.status === "submitted" || delivery.status === "opened") {
+    return {
+      deviceId: delivery.deviceId,
+      token: delivery.token,
+      deliveryId: delivery._id,
+      status: "submitted"
+    };
+  }
+  return {
+    deviceId: delivery.deviceId,
+    token: delivery.token,
+    deliveryId: delivery._id,
+    status: "failed",
+    errorCode: delivery.errorCode ?? "TRANSIENT",
+    ...delivery.errorMessage ? { errorMessage: delivery.errorMessage } : {}
+  };
+}
+function readableError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function validateImageUrl(imageUrl) {
+  if (imageUrl === void 0) return;
+  try {
+    const url = new URL(imageUrl);
+    if (url.protocol !== "https:") throw new Error("not https");
+  } catch {
+    throw new Error("Invalid imageUrl");
+  }
+}
 function computeDigest(title, body, idempotencyKey) {
   if (idempotencyKey) return idempotencyKey;
   const utcDay = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
   const input = title + "\0" + body + "\0" + utcDay;
-  return (0, import_node_crypto8.createHash)("sha256").update(input, "utf8").digest("hex");
+  return (0, import_node_crypto9.createHash)("sha256").update(input, "utf8").digest("hex");
 }
-function isDuplicateKeyError2(err) {
+function isDuplicateKeyError3(err) {
   return typeof err === "object" && err !== null && "code" in err && err.code === 11e3;
 }
 
+// src/events/service.ts
+var import_node_crypto10 = require("crypto");
+var EVENT_NAME_RE2 = /^[a-z][a-z0-9_]{0,63}$/;
+var MAX_PROPERTIES_BYTES = 16 * 1024;
+var EventService = class {
+  constructor(db, defaultUsersCollection, journeyHooks) {
+    this.db = db;
+    this.defaultUsersCollection = defaultUsersCollection;
+    this.journeyHooks = journeyHooks;
+    this.events = db.collection("push_events");
+  }
+  db;
+  defaultUsersCollection;
+  journeyHooks;
+  events;
+  async ensureIndexes() {
+    await this.events.createIndex({ deviceId: 1, name: 1, occurredAt: -1 });
+    await this.events.createIndex({ name: 1, createdAt: -1 });
+    await this.events.createIndex(
+      { deviceId: 1, source: 1, idempotencyKey: 1 },
+      {
+        unique: true,
+        partialFilterExpression: { idempotencyKey: { $type: "string" } }
+      }
+    );
+  }
+  async track(input) {
+    validateEventInput(input);
+    const usersCollection = input.usersCollection ?? this.defaultUsersCollection;
+    const user = await this.db.collection(usersCollection).findOne({
+      $or: [{ _id: input.deviceId }, { deviceId: input.deviceId }]
+    });
+    if (!user) return { created: false, ignored: "USER_NOT_FOUND" };
+    const source = input.source ?? "server";
+    if (input.idempotencyKey !== void 0) {
+      const existing = await this.events.findOne({
+        deviceId: input.deviceId,
+        source,
+        idempotencyKey: input.idempotencyKey
+      });
+      if (existing) {
+        await this.finishEnrollment(existing);
+        return { created: false, eventId: existing._id };
+      }
+    }
+    const now = /* @__PURE__ */ new Date();
+    const event = {
+      _id: (0, import_node_crypto10.randomUUID)(),
+      deviceId: input.deviceId,
+      name: input.name,
+      source,
+      occurredAt: input.occurredAt ?? now,
+      createdAt: now
+    };
+    if (input.properties !== void 0) event.properties = input.properties;
+    if (input.idempotencyKey !== void 0) {
+      event.idempotencyKey = input.idempotencyKey;
+    }
+    if (this.journeyHooks) {
+      event.journeyEnrollments = await this.journeyHooks.resolve(event.name);
+      event.enrollmentStatus = "pending";
+    } else {
+      event.enrollmentStatus = "complete";
+    }
+    try {
+      await this.events.insertOne(event);
+    } catch (error) {
+      if (!isDuplicateKeyError4(error) || input.idempotencyKey === void 0) {
+        throw error;
+      }
+      const existing = await this.events.findOne({
+        deviceId: input.deviceId,
+        source,
+        idempotencyKey: input.idempotencyKey
+      });
+      if (!existing) throw error;
+      await this.finishEnrollment(existing);
+      return { created: false, eventId: existing._id };
+    }
+    await this.finishEnrollment(event);
+    return { created: true, eventId: event._id };
+  }
+  async find(filter) {
+    return this.events.find(filter).sort({ createdAt: -1 }).toArray();
+  }
+  async finishEnrollment(event) {
+    if (!this.journeyHooks || event.enrollmentStatus !== "pending") return;
+    await this.journeyHooks.enroll(event);
+    await this.events.updateOne(
+      { _id: event._id, enrollmentStatus: "pending" },
+      { $set: { enrollmentStatus: "complete" } }
+    );
+  }
+};
+function validateEventInput(input) {
+  if (typeof input.deviceId !== "string" || input.deviceId.length === 0) {
+    throw new Error("Invalid deviceId");
+  }
+  if (!EVENT_NAME_RE2.test(input.name)) throw new Error("Invalid event name");
+  if (input.idempotencyKey !== void 0 && (typeof input.idempotencyKey !== "string" || input.idempotencyKey.length === 0 || input.idempotencyKey.length > 200)) {
+    throw new Error("Invalid idempotency key");
+  }
+  if (input.occurredAt !== void 0 && (!(input.occurredAt instanceof Date) || Number.isNaN(input.occurredAt.getTime()))) {
+    throw new Error("Invalid occurredAt");
+  }
+  if (input.properties !== void 0) {
+    if (!input.properties || typeof input.properties !== "object" || Array.isArray(input.properties)) {
+      throw new Error("Invalid properties");
+    }
+    try {
+      if (Buffer.byteLength(JSON.stringify(input.properties), "utf8") > MAX_PROPERTIES_BYTES) {
+        throw new Error("Invalid properties");
+      }
+    } catch {
+      throw new Error("Invalid properties");
+    }
+  }
+}
+function isDuplicateKeyError4(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === 11e3;
+}
+
+// src/events/router.ts
+var import_express5 = require("express");
+function createEventsRouter(service) {
+  const router = (0, import_express5.Router)();
+  router.post("/", async (req, res) => {
+    const deviceId = req.user?.deviceId;
+    if (!deviceId) {
+      res.status(401).json({ success: false, error: "Missing authorization header" });
+      return;
+    }
+    try {
+      const { name, properties, idempotencyKey, occurredAt } = req.body ?? {};
+      let parsedOccurredAt;
+      if (occurredAt !== void 0) {
+        if (typeof occurredAt !== "string") throw new Error("Invalid occurredAt");
+        parsedOccurredAt = new Date(occurredAt);
+      }
+      const result = await service.track({
+        deviceId,
+        name,
+        properties,
+        idempotencyKey,
+        occurredAt: parsedOccurredAt,
+        source: "client"
+      });
+      res.status(200).json({ success: true, data: result });
+    } catch {
+      res.status(400).json({ success: false, error: "Invalid request body" });
+    }
+  });
+  return router;
+}
+
 // src/codixus-server.ts
 var CodixusServer = class {
   constructor(config) {
@@ -2050,6 +2847,7 @@ var CodixusServer = class {
   auth;
   db;
   push;
+  events;
   admin;
   async connect() {
     this._db = await this.connection.connect();
@@ -2066,6 +2864,7 @@ var CodixusServer = class {
       { expiresAt: 1 },
       { expireAfterSeconds: 0 }
     );
+    let journeyService;
     if (this.config.push) {
       const pushDevicesCol = this._db.collection("push_devices");
       await pushDevicesCol.createIndex({ token: 1 }, { unique: true });
@@ -2078,15 +2877,54 @@ var CodixusServer = class {
       );
       await pushDeliveriesCol.createIndex({ ticketId: 1 });
       await pushDeliveriesCol.createIndex({ deviceId: 1 });
-      const pushService = new PushService(this._db, this.config.push.transport);
+      const configuredPushService = new PushService(
+        this._db,
+        this.config.push.transport
+      );
+      journeyService = new JourneyService(this._db, configuredPushService);
+      await journeyService.ensureIndexes();
+      const journeys = journeyService;
       this.push = {
-        router: () => createPushRouter(this._db),
-        send: (input) => pushService.send(input),
-        sendTo: (input) => pushService.sendTo(input),
-        pollReceipts: () => pushService.pollReceipts(),
-        find: (filter) => pushService.find(filter)
+        router: () => createPushRouter(this._db, async ({ deviceId, token, platform }) => {
+          await this.events.track({
+            deviceId,
+            name: "push_registered",
+            properties: { platform },
+            idempotencyKey: `push-registered:${(0, import_node_crypto11.createHash)("sha256").update(token).digest("hex")}`,
+            source: "system"
+          });
+        }),
+        send: (input) => configuredPushService.send(input),
+        sendTo: (input) => configuredPushService.sendTo(input),
+        pollReceipts: () => configuredPushService.pollReceipts(),
+        find: (filter) => configuredPushService.find(filter),
+        journeys: {
+          create: (input) => journeys.create(input),
+          list: () => journeys.list(),
+          get: (id) => journeys.get(id),
+          updateDraft: (id, input) => journeys.updateDraft(id, input),
+          publish: (id) => journeys.publish(id),
+          pause: (id) => journeys.pause(id),
+          resume: (id) => journeys.resume(id),
+          testSend: (input) => journeys.testSend(input),
+          processDue: (options) => journeys.processDue(options)
+        }
       };
     }
+    const eventService = new EventService(
+      this._db,
+      this.config.events?.usersCollection ?? "users",
+      journeyService ? {
+        resolve: (eventName) => journeyService.resolveEnrollments(eventName),
+        enroll: (event) => journeyService.enrollEvent(event)
+      } : void 0
+    );
+    await eventService.ensureIndexes();
+    this.events = {
+      router: () => createEventsRouter(eventService),
+      track: (input) => eventService.track(input),
+      find: (filter) => eventService.find(filter)
+    };
     this.auth = {
       sign: (subject, claims) => this.jwt.sign(subject, claims),
       verify: (token) => this.jwt.verify(token),
@@ -2097,7 +2935,21 @@ var CodixusServer = class {
         return tokens;
       },
       guard: (options) => this.guardFn(options),
-      router: (config) => createAuthRouter(this.jwt, this.banService, this._db, config),
+      router: (config) => createAuthRouter(
+        this.jwt,
+        this.banService,
+        this._db,
+        config,
+        async ({ deviceId, usersCollection }) => {
+          await eventService.track({
+            deviceId,
+            name: "user_created",
+            source: "system",
+            idempotencyKey: "user-created",
+            usersCollection
+          });
+        }
+      ),
       ban: (deviceId, reason) => this.banService.ban(deviceId, reason),
       unban: (deviceId) => this.banService.unban(deviceId),
       isBanned: (deviceId) => this.banService.isBanned(deviceId)
@@ -2112,7 +2964,8 @@ var CodixusServer = class {
           db: this._db,
           token: this.config.admin.token,
           hasPush: !!this.config.push,
-          pushSend: this.push?.send
+          pushSend: this.push?.send,
+          journeys: journeyService
         })
       };
     }
@@ -2172,12 +3025,19 @@ function validate(schema) {
 var SEND_URL = "https://exp.host/--/api/v2/push/send";
 var RECEIPTS_URL = "https://exp.host/--/api/v2/push/getReceipts";
 var BATCH_SIZE = 100;
-function transientTickets(messages) {
-  return messages.map((m) => ({
-    token: m.token,
-    status: "error",
-    errorCode: "TRANSIENT"
-  }));
+var MAX_NOTIFICATION_BYTES = 4096;
+var DEFAULT_REQUEST_TIMEOUT_MS = 15e3;
+var DEFAULT_MAX_RETRY_DELAY_MS = 5e3;
+function transientTickets(messages, errorMessage) {
+  return messages.map((m) => {
+    const ticket = {
+      token: m.token,
+      status: "error",
+      errorCode: "TRANSIENT"
+    };
+    if (errorMessage) ticket.errorMessage = errorMessage;
+    return ticket;
+  });
 }
 function invalidPayloadTickets(messages) {
   return messages.map((m) => ({
@@ -2219,6 +3079,17 @@ function mapExpoTickets(messages, data) {
 function createExpoTransport(opts) {
   const fetchImpl = opts?.fetchImpl ?? globalThis.fetch;
   const accessToken = opts?.accessToken;
+  const sleepImpl = opts?.sleepImpl ?? ((delayMs) => new Promise((resolve) => setTimeout(resolve, delayMs)));
+  const baseRetryDelayMs = Math.max(0, opts?.baseRetryDelayMs ?? 500);
+  const maxAttempts = Math.max(1, Math.floor(opts?.maxAttempts ?? 3));
+  const requestTimeoutMs = Math.max(
+    1,
+    Math.floor(opts?.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS)
+  );
+  const maxRetryDelayMs = Math.max(
+    0,
+    Math.floor(opts?.maxRetryDelayMs ?? DEFAULT_MAX_RETRY_DELAY_MS)
+  );
   function headers() {
     const h = {
       "Content-Type": "application/json"
@@ -2228,13 +3099,36 @@ function createExpoTransport(opts) {
     }
     return h;
   }
+  async function postJson(url, body) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), requestTimeoutMs);
+    try {
+      const response = await fetchImpl(url, {
+        method: "POST",
+        headers: headers(),
+        body: JSON.stringify(body),
+        signal: controller.signal
+      });
+      const json = response.ok ? await response.json() : void 0;
+      return { response, json };
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+  function exponentialDelay(attempt) {
+    return Math.min(
+      baseRetryDelayMs * 2 ** (attempt - 1),
+      maxRetryDelayMs
+    );
+  }
   return {
     name: "expo",
     async send(messages) {
       const allTickets = [];
       for (let i = 0; i < messages.length; i += BATCH_SIZE) {
         const batch = messages.slice(i, i + BATCH_SIZE);
-        const body = batch.map((m) => {
+        const batchTickets = new Array(batch.length);
+        const entries = batch.map((m, batchIndex) => {
           const item = {
             to: m.token,
             title: m.title,
@@ -2245,33 +3139,73 @@ function createExpoTransport(opts) {
           if (m.badge !== void 0) item.badge = m.badge;
           if (m.sound !== void 0) item.sound = m.sound;
           if (m.channelId !== void 0) item.channelId = m.channelId;
-          return item;
+          if (m.imageUrl !== void 0) {
+            item.richContent = { image: m.imageUrl };
+            item.mutableContent = true;
+          }
+          return { batchIndex, message: m, item };
         });
-        try {
-          const res = await fetchImpl(SEND_URL, {
-            method: "POST",
-            headers: headers(),
-            body: JSON.stringify(body)
-          });
-          if (res.status === 429 || res.status >= 500) {
-            allTickets.push(...transientTickets(batch));
-            continue;
+        const sendable = entries.filter((entry) => {
+          if (Buffer.byteLength(JSON.stringify(entry.item), "utf8") <= MAX_NOTIFICATION_BYTES) {
+            return true;
           }
-          if (res.status >= 400 && res.status < 500) {
-            allTickets.push(...invalidPayloadTickets(batch));
-            continue;
+          batchTickets[entry.batchIndex] = {
+            token: entry.message.token,
+            status: "error",
+            errorCode: "MessageTooBig",
+            errorMessage: "Expo notification payload exceeds 4096 bytes"
+          };
+          return false;
+        });
+        const sendBatch = sendable.map((entry) => entry.message);
+        const body = sendable.map((entry) => entry.item);
+        if (sendBatch.length === 0) {
+          allTickets.push(...batchTickets);
+          continue;
+        }
+        const assignTickets = (tickets) => {
+          for (let index = 0; index < tickets.length; index += 1) {
+            const entry = sendable[index];
+            if (entry) batchTickets[entry.batchIndex] = tickets[index];
           }
-          const json = await res.json();
-          if (!Array.isArray(json.data)) {
-            allTickets.push(...transientTickets(batch));
-            continue;
+        };
+        let completed = false;
+        let transientErrorMessage;
+        for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+          try {
+            const { response: res, json } = await postJson(SEND_URL, body);
+            if (res.status >= 400 && res.status < 500 && res.status !== 429) {
+              assignTickets(invalidPayloadTickets(sendBatch));
+              completed = true;
+              break;
+            }
+            if (res.status === 429 || res.status >= 500 || !res.ok) {
+              transientErrorMessage = `Expo send HTTP ${res.status}`;
+              if (attempt === maxAttempts) break;
+              await sleepImpl(
+                retryDelay(res, attempt, baseRetryDelayMs, maxRetryDelayMs)
+              );
+              continue;
+            }
+            const payload = json;
+            if (!Array.isArray(payload.data)) {
+              if (attempt === maxAttempts) break;
+              await sleepImpl(exponentialDelay(attempt));
+              continue;
+            }
+            assignTickets(mapExpoTickets(sendBatch, payload.data));
+            completed = true;
+            break;
+          } catch (error) {
+            transientErrorMessage = error instanceof Error ? error.message : String(error);
+            if (attempt === maxAttempts) break;
+            await sleepImpl(exponentialDelay(attempt));
           }
-          allTickets.push(
-            ...mapExpoTickets(batch, json.data)
-          );
-        } catch {
-          allTickets.push(...transientTickets(batch));
         }
+        if (!completed) {
+          assignTickets(transientTickets(sendBatch, transientErrorMessage));
+        }
+        allTickets.push(...batchTickets);
       }
       return allTickets;
     },
@@ -2279,19 +3213,17 @@ function createExpoTransport(opts) {
       const allReceipts = [];
       for (let i = 0; i < ticketIds.length; i += BATCH_SIZE) {
         const batch = ticketIds.slice(i, i + BATCH_SIZE);
-        const res = await fetchImpl(RECEIPTS_URL, {
-          method: "POST",
-          headers: headers(),
-          body: JSON.stringify({ ids: batch })
+        const { response: res, json } = await postJson(RECEIPTS_URL, {
+          ids: batch
         });
         if (!res.ok) {
           throw new Error(`Expo getReceipts HTTP ${res.status}`);
         }
-        const json = await res.json();
-        if (typeof json.data !== "object" || json.data === null || Array.isArray(json.data)) {
+        const payload = json;
+        if (typeof payload.data !== "object" || payload.data === null || Array.isArray(payload.data)) {
           throw new Error("Expo getReceipts invalid response");
         }
-        const data = json.data;
+        const data = payload.data;
         for (const id of batch) {
           const receipt = data[id];
           if (!receipt) continue;
@@ -2301,7 +3233,8 @@ function createExpoTransport(opts) {
             allReceipts.push({
               ticketId: id,
               status: "error",
-              errorCode: receipt.status === "error" ? receipt.details?.error ?? "UNKNOWN" : "UNKNOWN"
+              errorCode: receipt.status === "error" ? receipt.details?.error ?? "UNKNOWN" : "UNKNOWN",
+              ...receipt.status === "error" && receipt.message ? { errorMessage: receipt.message } : {}
             });
           }
         }
@@ -2310,6 +3243,16 @@ function createExpoTransport(opts) {
     }
   };
 }
+function retryDelay(response, attempt, baseRetryDelayMs, maxRetryDelayMs) {
+  const retryAfter = response.headers.get("Retry-After");
+  if (retryAfter !== null) {
+    const seconds = Number(retryAfter);
+    if (Number.isFinite(seconds) && seconds >= 0) {
+      return Math.min(seconds * 1e3, maxRetryDelayMs);
+    }
+  }
+  return Math.min(baseRetryDelayMs * 2 ** (attempt - 1), maxRetryDelayMs);
+}
 
 // src/index.ts
 var import_shared4 = require("@codixus/shared");
@@ -2318,12 +3261,14 @@ var import_shared4 = require("@codixus/shared");
   CodixusError,
   CodixusServer,
   ErrorCodes,
+  JourneyError,
   Model,
   Query,
   RestErrorCode,
   SubCollection,
   createExpoTransport,
   model,
-  validate
+  validate,
+  validateJourneyDefinition
 });
 //# sourceMappingURL=index.cjs.map