@acmekit/acmekit 2.13.83 → 2.13.85

package/dist/templates/plugin/.claude/skills/write-test/SKILL.md

@@ -1,225 +1,342 @@
 ---
 name: write-test
-description: "Generates integration or unit tests using the correct AcmeKit test runner. Auto-detects whether to use pluginIntegrationTestRunner (full plugin tests) or moduleIntegrationTestRunner (module services). Use when adding tests for modules, workflows, API routes, or service methods."
+description: "Generates integration or unit tests using the unified integrationTestRunner. Auto-detects the correct mode (plugin for container/HTTP, module for isolated services). Use when adding tests for modules, workflows, subscribers, jobs, or API routes."
 argument-hint: "[module-or-feature]"
 allowed-tools: Bash, Read, Write, Edit, Grep, Glob
 ---
 
 # Write Test (Plugin)
 
-Generate tests for AcmeKit plugins using the correct test runner and patterns.
-
-**CRITICAL:** Plugin tests have NO HTTP server. Do NOT generate tests using `api.get()`, `api.post()`, or `acmekitIntegrationTestRunner`. Test services directly through `container.resolve()`.
+Generate tests for AcmeKit plugins using `integrationTestRunner` with the correct mode and patterns.
 
 ## Current Test Files
 
 - Existing tests: !`find src -name "*.spec.ts" -o -name "*.test.ts" 2>/dev/null | head -20 || echo "(none)"`
 - Plugin integration tests: !`ls integration-tests/plugin/*.spec.ts 2>/dev/null || echo "(none)"`
+- HTTP integration tests: !`ls integration-tests/http/*.spec.ts 2>/dev/null || echo "(none)"`
 
 ## Critical Gotchas — Every Test Must Get These Right
 
-1. **Service resolution key = module constant.** `container.resolve(BLOG_MODULE)` where `BLOG_MODULE = "blog"` (the string passed to `Module()`). NEVER guess `"blogModuleService"` — it won't resolve (AwilixResolutionError).
-2. **`moduleName` in `moduleIntegrationTestRunner` = module constant.** Same rule: `moduleName: MY_MODULE` where `MY_MODULE` matches `Module()`. NEVER use `"myModuleService"`.
-3. **`resolve` in `moduleIntegrationTestRunner` = string path from CWD.** Use `resolve: "./src/modules/my-module"`. NEVER pass the imported module object (`resolve: BlogModule` hangs — models not found).
-4. **Workflow errors are plain objects, not Error instances.** NEVER use `.rejects.toThrow()` on workflows — always fails. Use `throwOnError: false` + `errors` array. Error path: `errors[0].error.message` (NOT `errors[0].message`).
-5. **`.rejects.toThrow()` DOES work for service errors** (e.g., `service.retrievePost("bad-id")`). Only workflow errors are serialized.
-6. **Schema sync, not migrations.** `pluginIntegrationTestRunner` and `moduleIntegrationTestRunner` sync schema from entities — no migration files needed.
+1. **Unified runner only.** `import { integrationTestRunner } from "@acmekit/test-utils"`. NEVER use `pluginIntegrationTestRunner` or `moduleIntegrationTestRunner` — those are deprecated.
+2. **Service resolution key = module constant.** `container.resolve(GREETING_MODULE)` where `GREETING_MODULE = "greeting"` (the string passed to `Module()`). NEVER guess `"greetingModuleService"`.
+3. **`resolve` in module mode = absolute path.** Use `resolve: process.cwd() + "/src/modules/greeting"`. NEVER pass the imported module object.
+4. **Workflow errors are plain objects.** NEVER use `.rejects.toThrow()` on workflows. Use `throwOnError: false` + `errors` array. Error path: `errors[0].error.message`.
+5. **`.rejects.toThrow()` DOES work for service errors** (real `Error` instances). Only workflow errors are serialized.
+6. **Container-only vs HTTP.** Plugin mode without `http: true` has NO `api` fixture. NEVER use `api.get()` or `api.post()` in container-only tests.
+7. **HTTP mode requires auth.** `mode: "plugin"` + `http: true` boots the full framework — inline JWT + client API key setup in `beforeEach`.
+8. **Axios throws on 4xx/5xx.** Use `.catch((e: any) => e)` for error assertions in HTTP tests.
+9. **MockEventBusService emit takes arrays.** In plugin container mode, `emit` receives `[{ name, data }]` (array). Real event bus uses `{ name, data }` (single object).
 
 ## Instructions
 
 ### Step 1: Determine Test Type
 
