@ekairos/structure 1.22.22-beta.development.0 → 1.22.24-beta.feature-events-package-refactor.0

package/dist/contextPersistence.d.ts

@@ -0,0 +1,29 @@
+declare const STRUCTURE_CONTEXT_ENTITIES: readonly ["event_contexts", "thread_contexts"];
+type StructureContextEntity = (typeof STRUCTURE_CONTEXT_ENTITIES)[number];
+type FindStructureContextParams = {
+    includeOutputFile?: boolean;
+};
+type FindStructureContextResult = {
+    entity: StructureContextEntity;
+    row: any;
+};
+export declare function findStructureContextByKey(db: any, key: string, params?: FindStructureContextParams): Promise<FindStructureContextResult | null>;
+export declare function createStructureContext(db: any, params: {
+    id: string;
+    key: string;
+    content?: Record<string, unknown>;
+    status?: string;
+    createdAt?: Date;
+}): Promise<{
+    entity: "event_contexts" | "thread_contexts";
+    id: string;
+}>;
+export declare function linkStructureOutputFileToContextByKey(db: any, params: {
+    contextKey: string;
+    fileId: string;
+}): Promise<void>;
+export declare function unlinkStructureOutputFileFromContextByKey(db: any, params: {
+    contextKey: string;
+    fileId: string;
+}): Promise<void>;
+export {};

package/dist/contextPersistence.js

@@ -0,0 +1,64 @@
+const STRUCTURE_CONTEXT_ENTITIES = ["event_contexts", "thread_contexts"];
+function buildContextQuery(entity, key, includeOutputFile) {
+    return {
+        [entity]: {
+            $: { where: { key }, limit: 1 },
+            ...(includeOutputFile ? { structure_output_file: {} } : {}),
+        },
+    };
+}
+function preferredContextEntity(db) {
+    if (db?.tx?.event_contexts)
+        return "event_contexts";
+    if (db?.tx?.thread_contexts)
+        return "thread_contexts";
+    throw new Error("No persisted context collection is available");
+}
+export async function findStructureContextByKey(db, key, params = {}) {
+    let lastError = null;
+    let queried = false;
+    for (const entity of STRUCTURE_CONTEXT_ENTITIES) {
+        try {
+            const res = await db.query(buildContextQuery(entity, key, Boolean(params.includeOutputFile)));
+            queried = true;
+            const row = res?.[entity]?.[0];
+            if (row)
+                return { entity, row };
+        }
+        catch (error) {
+            lastError = error;
+        }
+    }
+    if (!queried && lastError) {
+        throw lastError;
+    }
+    return null;
+}
+export async function createStructureContext(db, params) {
+    const entity = preferredContextEntity(db);
+    await db.transact([
+        db.tx[entity][params.id].create({
+            createdAt: params.createdAt ?? new Date(),
+            content: params.content ?? {},
+            key: params.key,
+            status: params.status ?? "open",
+        }),
+    ]);
+    return { entity, id: params.id };
+}
+export async function linkStructureOutputFileToContextByKey(db, params) {
+    const context = await findStructureContextByKey(db, params.contextKey);
+    const ctxId = context?.row?.id;
+    if (!context || !ctxId) {
+        throw new Error("Context not found");
+    }
+    await db.transact([db.tx[context.entity][ctxId].link({ structure_output_file: params.fileId })]);
+}
+export async function unlinkStructureOutputFileFromContextByKey(db, params) {
+    const context = await findStructureContextByKey(db, params.contextKey);
+    const ctxId = context?.row?.id;
+    if (!context || !ctxId) {
+        throw new Error("Context not found");
+    }
+    await db.transact([db.tx[context.entity][ctxId].unlink({ structure_output_file: params.fileId })]);
+}

package/dist/dataset/steps.js

