@lunora/testing 1.0.0-alpha.5 → 1.0.0-alpha.51

package/dist/packem_shared/agentHarness-GTPhWdQ8.mjs

@@ -0,0 +1,144 @@
+import { runAgentLoop, DEFAULT_AGENT_FUNCTION_PATHS } from '@lunora/agent';
+
+const scriptedGenerate = (script) => {
+  const remaining = [...script];
+  return () => {
+    const next = remaining.shift();
+    if (!next) {
+      throw new Error("agentHarness: scripted generate exhausted — the run took more turns than the script provided.");
+    }
+    return Promise.resolve(next);
+  };
+};
+class DurableStepJournal {
+  invoked = [];
+  entries = /* @__PURE__ */ new Map();
+  async do(name, callback) {
+    const existing = this.entries.get(name);
+    if (existing) {
+      return existing.output;
+    }
+    this.invoked.push(name);
+    const output = await callback();
+    this.entries.set(name, { output });
+    return output;
+  }
+  // eslint-disable-next-line class-methods-use-this -- mirrors AgentStepLike.waitForEvent's host signature so the mock stays assignable
+  async waitForEvent(_name, _options) {
+    return new Promise(() => {
+    });
+  }
+}
+const createRuntime = (extra) => {
+  const threads = /* @__PURE__ */ new Map();
+  const messages = /* @__PURE__ */ new Map();
+  const dispatches = [];
+  const ensureThread = (args) => {
+    const key = args?.["key"];
+    const instanceId = args?.["instanceId"];
+    const existing = threads.get(key);
+    if (existing) {
+      existing.status = "running";
+      delete existing.error;
+      if (instanceId !== void 0) {
+        existing.instanceId = instanceId;
+      }
+      return { created: false };
+    }
+    threads.set(key, {
+      agent: args?.["agent"],
+      instanceId,
+      key,
+      messageCount: 0,
+      owner: args?.["owner"],
+      status: "running",
+      title: args?.["title"]
+    });
+    return { created: true };
+  };
+  const appendMessage = (args) => {
+    const threadKey = args?.["threadKey"];
+    const messageKey = args?.["messageKey"];
+    const id = `${threadKey}:${messageKey}`;
+    const existing = messages.get(id);
+    if (existing) {
+      return { seq: existing.seq };
+    }
+    const thread = threads.get(threadKey);
+    if (!thread) {
+      throw new Error(`agentHarness: append to unknown thread "${threadKey}".`);
+    }
+    const seq = thread.messageCount;
+    thread.messageCount += 1;
+    messages.set(id, { ...args, seq });
+    return { seq };
+  };
+  const listMessages = (args) => {
+    const key = args?.["key"];
+    return [...messages.values()].filter((message) => message.threadKey === key).toSorted((a, b) => a.seq - b.seq);
+  };
+  const patchThread = (args) => {
+    const thread = threads.get(args?.["key"]);
+    if (thread) {
+      for (const [field, value] of Object.entries(args ?? {})) {
+        if (field !== "key" && value !== void 0) {
+          thread[field] = value;
+        }
+      }
+    }
+    return void 0;
+  };
+  const handlers = new Map([
+    [DEFAULT_AGENT_FUNCTION_PATHS.appendMessage, appendMessage],
+    [DEFAULT_AGENT_FUNCTION_PATHS.ensureThread, ensureThread],
+    [DEFAULT_AGENT_FUNCTION_PATHS.listMessages, listMessages],
+    [DEFAULT_AGENT_FUNCTION_PATHS.patchThread, patchThread],
+    ...Object.entries(extra)
+  ]);
+  const run = (reference, args) => {
+    const path = reference["__lunoraRef"];
+    dispatches.push({ args, path });
+    const handler = handlers.get(path);
+    if (!handler) {
+      throw new Error(`agentHarness: unstubbed dispatch "${path}" — pass a \`functions\` handler for it.`);
+    }
+    return Promise.resolve(handler(args));
+  };
+  return { dispatches, messages, run, threads };
+};
+const agentHarness = (agent, options) => {
+  const exportName = options.exportName ?? "agent";
+  const env = options.env ?? { LUNORA_TEST: true };
+  const runtime = createRuntime(options.functions ?? {});
+  let runCount = 0;
+  const run = (params, overrides) => {
+    runCount += 1;
+    const instanceId = overrides?.instanceId ?? `wf-${String(runCount)}`;
+    const script = overrides?.script ?? options.script;
+    return runAgentLoop({
+      agent,
+      env,
+      exportName,
+      generate: scriptedGenerate(script),
+      instanceId,
+      params,
+      paths: DEFAULT_AGENT_FUNCTION_PATHS,
+      run: runtime.run,
+      step: new DurableStepJournal()
+    });
+  };
+  return {
+    dispatches: runtime.dispatches,
+    messages: (threadKey) => [...runtime.messages.values()].filter((message) => message.threadKey === threadKey).toSorted((a, b) => a.seq - b.seq).map(({ messageKey: _messageKey, threadKey: _threadKey, ...row }) => row),
+    run,
+    thread: (threadKey) => runtime.threads.get(threadKey)
+  };
+};
+const finalTurn = (text, extra) => {
+  return { text, toolCalls: [], ...extra };
+};
+const toolCallTurn = (id, name, input, text = "") => {
+  return { text, toolCalls: [{ id, input, name }] };
+};
+
+export { agentHarness, finalTurn, toolCallTurn };