-| What to test | Runner | File location |
+| What to test | Mode | File location |
 |---|---|---|
-| Full plugin (all resources loaded) | `pluginIntegrationTestRunner` | `integration-tests/plugin/<feature>.spec.ts` |
-| Module service methods (isolated) | `moduleIntegrationTestRunner` | `src/modules/<mod>/__tests__/<name>.spec.ts` |
-| Workflows (through container) | `pluginIntegrationTestRunner` | `integration-tests/plugin/<feature>.spec.ts` |
-| Pure functions | Plain Jest `describe/it` | `src/**/__tests__/<name>.unit.spec.ts` |
+| API routes (HTTP end-to-end) | `mode: "plugin"` + `http: true` | `integration-tests/http/<feature>.spec.ts` |
+| Workflows, subscribers, jobs (container) | `mode: "plugin"` | `integration-tests/plugin/<feature>.spec.ts` |
+| Module service methods (isolated) | `mode: "module"` | `src/modules/<mod>/__tests__/<name>.spec.ts` |
+| Pure functions | Plain Jest | `src/**/__tests__/<name>.unit.spec.ts` |
 
 ### Step 2: Generate Test File
 
-#### Plugin Integration Test
+#### Plugin HTTP Integration Test
 
 ```typescript
-import { pluginIntegrationTestRunner } from "@acmekit/test-utils"
-import { plugin } from "../../src/plugin"
-import { BLOG_MODULE } from "../../src/modules/blog"  // BLOG_MODULE = "blog" — must match Module() key
-
-jest.setTimeout(60 * 1000)
-
-pluginIntegrationTestRunner({
+import { integrationTestRunner } from "@acmekit/test-utils"
+import {
+  ApiKeyType,
+  CLIENT_API_KEY_HEADER,
+  ContainerRegistrationKeys,
+  generateJwtToken,
+  Modules,
+} from "@acmekit/framework/utils"
+import { GREETING_MODULE } from "../../src/modules/greeting"
+
+jest.setTimeout(120 * 1000)
+
+integrationTestRunner({
+  mode: "plugin",
+  http: true,
   pluginPath: process.cwd(),
-  pluginOptions: {
-    apiKey: "test-api-key",
-  },
-  testSuite: ({ container, acmekitApp }) => {
-    describe("Plugin loading", () => {
-      it("should load plugin modules", () => {
-        expect(acmekitApp.modules).toBeDefined()
+  pluginOptions: { apiKey: "test-api-key" },
+  testSuite: ({ api, container }) => {
+    let adminHeaders: Record<string, any>
+    let clientHeaders: Record<string, any>
+
+    beforeEach(async () => {
+      const userModule = container.resolve(Modules.USER)
+      const authModule = container.resolve(Modules.AUTH)
+      const apiKeyModule = container.resolve(Modules.API_KEY)
+
+      const user = await userModule.createUsers({
+        email: "admin@test.js",
       })
 
-      it("should resolve typed plugin options", () => {
-        const options = plugin.resolveOptions(container)
-        expect(options.apiKey).toBe("test-api-key")
+      const authIdentity = await authModule.createAuthIdentities({
+        provider_identities: [
+          { provider: "emailpass", entity_id: "admin@test.js" },
+        ],
+        app_metadata: { user_id: user.id },
       })
-    })
-
-    describe("BlogModule CRUD", () => {
-      let service: any
 
-      beforeEach(() => {
-        service = container.resolve(BLOG_MODULE)  // resolves via module key
+      const config = container.resolve(
+        ContainerRegistrationKeys.CONFIG_MODULE
+      )
+      const { jwtSecret, jwtOptions } = config.projectConfig.http
+
+      const token = generateJwtToken(
+        {
+          actor_id: user.id,
+          actor_type: "user",
+          auth_identity_id: authIdentity.id,
+          app_metadata: { user_id: user.id },
+        },
+        { secret: jwtSecret, expiresIn: "1d", jwtOptions }
+      )
+
+      adminHeaders = {
+        headers: { authorization: `Bearer ${token}` },
+      }
+
+      const apiKey = await apiKeyModule.createApiKeys({
+        title: "Test Client Key",
+        type: ApiKeyType.CLIENT,
+        created_by: "test",
       })
 
-      it("should create a blog post", async () => {
-        const result = await service.createBlogPosts([
-          { title: "Launch Announcement" },
-        ])
-        expect(result).toHaveLength(1)
-        expect(result[0]).toEqual(
+      clientHeaders = {
+        headers: { [CLIENT_API_KEY_HEADER]: apiKey.token },
+      }
+    })
+
+    describe("POST /admin/plugin/greetings", () => {
+      it("should create a greeting", async () => {
+        const response = await api.post(
+          "/admin/plugin/greetings",
+          { message: "Hello from HTTP" },
+          adminHeaders
+        )
+        expect(response.status).toEqual(200)
+        expect(response.data.greeting).toEqual(
           expect.objectContaining({
             id: expect.any(String),
-            title: "Launch Announcement",
+            message: "Hello from HTTP",
           })
         )
       })
 
-      it("should list and count", async () => {
-        await service.createBlogPosts([{ title: "A" }, { title: "B" }])
-        const [posts, count] = await service.listAndCountBlogPosts()
-        expect(count).toBe(2)
+      it("should reject missing required fields", async () => {
+        const { response } = await api
+          .post("/admin/plugin/greetings", {}, adminHeaders)
+          .catch((e: any) => e)
+        expect(response.status).toEqual(400)
+      })
+    })
+
+    describe("DELETE /admin/plugin/greetings/:id", () => {
+      it("should soft-delete and confirm", async () => {
+        const created = (
+          await api.post(
+            "/admin/plugin/greetings",
+            { message: "Delete me" },
+            adminHeaders
+          )
+        ).data.greeting
+
+        const response = await api.delete(
+          `/admin/plugin/greetings/${created.id}`,
+          adminHeaders
+        )
+        expect(response.data).toEqual({
+          id: created.id,
+          object: "greeting",
+          deleted: true,
+        })
       })
+    })
 
-      it("should throw on missing required field", async () => {
-        await expect(service.createBlogPosts([{}])).rejects.toThrow()
+    describe("Client routes", () => {
+      it("GET /client/plugin/greetings with API key", async () => {
+        await api.post(
+          "/admin/plugin/greetings",
+          { message: "Public" },
+          adminHeaders
+        )
+        const response = await api.get(
+          "/client/plugin/greetings",
+          clientHeaders
+        )
+        expect(response.status).toEqual(200)
+        expect(response.data.greetings).toHaveLength(1)
       })
     })
   },
 })
 ```
 