@@ -1,7 +1,8 @@
+import { findStructureContextByKey, linkStructureOutputFileToContextByKey, unlinkStructureOutputFileFromContextByKey, } from "../contextPersistence.js";
 export async function structureGetOrCreateContextStep(params) {
     "use step";
     try {
-        const { getThreadRuntime } = await import("@ekairos/thread/runtime");
+        const { getThreadRuntime } = await import("@ekairos/events/runtime");
         const runtime = await getThreadRuntime(params.env);
         const ctx = await runtime.store.getOrCreateContext({ key: params.contextKey });
         return { ok: true, data: ctx };
@@ -14,7 +15,7 @@ export async function structureGetOrCreateContextStep(params) {
 export async function structureGetContextStep(params) {
     "use step";
     try {
-        const { getThreadRuntime } = await import("@ekairos/thread/runtime");
+        const { getThreadRuntime } = await import("@ekairos/events/runtime");
         const runtime = await getThreadRuntime(params.env);
         const ctx = await runtime.store.getContext({ key: params.contextKey });
         if (!ctx)
@@ -29,7 +30,7 @@ export async function structureGetContextStep(params) {
 export async function structureUpdateContextContentStep(params) {
     "use step";
     try {
-        const { getThreadRuntime } = await import("@ekairos/thread/runtime");
+        const { getThreadRuntime } = await import("@ekairos/events/runtime");
         const runtime = await getThreadRuntime(params.env);
         const updated = await runtime.store.updateContextContent({ key: params.contextKey }, params.content);
         return { ok: true, data: updated };
@@ -42,7 +43,7 @@ export async function structureUpdateContextContentStep(params) {
 export async function structurePatchContextContentStep(params) {
     "use step";
     try {
-        const { getThreadRuntime } = await import("@ekairos/thread/runtime");
+        const { getThreadRuntime } = await import("@ekairos/events/runtime");
         const runtime = await getThreadRuntime(params.env);
         const existing = await runtime.store.getOrCreateContext({ key: params.contextKey });
         const existingContent = (existing?.content ?? {});
@@ -65,7 +66,7 @@ export async function structureUploadRowsOutputJsonlStep(params) {
     "use step";
     const startedAt = Date.now();
     try {
-        const { getThreadRuntime } = await import("@ekairos/thread/runtime");
+        const { getThreadRuntime } = await import("@ekairos/events/runtime");
         const runtime = await getThreadRuntime(params.env);
         const db = runtime.db;
         const storagePath = `/structure/${params.structureId}/output.jsonl`;
@@ -89,15 +90,12 @@ export async function structureLinkRowsOutputFileToContextStep(params) {
     "use step";
     const startedAt = Date.now();
     try {
-        const { getThreadRuntime } = await import("@ekairos/thread/runtime");
+        const { getThreadRuntime } = await import("@ekairos/events/runtime");
         const runtime = await getThreadRuntime(params.env);
         const store = runtime.store;
         const db = runtime.db;
-        const ctx = await store.getOrCreateContext({ key: params.contextKey });
-        const ctxId = ctx?.id;
-        if (!ctxId)
-            return { ok: false, error: "Context not found" };
-        await db.transact([db.tx.thread_contexts[ctxId].link({ structure_output_file: params.fileId })]);
+        await store.getOrCreateContext({ key: params.contextKey });
+        await linkStructureOutputFileToContextByKey(db, { contextKey: params.contextKey, fileId: params.fileId });
         console.log(`[structure:link-jsonl] contextKey=${params.contextKey} fileId=${params.fileId} elapsedMs=${Date.now() - startedAt}`);
         return { ok: true };
     }
@@ -109,15 +107,12 @@ export async function structureLinkRowsOutputFileToContextStep(params) {
 export async function structureUnlinkRowsOutputFileFromContextStep(params) {
     "use step";
     try {
-        const { getThreadRuntime } = await import("@ekairos/thread/runtime");
+        const { getThreadRuntime } = await import("@ekairos/events/runtime");
         const runtime = await getThreadRuntime(params.env);
         const store = runtime.store;
         const db = runtime.db;
-        const ctx = await store.getOrCreateContext({ key: params.contextKey });
-        const ctxId = ctx?.id;
-        if (!ctxId)
-            return { ok: false, error: "Context not found" };
-        await db.transact([db.tx.thread_contexts[ctxId].unlink({ structure_output_file: params.fileId })]);
+        await store.getOrCreateContext({ key: params.contextKey });
+        await unlinkStructureOutputFileFromContextByKey(db, { contextKey: params.contextKey, fileId: params.fileId });
         return { ok: true };
     }
     catch (error) {
@@ -128,16 +123,11 @@ export async function structureUnlinkRowsOutputFileFromContextStep(params) {
 export async function structureGetContextWithRowsOutputFileStep(params) {
     "use step";
     try {
-        const { getThreadRuntime } = await import("@ekairos/thread/runtime");
+        const { getThreadRuntime } = await import("@ekairos/events/runtime");
         const runtime = await getThreadRuntime(params.env);
         const db = runtime.db;
-        const query = (await db.query({
-            thread_contexts: {
-                $: { where: { key: params.contextKey }, limit: 1 },
-                structure_output_file: {},
-            },
-        }));
-        const row = query.thread_contexts?.[0];
+        const persisted = await findStructureContextByKey(db, params.contextKey, { includeOutputFile: true });
+        const row = persisted?.row;
         if (!row)
             return { ok: false, error: "Context not found" };
         return { ok: true, data: row };
@@ -152,16 +142,11 @@ export async function structureReadRowsOutputJsonlStep(params) {
     const startedAt = Date.now();
     try {
         const contextKey = `structure:${params.structureId}`;
-        const { getThreadRuntime } = await import("@ekairos/thread/runtime");
+        const { getThreadRuntime } = await import("@ekairos/events/runtime");
         const runtime = await getThreadRuntime(params.env);
         const db = runtime.db;
-        const query = (await db.query({
-            thread_contexts: {
-                $: { where: { key: contextKey }, limit: 1 },
-                structure_output_file: {},
-            },
-        }));
-        const ctx = query.thread_contexts?.[0];
+        const persisted = await findStructureContextByKey(db, contextKey, { includeOutputFile: true });
+        const ctx = persisted?.row;
         if (!ctx)
             return { ok: false, error: "Context not found" };
         const linked = Array.isArray(ctx?.structure_output_file) ? ctx.structure_output_file[0] : ctx.structure_output_file;

package/dist/file/steps.js

@@ -1,6 +1,6 @@
 export async function readInstantFileStep(params) {
     "use step";
-    const { getThreadRuntime } = await import("@ekairos/thread/runtime");
+    const { getThreadRuntime } = await import("@ekairos/events/runtime");
     const runtime = (await getThreadRuntime(params.env));
     const db = runtime.db;
     const { DatasetService } = await import("../service.js");

package/dist/rowsOutputPaging.js

@@ -1,5 +1,6 @@
 import { getDatasetOutputPath, getDatasetWorkstation } from "./datasetFiles.js";
 import { createDatasetSandboxStep, runDatasetSandboxCommandStep } from "./sandbox/steps.js";
+import { findStructureContextByKey } from "./contextPersistence.js";
 import { getThreadRuntime } from "./runtime.js";
 /**
  * Step 1/2:
@@ -40,13 +41,8 @@ export async function structureDownloadRowsOutputToSandboxStep(params) {
     const storyRuntime = await getThreadRuntime(params.env);
     const db = storyRuntime.db;
     const contextKey = `structure:${params.structureId}`;
-    const query = (await db.query({
-        thread_contexts: {
-            $: { where: { key: contextKey }, limit: 1 },
-            structure_output_file: {},
-        },
-    }));
-    const ctx = query.thread_contexts?.[0];
+    const persisted = await findStructureContextByKey(db, contextKey, { includeOutputFile: true });
+    const ctx = persisted?.row;
     const linked = Array.isArray(ctx?.structure_output_file) ? ctx.structure_output_file[0] : ctx.structure_output_file;
     const url = linked?.url;
     if (!url) {

package/dist/rowsOutputSplit.js

@@ -1,5 +1,6 @@
 import { getDatasetOutputPath, getDatasetWorkstation } from "./datasetFiles.js";
 import { readDatasetSandboxFileStep, runDatasetSandboxCommandStep } from "./sandbox/steps.js";
+import { linkStructureOutputFileToContextByKey } from "./contextPersistence.js";
 import { getThreadRuntime } from "./runtime.js";
 /**
  * Step:
@@ -102,7 +103,7 @@ export async function structureSplitRowsOutputToDatasetStep(params) {
     if (!ctxId)
         throw new Error("Failed to create child dataset context");
     // Link the output file to the context (used by DatasetService.readRecordsFromFile).
-    await db.transact([db.tx.thread_contexts[ctxId].link({ structure_output_file: fileId })]);
+    await linkStructureOutputFileToContextByKey(db, { contextKey, fileId });
     // Patch metadata under `structure` namespace (never clobber Story runtime keys).
     const existingContent = (ctx?.content ?? {});
     const existingStructure = (existingContent?.structure ?? {});

package/dist/runtime.d.ts

@@ -6,4 +6,4 @@
  *   causing `ReferenceError: getThreadRuntime is not defined`.
  * - Using a dynamic import keeps the symbol resolution local to the step runtime.
  */
-export declare function getThreadRuntime(env: any): Promise<import("@ekairos/thread/runtime").ThreadRuntime>;
+export declare function getThreadRuntime(env: any): Promise<import("@ekairos/events/runtime").ThreadRuntime>;

package/dist/runtime.js

@@ -7,6 +7,6 @@
  * - Using a dynamic import keeps the symbol resolution local to the step runtime.
  */
 export async function getThreadRuntime(env) {
-    const { getThreadRuntime } = await import("@ekairos/thread/runtime");
+    const { getThreadRuntime } = await import("@ekairos/events/runtime");
     return await getThreadRuntime(env);
 }

package/dist/sandbox/steps.js

@@ -104,7 +104,7 @@ export async function createDatasetSandboxStep(params) {
     "use step";
     const startedAt = Date.now();
     const { env, ...configInput } = params;
-    const { getThreadRuntime } = await import("@ekairos/thread/runtime");
+    const { getThreadRuntime } = await import("@ekairos/events/runtime");
     const db = (await getThreadRuntime(env)).db;
     const { SandboxService } = (await import("@ekairos/sandbox"));
     const service = new SandboxService(db);
@@ -181,7 +181,7 @@ export async function createDatasetSandboxStep(params) {
 export async function runDatasetSandboxCommandStep(params) {
     "use step";
     const startedAt = Date.now();
-    const { getThreadRuntime } = await import("@ekairos/thread/runtime");
+    const { getThreadRuntime } = await import("@ekairos/events/runtime");
     const db = (await getThreadRuntime(params.env)).db;
     const { SandboxService } = (await import("@ekairos/sandbox"));
     const service = new SandboxService(db);
@@ -202,7 +202,7 @@ export async function runDatasetSandboxCommandStep(params) {
 export async function writeDatasetSandboxFilesStep(params) {
     "use step";
     const startedAt = Date.now();
-    const { getThreadRuntime } = await import("@ekairos/thread/runtime");
+    const { getThreadRuntime } = await import("@ekairos/events/runtime");
     const db = (await getThreadRuntime(params.env)).db;
     const { SandboxService } = (await import("@ekairos/sandbox"));
     const service = new SandboxService(db);
@@ -233,7 +233,7 @@ export async function writeDatasetSandboxTextFileStep(params) {
 export async function readDatasetSandboxFileStep(params) {
     "use step";
     const startedAt = Date.now();
-    const { getThreadRuntime } = await import("@ekairos/thread/runtime");
+    const { getThreadRuntime } = await import("@ekairos/events/runtime");
     const db = (await getThreadRuntime(params.env)).db;
     const { SandboxService } = (await import("@ekairos/sandbox"));
     const service = new SandboxService(db);
@@ -262,7 +262,7 @@ export async function readDatasetSandboxTextFileStep(params) {
 export async function stopDatasetSandboxStep(params) {
     "use step";
     const startedAt = Date.now();
-    const { getThreadRuntime } = await import("@ekairos/thread/runtime");
+    const { getThreadRuntime } = await import("@ekairos/events/runtime");
     const db = (await getThreadRuntime(params.env)).db;
     const { SandboxService } = (await import("@ekairos/sandbox"));
     const service = new SandboxService(db);

package/dist/schema.js

@@ -1,6 +1,6 @@
 import { i } from "@instantdb/core";
 import { domain } from "@ekairos/domain";
-import { threadDomain } from "@ekairos/thread/schema";
+import { threadDomain } from "@ekairos/events/schema";
 import { sandboxDomain } from "@ekairos/sandbox/schema";
 const entities = {
     // Keep $files compatible with Instant's base file fields used by structure flows.
@@ -19,13 +19,18 @@ const links = {
     /**
      * Structure output link (rows):
      *
-     * - `thread_contexts.structure_output_file` points to the `$files` record for `output.jsonl`.
+     * - `event_contexts.structure_output_file` points to the `$files` record for `output.jsonl`.
+     * - A legacy `thread_contexts` link is kept for mixed deployments during migration.
      * - Reverse label is prefixed to avoid collisions across domains.
      */
     structureContextOutputFile: {
-        forward: { on: "thread_contexts", has: "one", label: "structure_output_file" },
+        forward: { on: "event_contexts", has: "one", label: "structure_output_file" },
         reverse: { on: "$files", has: "many", label: "structure_contexts" },
     },
+    structureLegacyContextOutputFile: {
+        forward: { on: "thread_contexts", has: "one", label: "structure_output_file" },
+        reverse: { on: "$files", has: "many", label: "structure_legacy_contexts" },
+    },
 };
 const rooms = {};
 export const structureDomain = domain("structure")

package/dist/service.d.ts

@@ -8,7 +8,7 @@ export type ServiceResult<T = any> = {
 /**
  * Back-compat helper for reading structure outputs outside the workflow runtime.
  *
- * IMPORTANT: The source of truth is `thread_contexts` (Story context) keyed by `structure:<id>`.
+ * IMPORTANT: The source of truth is the persisted Story/Event context keyed by `structure:<id>`.
  */
 export declare class DatasetService {
     private readonly db;

package/dist/service.js

@@ -1,7 +1,8 @@
+import { createStructureContext, findStructureContextByKey, linkStructureOutputFileToContextByKey, } from "./contextPersistence.js";
 /**
  * Back-compat helper for reading structure outputs outside the workflow runtime.
  *
- * IMPORTANT: The source of truth is `thread_contexts` (Story context) keyed by `structure:<id>`.
+ * IMPORTANT: The source of truth is the persisted Story/Event context keyed by `structure:<id>`.
  */
 export class DatasetService {
     constructor(db) {
@@ -13,13 +14,8 @@ export class DatasetService {
     async getDatasetById(datasetId) {
         try {
             const key = this.contextKey(datasetId);
-            const res = await this.db.query({
-                thread_contexts: {
-                    $: { where: { key }, limit: 1 },
-                    structure_output_file: {},
-                },
-            });
-            const ctx = res.thread_contexts?.[0];
+            const persisted = await findStructureContextByKey(this.db, key, { includeOutputFile: true });
+            const ctx = persisted?.row;
             if (!ctx)
                 return { ok: false, error: "Context not found" };
             return { ok: true, data: ctx };
@@ -43,13 +39,8 @@ export class DatasetService {
     async readRecordsFromFile(datasetId) {
         try {
             const key = this.contextKey(datasetId);
-            const res = await this.db.query({
-                thread_contexts: {
-                    $: { where: { key }, limit: 1 },
-                    structure_output_file: {},
-                },
-            });
-            const ctx = res.thread_contexts?.[0];
+            const persisted = await findStructureContextByKey(this.db, key, { includeOutputFile: true });
+            const ctx = persisted?.row;
             const linked = Array.isArray(ctx?.structure_output_file) ? ctx.structure_output_file[0] : ctx?.structure_output_file;
             const url = linked?.url;
             if (!url)
@@ -89,20 +80,14 @@ export class DatasetService {
         try {
             const datasetId = params.id ?? createUuidV4();
             const key = this.contextKey(datasetId);
-            const existing = await this.db.query({
-                thread_contexts: { $: { where: { key }, limit: 1 } },
-            });
-            const ctx = existing.thread_contexts?.[0];
+            const existing = await findStructureContextByKey(this.db, key);
+            const ctx = existing?.row;
             if (ctx)
                 return { ok: true, data: { datasetId } };
-            await this.db.transact([
-                this.db.tx.thread_contexts[createUuidV4()].create({
-                    createdAt: new Date(),
-                    content: {},
-                    key,
-                    status: "open",
-                }),
-            ]);
+            await createStructureContext(this.db, {
+                id: createUuidV4(),
+                key,
+            });
             return { ok: true, data: { datasetId } };
         }
         catch (error) {
@@ -133,14 +118,10 @@ export class DatasetService {
     async linkFileToDataset(params) {
         try {
             const key = this.contextKey(params.datasetId);
-            const res = await this.db.query({
-                thread_contexts: { $: { where: { key }, limit: 1 } },
-            });
-            const ctx = res?.thread_contexts?.[0];
-            const ctxId = ctx?.id;
-            if (!ctxId)
+            const persisted = await findStructureContextByKey(this.db, key);
+            if (!persisted?.row?.id)
                 return { ok: false, error: "Context not found" };
-            await this.db.transact([this.db.tx.thread_contexts[ctxId].link({ structure_output_file: params.fileId })]);
+            await linkStructureOutputFileToContextByKey(this.db, { contextKey: key, fileId: params.fileId });
             return { ok: true, data: undefined };
         }
         catch (error) {

package/dist/steps/commitFromEvents.step.js

@@ -1,3 +1,4 @@
+import { linkStructureOutputFileToContextByKey } from "../contextPersistence.js";
 function isToolCompletePart(value) {
     if (!value || typeof value !== "object")
         return false;
@@ -22,7 +23,7 @@ export async function structureCommitFromEventsStep(params) {
     "use step";
     const contextKey = `structure:${params.structureId}`;
     try {
-        const { getThreadRuntime } = await import("@ekairos/thread/runtime");
+        const { getThreadRuntime } = await import("@ekairos/events/runtime");
         const runtime = (await getThreadRuntime(params.env));
         const store = runtime.store;
         const db = runtime.db;
@@ -66,10 +67,9 @@ export async function structureCommitFromEventsStep(params) {
                 },
             };
             // Link output file to context (domain-prefixed link)
-            const ctxId = ctx?.id;
-            if (!ctxId)
+            if (!ctx?.id)
                 return { ok: false, error: "Context not found" };
-            await db.transact(db.tx.thread_contexts[ctxId].link({ structure_output_file: out.fileId }));
+            await linkStructureOutputFileToContextByKey(db, { contextKey, fileId: out.fileId });
         }
         await store.updateContextContent({ key: contextKey }, { ...prevContent, structure: nextStructure });
         return { ok: true, data: { committed: true } };

package/dist/steps/persistObjectFromStory.step.js

@@ -36,7 +36,7 @@ function extractJsonObject(text) {
 }
 export async function persistObjectResultFromStoryStep(params) {
     "use step";
-    const { getThreadRuntime } = await import("@ekairos/thread/runtime");
+    const { getThreadRuntime } = await import("@ekairos/events/runtime");
     const runtime = (await getThreadRuntime(params.env));
     const store = runtime.store;
     const contextKey = `structure:${params.datasetId}`;

package/dist/structure.js

@@ -1,4 +1,4 @@
-import { createThread, didToolExecute, INPUT_TEXT_ITEM_TYPE, WEB_CHANNEL } from "@ekairos/thread";
+import { createThread, didToolExecute, INPUT_TEXT_ITEM_TYPE, WEB_CHANNEL } from "@ekairos/events";
 import { getDatasetOutputPath, getDatasetOutputSchemaPath, getDatasetWorkstation, getDaytonaVolumeMountPath, getDaytonaVolumeName, } from "./datasetFiles.js";
 import { structureDownloadRowsOutputToSandboxStep, structureReadRowsOutputPageFromSandboxStep, } from "./rowsOutputPaging.js";
 import { structureSplitRowsOutputToDatasetStep } from "./rowsOutputSplit.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ekairos/structure",
-  "version": "1.22.22-beta.development.0",
+  "version": "1.22.24-beta.feature-events-package-refactor.0",
   "description": "Ekairos Structure - Unified structured extraction (rows or object) from file/text/dataset inputs",
   "type": "module",
   "main": "dist/index.js",
@@ -36,8 +36,8 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@ekairos/domain": "^1.22.22-beta.development.0",
-    "@ekairos/sandbox": "^1.22.22-beta.development.0",
+    "@ekairos/domain": "^1.22.24-beta.feature-events-package-refactor.0",
+    "@ekairos/sandbox": "^1.22.24-beta.feature-events-package-refactor.0",
     "@instantdb/admin": "0.22.126",
     "@instantdb/core": "0.22.126",
     "ai": "^5.0.95",
@@ -46,11 +46,11 @@
     "zod": "^4.1.8"
   },
   "peerDependencies": {
-    "@ekairos/thread": "workspace:*"
+    "@ekairos/events": "workspace:*"
   },
   "devDependencies": {
     "@ekairos/sandbox": "workspace:*",
-    "@ekairos/thread": "workspace:*",
+    "@ekairos/events": "workspace:*",
     "@ekairos/tsconfig": "workspace:*",
     "@types/node": "^24.5.0",
     "dotenv": "^17.2.2",