package/dist/packem_shared/containsScorer-DGwtvUNp.mjs

@@ -0,0 +1,94 @@
+import { LunoraError } from '@lunora/errors';
+
+const LEADING_SCORE = /^\s*(-?\d+(?:\.\d+)?)/u;
+const clamp01 = (value) => Number.isFinite(value) ? Math.min(1, Math.max(0, value)) : 0;
+const normalizeScore = (result) => {
+  if (typeof result === "number") {
+    return { score: clamp01(result) };
+  }
+  return { score: clamp01(result.score), ...result.reason === void 0 ? {} : { reason: result.reason } };
+};
+const mean = (values) => values.length === 0 ? 0 : values.reduce((sum, value) => sum + value, 0) / values.length;
+const containsScorer = (needle, options = {}) => {
+  return {
+    name: `contains:${needle}`,
+    score: ({ output }) => {
+      const haystack = options.caseSensitive ? output : output.toLowerCase();
+      const target = options.caseSensitive ? needle : needle.toLowerCase();
+      return haystack.includes(target) ? 1 : 0;
+    }
+  };
+};
+const regexScorer = (pattern, name = "regex") => {
+  return { name, score: ({ output }) => pattern.test(output) ? 1 : 0 };
+};
+const exactMatchScorer = () => {
+  return {
+    name: "exact-match",
+    score: ({ expected, output }) => output.trim() === expected?.trim() ? 1 : 0
+  };
+};
+const keywordScorer = (keywords) => {
+  if (keywords.length === 0) {
+    throw new LunoraError("BAD_REQUEST", "@lunora/testing: keywordScorer requires at least one keyword");
+  }
+  return {
+    name: "keyword-coverage",
+    score: ({ output }) => {
+      const lower = output.toLowerCase();
+      const hits = keywords.filter((keyword) => lower.includes(keyword.toLowerCase())).length;
+      return { reason: `${String(hits)}/${String(keywords.length)} keywords present`, score: hits / keywords.length };
+    }
+  };
+};
+const buildJudgePrompt = (criteria, sample) => [
+  `Rate the ASSISTANT OUTPUT against this criterion: ${criteria}`,
+  "Respond with a single number from 0 (fails) to 1 (fully meets), then a dash and a one-line reason.",
+  ...sample.input === void 0 ? [] : ["", `Input: ${sample.input}`],
+  ...sample.expected === void 0 ? [] : ["", `Reference answer: ${sample.expected}`],
+  "",
+  `Assistant output: ${sample.output}`
+].join("\n");
+const parseJudgeScore = (raw) => {
+  const match = LEADING_SCORE.exec(raw);
+  return { reason: raw.trim(), score: match ? clamp01(Number(match[1])) : 0 };
+};
+const llmScorer = (options) => {
+  return {
+    name: options.name ?? "llm-judge",
+    score: async (sample) => parseJudgeScore(await options.judge(buildJudgePrompt(options.criteria, sample)))
+  };
+};
+const scoreSample = async (sample, scorers) => {
+  const results = await Promise.all(
+    scorers.map(async (scorer) => {
+      return { name: scorer.name, result: normalizeScore(await scorer.score(sample)) };
+    })
+  );
+  const scores = {};
+  const seen = /* @__PURE__ */ new Map();
+  for (const { name, result } of results) {
+    const priorCount = seen.get(name) ?? 0;
+    seen.set(name, priorCount + 1);
+    scores[priorCount === 0 ? name : `${name}#${String(priorCount + 1)}`] = result;
+  }
+  return { average: mean(results.map(({ result }) => result.score)), scores };
+};
+const evaluate = async (cases, produce, scorers) => {
+  const items = await Promise.all(
+    cases.map(async (testCase) => {
+      const output = await produce(testCase.input);
+      const sample = {
+        input: testCase.input,
+        output,
+        ...testCase.expected === void 0 ? {} : { expected: testCase.expected },
+        ...testCase.metadata === void 0 ? {} : { metadata: testCase.metadata }
+      };
+      const { average, scores } = await scoreSample(sample, scorers);
+      return { average, input: testCase.input, output, scores };
+    })
+  );
+  return { average: mean(items.map((item) => item.average)), items };
+};
+
+export { containsScorer, evaluate, exactMatchScorer, keywordScorer, llmScorer, regexScorer, scoreSample };