-**Fixtures:** `container` (proxy), `acmekitApp`, `MikroOrmWrapper`, `dbConfig`.
+#### Plugin Container Integration Test (workflows, subscribers, jobs)
 
-#### Module Integration Test (Isolated)
+```typescript
+import { integrationTestRunner } from "@acmekit/test-utils"
+import { createGreetingsWorkflow } from "../../src/workflows"
+import { GREETING_MODULE } from "../../src/modules/greeting"
+
+jest.setTimeout(60 * 1000)
+
+integrationTestRunner({
+  mode: "plugin",
+  pluginPath: process.cwd(),
+  pluginOptions: { apiKey: "test-api-key" },
+  testSuite: ({ container }) => {
+    it("should create via workflow", async () => {
+      const { result } = await createGreetingsWorkflow(container).run({
+        input: { greetings: [{ message: "Workflow Hello" }] },
+      })
+      expect(result).toHaveLength(1)
+      expect(result[0].message).toBe("Workflow Hello")
+    })
+
+    it("should reject invalid input", async () => {
+      const { errors } = await createGreetingsWorkflow(container).run({
+        input: { greetings: [{ message: "", status: "invalid" }] },
+        throwOnError: false,
+      })
+      expect(errors).toHaveLength(1)
+      expect(errors[0].error.message).toContain("Invalid")
+    })
+  },
+})
+```
+
+#### Subscriber Test (direct handler invocation)
 
 ```typescript
-import { moduleIntegrationTestRunner } from "@acmekit/test-utils"
-import { BLOG_MODULE } from "../../src/modules/blog"  // BLOG_MODULE = "blog" — must match Module() key
+import { integrationTestRunner } from "@acmekit/test-utils"
+import greetingCreatedHandler from "../../src/subscribers/greeting-created"
+import { GREETING_MODULE } from "../../src/modules/greeting"
 
-jest.setTimeout(30000)
+jest.setTimeout(60 * 1000)
 
-moduleIntegrationTestRunner<IBlogModuleService>({
-  moduleName: BLOG_MODULE,  // must match Module() key
-  resolve: "./src/modules/blog",  // string path from CWD — NEVER pass imported module object
-  testSuite: ({ service }) => {
-    it("should create a blog post", async () => {
-      const result = await service.createBlogPosts([
-        { title: "Quarterly Report" },
-      ])
-      expect(result).toEqual([
-        expect.objectContaining({ title: "Quarterly Report" }),
+integrationTestRunner({
+  mode: "plugin",
+  pluginPath: process.cwd(),
+  testSuite: ({ container }) => {
+    it("should append ' [notified]' to greeting message", async () => {
+      const service: any = container.resolve(GREETING_MODULE)
+      const [greeting] = await service.createGreetings([
+        { message: "Hello World" },
       ])
+
+      await greetingCreatedHandler({
+        event: {
+          data: { id: greeting.id },
+          name: "greeting.created",
+        },
+        container,
+      })
+
+      const updated = await service.retrieveGreeting(greeting.id)
+      expect(updated.message).toBe("Hello World [notified]")
     })
   },
 })
 ```
 
-**Fixtures:** `service` (proxy), `MikroOrmWrapper`, `acmekitApp`, `dbConfig`.
-
-#### Unit Test
+#### Job Test (direct invocation)
 
 ```typescript
-import { formatSlug } from "../format-slug"
+import { integrationTestRunner } from "@acmekit/test-utils"
+import cleanupGreetingsJob from "../../src/jobs/cleanup-greetings"
+import { GREETING_MODULE } from "../../src/modules/greeting"
 
-describe("formatSlug", () => {
-  it("should kebab-case the title", () => {
-    expect(formatSlug("Hello World")).toBe("hello-world")
-  })
+jest.setTimeout(60 * 1000)
+
+integrationTestRunner({
+  mode: "plugin",
+  pluginPath: process.cwd(),
+  testSuite: ({ container }) => {
+    it("should soft-delete greetings with lang='old'", async () => {
+      const service: any = container.resolve(GREETING_MODULE)
+
+      await service.createGreetings([
+        { message: "Old 1", lang: "old" },
+        { message: "Old 2", lang: "old" },
+        { message: "Current", lang: "en" },
+      ])
+
+      await cleanupGreetingsJob(container)
+
+      const remaining = await service.listGreetings()
+      expect(remaining).toHaveLength(1)
+      expect(remaining[0].lang).toBe("en")
+    })
+  },
 })
 ```
 
-#### Testing Workflows Through Container
+#### Unit Test (No Framework Bootstrap)
 