package/dist/packem_shared/{lunoraTest-D8kUyDzR.mjs → lunoraTest-CHix6VWB.mjs}

@@ -1,8 +1,9 @@
 import { runShardMigrations, createShardCtxDb } from '@lunora/do';
+import { LunoraError } from '@lunora/errors';
 import { DatabaseSync } from 'node:sqlite';
 
-const createFakeScheduler = (getDispatch, getMutationContext, getFunctionRegistry) => {
-  let nowMs = Date.now();
+const createFakeScheduler = (getDispatch, getMutationContext, getActionContext, getFunctionRegistry, now) => {
+  let nowMs = now;
   let nextId = 1;
   const pending = /* @__PURE__ */ new Map();
   const recordedFailures = [];
@@ -18,6 +19,7 @@ const createFakeScheduler = (getDispatch, getMutationContext, getFunctionRegistr
     });
     return id;
   };
+  const targetPath = (target) => typeof target === "string" ? target : target.name ?? target.binding ?? "";
   const scheduler = {
     cancel: (id) => {
       const existed = pending.has(id);
@@ -27,12 +29,12 @@ const createFakeScheduler = (getDispatch, getMutationContext, getFunctionRegistr
     // eslint-disable-next-line unicorn/no-null -- Scheduler.get returns null when absent (public API contract)
     get: (id) => Promise.resolve(pending.get(id) ?? null),
     list: () => Promise.resolve([...pending.values()]),
-    runAfter: (delayMs, functionPath, args) => {
-      const id = enqueue(nowMs + delayMs, functionPath, args);
+    runAfter: (delayMs, target, args) => {
+      const id = enqueue(nowMs + delayMs, targetPath(target), args);
       return Promise.resolve(id);
     },
-    runAt: (timestampMs, functionPath, args) => {
-      const id = enqueue(timestampMs, functionPath, args);
+    runAt: (timestampMs, target, args) => {
+      const id = enqueue(timestampMs, targetPath(target), args);
       return Promise.resolve(id);
     }
   };
@@ -46,8 +48,8 @@ const createFakeScheduler = (getDispatch, getMutationContext, getFunctionRegistr
     }
     if (entry.kind === "mutation" || entry.kind === "action") {
       const dispatch = getDispatch();
-      const mutationContext = getMutationContext();
-      await dispatch(entry.kind, entry, mutationContext, job.args);
+      const context = entry.kind === "action" ? getActionContext() : getMutationContext();
+      await dispatch(entry.kind, entry, context, job.args);
     } else {
       console.warn(
         `[fake-scheduler] functionPath "${job.functionPath}" is a ${entry.kind} — only mutations and actions can be scheduled; job ${job.id} dropped`
@@ -57,7 +59,12 @@ const createFakeScheduler = (getDispatch, getMutationContext, getFunctionRegistr
   const executeDue = async (cutoff) => {
     const due = [...pending.values()].filter((j) => j.scheduledFor <= cutoff).toSorted((a, b) => a.scheduledFor - b.scheduledFor);
     const failed = [];
+    let executed = 0;
     for (const job of due) {
+      if (!pending.has(job.id)) {
+        continue;
+      }
+      executed += 1;
       try {
         await dispatchJob(job);
       } catch (error) {
@@ -66,7 +73,7 @@ const createFakeScheduler = (getDispatch, getMutationContext, getFunctionRegistr
         recordedFailures.push(failure);
       }
     }
-    return { executed: due.length, failed };
+    return { executed, failed };
   };
   const runSweep = async (cutoff, options) => {
     const { executed, failed } = await executeDue(cutoff);
@@ -100,7 +107,7 @@ const createSqlExec = () => {
     return {
       one() {
         if (rows.length !== 1) {
-          throw new Error(`expected exactly one row, received ${String(rows.length)}`);
+          throw new LunoraError("INTERNAL", `expected exactly one row, received ${String(rows.length)}`);
         }
         const [only] = rows;
         return only;
@@ -138,24 +145,34 @@ const registeredFunctionKind = (value) => {
 };
 const registeredFunctionVisibility = (value) => typeof value === "object" && value !== null && value.visibility === "internal" ? "internal" : "public";
 const unavailable = (surface) => {
-  throw new Error(`ctx.${surface} is not available in the in-memory @lunora/testing harness (v1)`);
+  throw new LunoraError("INTERNAL", `ctx.${surface} is not available in the in-memory @lunora/testing harness (v1)`);
 };
 const stubProxy = (surface) => /* @__PURE__ */ new Proxy((..._args) => unavailable(surface), {
   apply: () => unavailable(surface),
   get: () => unavailable(surface)
 });
+const passthroughTrace = async (_name, function_) => await function_(passthroughTrace);
+const noopMetrics = {
+  count: () => void 0,
+  gauge: () => void 0,
+  record: () => void 0
+};
 const noopLog = {
   debug: () => void 0,
   error: () => void 0,
+  fatal: () => void 0,
   info: () => void 0,
   log: () => void 0,
-  warn: () => void 0
+  trace: () => void 0,
+  warn: () => void 0,
+  with: () => noopLog
 };
 const buildSubscribe = (runRegistered, queryContext, mutationListeners) => {
   const factory = (referenceOrInline, args) => {
     let done = false;
-    let pendingResolve;
+    const pendingWaiters = [];
     let pendingResult;
+    let pendingError;
     let latestSeq = 0;
     let appliedSeq = 0;
     const runQuery = () => {
@@ -170,25 +187,46 @@ const buildSubscribe = (runRegistered, queryContext, mutationListeners) => {
       }
       appliedSeq = seq;
       const iterResult = { done: false, value };
-      if (pendingResolve === void 0) {
+      if (pendingWaiters.length === 0) {
         pendingResult = iterResult;
+        pendingError = void 0;
       } else {
-        const resolve = pendingResolve;
-        pendingResolve = void 0;
         pendingResult = void 0;
-        resolve(iterResult);
+        pendingError = void 0;
+        for (const waiter of pendingWaiters.splice(0)) {
+          waiter.resolve(iterResult);
+        }
+      }
+    };
+    const emitError = (seq, error) => {
+      if (seq < appliedSeq) {
+        return;
+      }
+      appliedSeq = seq;
+      if (pendingWaiters.length === 0) {
+        pendingError = { error };
+        pendingResult = void 0;
+      } else {
+        pendingResult = void 0;
+        pendingError = void 0;
+        for (const waiter of pendingWaiters.splice(0)) {
+          waiter.reject(error);
+        }
       }
     };
     const emitAt = (seq) => (value) => {
       emit(seq, value);
     };
+    const emitErrorAt = (seq) => (error) => {
+      emitError(seq, error);
+    };
     const listener = () => {
       if (done) {
         return;
       }
       latestSeq += 1;
       const seq = latestSeq;
-      runQuery().then(emitAt(seq)).catch(() => void 0);
+      runQuery().then(emitAt(seq)).catch(emitErrorAt(seq));
     };
     mutationListeners.add(listener);
     const iterator = {
@@ -199,17 +237,29 @@ const buildSubscribe = (runRegistered, queryContext, mutationListeners) => {
         if (done) {
           return Promise.resolve({ done: true, value: void 0 });
         }
-        if (pendingResult !== void 0 && appliedSeq === latestSeq) {
-          const result = pendingResult;
-          pendingResult = void 0;
-          return Promise.resolve(result);
+        if (appliedSeq === latestSeq) {
+          if (pendingError !== void 0) {
+            const { error } = pendingError;
+            pendingError = void 0;
+            return Promise.reject(error);
+          }
+          if (pendingResult !== void 0) {
+            const result = pendingResult;
+            pendingResult = void 0;
+            return Promise.resolve(result);
+          }
         }
         if (appliedSeq < latestSeq) {
-          return new Promise((resolve) => {
-            pendingResolve = resolve;
+          return new Promise((resolve, reject) => {
+            pendingWaiters.push({ reject, resolve });
           });
         }
         return runQuery().then((value) => {
+          if (pendingError !== void 0) {
+            const { error } = pendingError;
+            pendingError = void 0;
+            throw error;
+          }
           if (pendingResult !== void 0) {
             const result = pendingResult;
             pendingResult = void 0;
@@ -221,15 +271,13 @@ const buildSubscribe = (runRegistered, queryContext, mutationListeners) => {
       return: () => {
         done = true;
         mutationListeners.delete(listener);
-        if (pendingResolve !== void 0) {
-          const resolve = pendingResolve;
-          pendingResolve = void 0;
-          resolve({ done: true, value: void 0 });
+        for (const waiter of pendingWaiters.splice(0)) {
+          waiter.resolve({ done: true, value: void 0 });
         }
         return Promise.resolve({ done: true, value: void 0 });
       }
     };
-    runQuery().then(emitAt(0)).catch(() => void 0);
+    runQuery().then(emitAt(0)).catch(emitErrorAt(0));
     return iterator;
   };
   return factory;
@@ -243,26 +291,28 @@ const lunoraTest = (schema, options) => {
     const runner = sql.exec;
     runner.call(sql, statement);
   };
-  let transactionDepth = 0;
-  const runInMutationTransaction = async (function_) => {
-    if (transactionDepth > 0) {
-      return function_();
-    }
-    transactionDepth = 1;
-    execStatement("BEGIN");
-    try {
-      const result = await function_();
-      execStatement("COMMIT");
-      return result;
-    } catch (error) {
+  let mutationQueue = Promise.resolve();
+  const runInMutationTransaction = (function_) => {
+    const runTransaction = async () => {
+      execStatement("BEGIN");
       try {
-        execStatement("ROLLBACK");
-      } catch {
+        const result2 = await function_();
+        execStatement("COMMIT");
+        return result2;
+      } catch (error) {
+        try {
+          execStatement("ROLLBACK");
+        } catch {
+        }
+        throw error;
       }
-      throw error;
-    } finally {
-      transactionDepth = 0;
-    }
+    };
+    const result = mutationQueue.then(runTransaction);
+    mutationQueue = result.then(
+      () => void 0,
+      () => void 0
+    );
+    return result;
   };
   let closed = false;
   const closeDatabase = () => {
@@ -283,22 +333,39 @@ const lunoraTest = (schema, options) => {
   };
   let scheduledDispatchRef;
   let mutationContextRef;
+  let actionContextRef;
+  const harnessNow = options?.now ?? Date.now();
   const { controls: schedulerControls, scheduler: fakeScheduler } = createFakeScheduler(
     () => {
       if (scheduledDispatchRef === void 0) {
-        throw new Error("[fake-scheduler] dispatch not yet available — scheduler.advance called before harness construction completed");
+        throw new LunoraError(
+          "INTERNAL",
+          "[fake-scheduler] dispatch not yet available — scheduler.advance called before harness construction completed"
+        );
       }
       return scheduledDispatchRef;
     },
     () => {
       if (mutationContextRef === void 0) {
-        throw new Error("[fake-scheduler] mutationContext not yet available — scheduler.advance called before harness construction completed");
+        throw new LunoraError(
+          "INTERNAL",
+          "[fake-scheduler] mutationContext not yet available — scheduler.advance called before harness construction completed"
+        );
       }
       return mutationContextRef;
     },
-    () => functionRegistryMap
+    () => {
+      if (actionContextRef === void 0) {
+        throw new LunoraError(
+          "INTERNAL",
+          "[fake-scheduler] actionContext not yet available — scheduler.advance called before harness construction completed"
+        );
+      }
+      return actionContextRef;
+    },
+    () => functionRegistryMap,
+    harnessNow
   );
-  const harnessNow = options?.now ?? Date.now();
   const makeHarness = (identity) => {
     const auth = {
       // eslint-disable-next-line unicorn/no-null -- AuthState.getIdentity's anonymous sentinel is `null` (mirrors a decoded JWT being absent)
@@ -309,23 +376,31 @@ const lunoraTest = (schema, options) => {
     const queryContext = {
       auth,
       db: database,
+      env: options?.env,
       log: noopLog,
+      metrics: noopMetrics,
       now: harnessNow,
+      trace: passthroughTrace,
       // eslint-disable-next-line @typescript-eslint/no-use-before-define -- lazy closure: `runInternal` is invoked only when a handler calls ctx.runQuery, after construction completes
       runQuery: (reference, args) => runInternal("query", reference, queryContext, args),
+      secrets: stubProxy("secrets"),
       storage: stubProxy("storage"),
       vectors: stubProxy("vectors")
     };
     const mutationContext = {
       auth,
       db: database,
+      env: options?.env,
       log: noopLog,
+      metrics: noopMetrics,
       now: harnessNow,
+      trace: passthroughTrace,
       // eslint-disable-next-line @typescript-eslint/no-use-before-define -- lazy closure: `runInternal` is invoked only when a handler calls ctx.runMutation, after construction completes
       runMutation: (reference, args) => runInternal("mutation", reference, mutationContext, args),
       // eslint-disable-next-line @typescript-eslint/no-use-before-define -- lazy closure: `runInternal` is invoked only when a handler calls ctx.runQuery, after construction completes
       runQuery: (reference, args) => runInternal("query", reference, queryContext, args),
       scheduler: fakeScheduler,
+      secrets: stubProxy("secrets"),
       storage: stubProxy("storage"),
       vectors: stubProxy("vectors"),
       workflows: stubProxy("workflows")
@@ -334,10 +409,13 @@ const lunoraTest = (schema, options) => {
     const actionContext = {
       auth,
       db: database,
+      env: options?.env,
       // Use the injected fetch when provided; fall back to the v1 stub otherwise.
       fetch: options?.fetch ?? stubProxy("fetch"),
       log: noopLog,
+      metrics: noopMetrics,
       now: harnessNow,
+      trace: passthroughTrace,
       // eslint-disable-next-line @typescript-eslint/no-use-before-define -- lazy closure: `runInternal` is invoked only when a handler calls ctx.runAction, after construction completes
       runAction: (reference, args) => runInternal("action", reference, actionContext, args),
       // eslint-disable-next-line @typescript-eslint/no-use-before-define -- lazy closure: `runInternal` is invoked only when a handler calls ctx.runMutation, after construction completes
@@ -345,18 +423,21 @@ const lunoraTest = (schema, options) => {
       // eslint-disable-next-line @typescript-eslint/no-use-before-define -- lazy closure: `runInternal` is invoked only when a handler calls ctx.runQuery, after construction completes
       runQuery: (reference, args) => runInternal("query", reference, queryContext, args),
       scheduler: fakeScheduler,
+      secrets: stubProxy("secrets"),
       storage: stubProxy("storage"),
       vectors: stubProxy("vectors"),
       workflows: stubProxy("workflows")
     };
+    actionContextRef ??= actionContext;
     const runRegistered = (expected, reference, context, args, allowInternal) => {
       const kind = registeredFunctionKind(reference);
       if (kind !== expected) {
-        throw new Error(`expected a registered ${expected}, received a ${kind ?? "non-function"} reference`);
+        throw new LunoraError("INTERNAL", `expected a registered ${expected}, received a ${kind ?? "non-function"} reference`);
       }
       if (!allowInternal && registeredFunctionVisibility(reference) === "internal") {
-        throw new Error(
-          `"${expected}" is an internal function — it is unreachable from the external RPC boundary in production. Call it through ctx.run${expected.charAt(0).toUpperCase()}${expected.slice(1)} from another function instead.`
+        throw new LunoraError(
+          "INTERNAL",
+          `This ${expected} is an internal function — it is unreachable from the external RPC boundary in production. Call it through ctx.run${expected.charAt(0).toUpperCase()}${expected.slice(1)} from another function instead.`
         );
       }
       return Promise.resolve(reference.handler(context, args ?? {}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lunora/testing",
-  "version": "1.0.0-alpha.5",
+  "version": "1.0.0-alpha.51",
   "description": "Testing toolkit for Lunora: an in-memory harness for queries, mutations, and actions",
   "keywords": [
     "cloudflare",
@@ -25,7 +25,7 @@
     "directory": "packages/testing"
   },
   "files": [
-    "dist",
+    "./dist",
     "README.md",
     "LICENSE.md",
     "__assets__"
@@ -46,9 +46,11 @@
     "access": "public"
   },
   "dependencies": {
-    "@lunora/do": "1.0.0-alpha.4",
-    "@lunora/mail": "1.0.0-alpha.1",
-    "@lunora/server": "1.0.0-alpha.2"
+    "@lunora/agent": "1.0.0-alpha.8",
+    "@lunora/do": "1.0.0-alpha.37",
+    "@lunora/errors": "1.0.0-alpha.6",
+    "@lunora/mail": "1.0.0-alpha.16",
+    "@lunora/server": "1.0.0-alpha.29"
   },
   "engines": {
     "node": "^22.15.0 || >=24.11.0"