-```typescript
-import { createBlogPostWorkflow } from "../../src/workflows"
+For providers, utilities, and standalone classes. **CRITICAL:** `jest.mock()` factories are hoisted above `const`/`let`. Create mocks INSIDE the factory, access via `require()`.
 
-// Direct execution
-it("should execute the workflow", async () => {
-  const { result } = await createBlogPostWorkflow(container).run({
-    input: { title: "Workflow Test", author: "Admin" },
-  })
-  expect(result.blogPost).toEqual(
-    expect.objectContaining({ title: "Workflow Test" })
-  )
+```typescript
+jest.mock("external-sdk", () => {
+  const mocks = { doThing: jest.fn() }
+  const MockClient = jest.fn().mockImplementation(() => ({
+    doThing: mocks.doThing,
+  }))
+  return { Client: MockClient, __mocks: mocks }
 })
 
-it("should reject invalid workflow input", async () => {
-  const { errors } = await createBlogPostWorkflow(container).run({
-    input: {},
-    throwOnError: false,
+const { __mocks: sdkMocks } = require("external-sdk")
+
+import MyProvider from "../my-provider"
+
+describe("MyProvider", () => {
+  const mockContainer = {} as any
+
+  beforeEach(() => {
+    jest.clearAllMocks()
   })
-  expect(errors).toHaveLength(1)
-  expect(errors[0].error.message).toContain("title")  // errors[0].error.message — NOT errors[0].message
-})
 
-// Typed errors — PermanentFailure stops retries, SkipStep skips gracefully
-it("should permanently fail on invalid card", async () => {
-  const { errors } = await chargeCardWorkflow(container).run({
-    input: { cardToken: "invalid", amount: 100 },
-    throwOnError: false,
+  it("should have correct identifier", () => {
+    expect(MyProvider.identifier).toBe("my-provider")
   })
-  expect(errors[0].error.message).toContain("Card declined")
-})
 
-it("should skip optional step when disabled", async () => {
-  const { result } = await processOrderWorkflow(container).run({
-    input: { items: [{ id: "item-1" }] },
-    throwOnError: false,
+  it("should delegate to SDK", async () => {
+    sdkMocks.doThing.mockResolvedValue({ success: true })
+    const provider = new MyProvider(mockContainer, { apiKey: "key" })
+    const result = await provider.doSomething({ input: "test" })
+    expect(result.success).toBe(true)
   })
-  // SkipStep doesn't produce errors — workflow continues
-  expect(result).toBeDefined()
 })
 ```
 
-#### Testing Domain Events
+**Timer mocking:** Use `jest.useFakeTimers()` + `jest.advanceTimersByTimeAsync()` or `jest.spyOn(instance, "sleep_").mockResolvedValue(undefined)`.
 
-```typescript
-import { MockEventBusService } from "@acmekit/test-utils"
-
-let eventBusSpy: jest.SpyInstance
-beforeEach(() => { eventBusSpy = jest.spyOn(MockEventBusService.prototype, "emit") })
-afterEach(() => { eventBusSpy.mockRestore() })
-
-it("should emit blog-post.created event", async () => {
-  const service = container.resolve(BLOG_MODULE)  // "blog" — from Module() key
-  await service.createBlogPosts([{ title: "Event Test" }])
-  expect(eventBusSpy).toHaveBeenCalledWith(
-    [expect.objectContaining({
-      name: "blog-post.created",
-      data: expect.objectContaining({ id: expect.any(String) }),
-    })],
-    { internal: true }
-  )
-})
-```
+**SWC regex:** Use `new RegExp("...")` instead of complex regex literals.
 
-#### Testing Subscribers
+#### Module Integration Test (isolated)
 
 ```typescript
-import { TestEventUtils } from "@acmekit/test-utils"
-import { Modules } from "@acmekit/framework/utils"
-
-it("should execute subscriber side-effect", async () => {
-  const eventBus = container.resolve(Modules.EVENT_BUS)
-  // IMPORTANT: capture promise BEFORE triggering event
-  const subscriberExecution = TestEventUtils.waitSubscribersExecution(
-    "blog-post.created",
-    eventBus
-  )
-  const service = container.resolve(BLOG_MODULE)  // "blog" — from Module() key
-  await service.createBlogPosts([{ title: "Trigger Subscriber" }])
-  await subscriberExecution
-  // assert subscriber side-effect
+import { integrationTestRunner } from "@acmekit/test-utils"
+
+jest.setTimeout(30000)
+
+integrationTestRunner<IGreetingModuleService>({
+  mode: "module",
+  moduleName: "greeting",
+  resolve: process.cwd() + "/src/modules/greeting",
+  testSuite: ({ service }) => {
+    it("should create a greeting", async () => {
+      const result = await service.createGreetings([
+        { message: "Hello" },
+      ])
+      expect(result[0]).toEqual(
+        expect.objectContaining({ message: "Hello" })
+      )
+    })
+  },
 })
 ```
 
@@ -228,16 +345,27 @@ it("should execute subscriber side-effect", async () => {
 ```bash
 pnpm test:unit                      # Unit tests
 pnpm test:integration:modules       # Module integration tests
-pnpm test:integration:plugin        # Full plugin integration tests
+pnpm test:integration:plugin        # Plugin container tests
+pnpm test:integration:http          # Plugin HTTP tests
 ```
 
 ## Key Patterns
 
+- Use `integrationTestRunner` with `mode` — never the old deprecated runner names
 - Match the `jest.config.js` test buckets — don't invent new locations
-- All integration tests require `NODE_OPTIONS=--experimental-vm-modules`
-- Runners handle DB setup/teardown automatically — no manual cleanup needed
-- NEVER use `api.get()` or `api.post()` — plugin tests have no HTTP server
-- Always use `pluginPath: process.cwd()` unless the repo structure requires a different path
+- Always use `pluginPath: process.cwd()` — never hardcode paths
+- Container-only tests: access services via `container.resolve(MODULE_CONSTANT)` — no `api` fixture
+- HTTP tests: full auth setup with `generateJwtToken` + `ApiKeyType.CLIENT` — no `createAdminUser` helper
+- Plugin depends on other plugins: add `skipDependencyValidation: true` + mock peer services via `injectedDependencies`
+- Plugin providers need options: use `pluginModuleOptions: { moduleName: { providers: [...] } }`
+- Pass body directly: `api.post(url, body, headers)` — NOT `{ body: {...} }`
+- Use `.catch((e: any) => e)` for error assertions — axios throws on 4xx/5xx
 - Use `expect.objectContaining()` with `expect.any(String)` for IDs/timestamps
-- Call `waitSubscribersExecution` BEFORE triggering the event
+- Test subscribers by importing handler directly and calling with `{ event, container }`
+- Test jobs by importing function directly and calling with `container`
 - Use realistic test data, not "test" or "foo"
+- **Always `beforeEach(() => jest.clearAllMocks())`** in unit tests — mock state leaks between describes
+- **Never reference file-level `const`/`let` inside `jest.mock()` factories** — TDZ error (SWC/Babel hoisting)
+- **Mock timers or sleep** when code under test has delays — prevents test timeouts
+- **Use `new RegExp()` over complex regex literals** — SWC parser fails on some patterns
+- **Read implementation to verify error paths** — check if errors are thrown vs returned

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@acmekit/acmekit",
-  "version": "2.13.83",
+  "version": "2.13.85",
   "description": "Generic application bootstrap and loaders for the AcmeKit framework",
   "main": "dist/index.js",
   "exports": {
@@ -49,45 +49,45 @@
     "test:integration": "../../node_modules/.bin/jest --passWithNoTests --forceExit --testPathPattern=\"src/.*/integration-tests/__tests__/.*\\.ts\""
   },
   "devDependencies": {
-    "@acmekit/framework": "2.13.83"
+    "@acmekit/framework": "2.13.85"
   },
   "dependencies": {
-    "@acmekit/admin-bundler": "2.13.83",
-    "@acmekit/analytics": "2.13.83",
-    "@acmekit/analytics-local": "2.13.83",
-    "@acmekit/analytics-posthog": "2.13.83",
-    "@acmekit/api-key": "2.13.83",
-    "@acmekit/auth": "2.13.83",
-    "@acmekit/auth-emailpass": "2.13.83",
-    "@acmekit/auth-github": "2.13.83",
-    "@acmekit/auth-google": "2.13.83",
-    "@acmekit/cache-inmemory": "2.13.83",
-    "@acmekit/cache-redis": "2.13.83",
-    "@acmekit/caching": "2.13.83",
-    "@acmekit/caching-redis": "2.13.83",
-    "@acmekit/core-flows": "2.13.83",
-    "@acmekit/event-bus-local": "2.13.83",
-    "@acmekit/event-bus-redis": "2.13.83",
-    "@acmekit/file": "2.13.83",
-    "@acmekit/file-local": "2.13.83",
-    "@acmekit/file-s3": "2.13.83",
-    "@acmekit/index": "2.13.83",
-    "@acmekit/link-modules": "2.13.83",
-    "@acmekit/locking": "2.13.83",
-    "@acmekit/locking-postgres": "2.13.83",
-    "@acmekit/locking-redis": "2.13.83",
-    "@acmekit/notification": "2.13.83",
-    "@acmekit/notification-local": "2.13.83",
-    "@acmekit/notification-sendgrid": "2.13.83",
-    "@acmekit/rbac": "2.13.83",
-    "@acmekit/secrets-aws": "2.13.83",
-    "@acmekit/secrets-local": "2.13.83",
-    "@acmekit/settings": "2.13.83",
-    "@acmekit/telemetry": "2.13.83",
-    "@acmekit/translation": "2.13.83",
-    "@acmekit/user": "2.13.83",
-    "@acmekit/workflow-engine-inmemory": "2.13.83",
-    "@acmekit/workflow-engine-redis": "2.13.83",
+    "@acmekit/admin-bundler": "2.13.85",
+    "@acmekit/analytics": "2.13.85",
+    "@acmekit/analytics-local": "2.13.85",
+    "@acmekit/analytics-posthog": "2.13.85",
+    "@acmekit/api-key": "2.13.85",
+    "@acmekit/auth": "2.13.85",
+    "@acmekit/auth-emailpass": "2.13.85",
+    "@acmekit/auth-github": "2.13.85",
+    "@acmekit/auth-google": "2.13.85",
+    "@acmekit/cache-inmemory": "2.13.85",
+    "@acmekit/cache-redis": "2.13.85",
+    "@acmekit/caching": "2.13.85",
+    "@acmekit/caching-redis": "2.13.85",
+    "@acmekit/core-flows": "2.13.85",
+    "@acmekit/event-bus-local": "2.13.85",
+    "@acmekit/event-bus-redis": "2.13.85",
+    "@acmekit/file": "2.13.85",
+    "@acmekit/file-local": "2.13.85",
+    "@acmekit/file-s3": "2.13.85",
+    "@acmekit/index": "2.13.85",
+    "@acmekit/link-modules": "2.13.85",
+    "@acmekit/locking": "2.13.85",
+    "@acmekit/locking-postgres": "2.13.85",
+    "@acmekit/locking-redis": "2.13.85",
+    "@acmekit/notification": "2.13.85",
+    "@acmekit/notification-local": "2.13.85",
+    "@acmekit/notification-sendgrid": "2.13.85",
+    "@acmekit/rbac": "2.13.85",
+    "@acmekit/secrets-aws": "2.13.85",
+    "@acmekit/secrets-local": "2.13.85",
+    "@acmekit/settings": "2.13.85",
+    "@acmekit/telemetry": "2.13.85",
+    "@acmekit/translation": "2.13.85",
+    "@acmekit/user": "2.13.85",
+    "@acmekit/workflow-engine-inmemory": "2.13.85",
+    "@acmekit/workflow-engine-redis": "2.13.85",
     "@inquirer/checkbox": "^2.3.11",
     "@inquirer/input": "^2.2.9",
     "boxen": "^5.0.1",
@@ -106,7 +106,7 @@
   },
   "peerDependencies": {
     "@acmekit/docs-bundler": "^2.13.42",
-    "@acmekit/framework": "2.13.83",
+    "@acmekit/framework": "2.13.85",
     "@jimsheen/yalc": "^1.2.2",
     "@swc/core": "^1.7.28",
     "posthog-node": "^5.11.0",