@sentry/junior 0.71.3 → 0.72.0

package/dist/cli/run.js

@@ -1,7 +1,7 @@
 import "../chunk-2KG3PWR4.js";
 
 // src/cli/run.ts
-var CLI_USAGE = "usage: junior init <dir>\n       junior snapshot create\n       junior check [dir]";
+var CLI_USAGE = "usage: junior init <dir>\n       junior snapshot create\n       junior check [dir]\n       junior upgrade";
 var DEFAULT_IO = {
   error: console.error
 };
@@ -31,6 +31,14 @@ async function runCli(argv, handlers, io = DEFAULT_IO) {
     await handlers.runCheck(subcommand);
     return 0;
   }
+  if (command === "upgrade") {
+    if (subcommand || rest.length > 0) {
+      io.error(CLI_USAGE);
+      return 1;
+    }
+    await handlers.runUpgrade();
+    return 0;
+  }
   io.error(CLI_USAGE);
   return 1;
 }

package/dist/cli/snapshot-warmup.js

@@ -1,16 +1,19 @@
 import {
   resolveRuntimeDependencySnapshot
-} from "../chunk-B5HKWWQB.js";
-import {
-  disconnectStateAdapter
-} from "../chunk-R62YWUNO.js";
+} from "../chunk-VLIO6RQR.js";
+import "../chunk-G3E7SCME.js";
 import {
   getPluginProviders,
   getPluginRuntimeDependencies,
   getPluginRuntimePostinstall
-} from "../chunk-UXG6TU2U.js";
-import "../chunk-JS4HURDT.js";
-import "../chunk-BBXYXOJW.js";
+} from "../chunk-GB3AL54K.js";
+import "../chunk-KVZL5NZS.js";
+import {
+  disconnectStateAdapter
+} from "../chunk-3FYPXHPL.js";
+import "../chunk-ZJQPA67D.js";
+import "../chunk-PP7AGSBU.js";
+import "../chunk-6GEYPE6T.js";
 import "../chunk-Z3YD6NHK.js";
 import "../chunk-2KG3PWR4.js";
 

package/dist/cli/upgrade.js

@@ -0,0 +1,599 @@
+import {
+  coerceThreadConversationState
+} from "../chunk-4JXCSGSA.js";
+import {
+  JUNIOR_THREAD_STATE_TTL_MS,
+  getConversation,
+  requestConversationWork
+} from "../chunk-HNMUVGSR.js";
+import {
+  parseDestination,
+  sameDestination
+} from "../chunk-XC33FJZN.js";
+import {
+  disconnectStateAdapter,
+  getConnectedStateContext
+} from "../chunk-3FYPXHPL.js";
+import {
+  getChatConfig
+} from "../chunk-ZJQPA67D.js";
+import "../chunk-PP7AGSBU.js";
+import {
+  isRecord,
+  toOptionalNumber,
+  toOptionalString
+} from "../chunk-6GEYPE6T.js";
+import "../chunk-Z3YD6NHK.js";
+import "../chunk-2KG3PWR4.js";
+
+// src/cli/upgrade/migrations/redis-conversation-state.ts
+var CONVERSATION_PREFIX = "junior:conversation";
+var CONVERSATION_SCHEMA_VERSION = 1;
+var CONVERSATION_ACTIVITY_INDEX_MAX_LENGTH = 1e4;
+var CONVERSATION_BY_ACTIVITY_INDEX_KEY = `${CONVERSATION_PREFIX}:by-activity`;
+var CONVERSATION_ACTIVE_INDEX_KEY = `${CONVERSATION_PREFIX}:active`;
+var LEGACY_CONVERSATION_WORK_PREFIX = "junior:conversation-work";
+var LEGACY_CONVERSATION_WORK_SCHEMA_VERSION = 1;
+var LEGACY_CONVERSATION_WORK_INDEX_KEY = `${LEGACY_CONVERSATION_WORK_PREFIX}:index`;
+var AGENT_TURN_SESSION_PREFIX = "junior:agent_turn_session";
+var AGENT_TURN_SESSION_INDEX_KEY = `${AGENT_TURN_SESSION_PREFIX}:index`;
+var THREAD_STATE_PREFIX = "thread-state";
+function conversationKey(conversationId) {
+  return `${CONVERSATION_PREFIX}:${conversationId}`;
+}
+function legacyConversationWorkKey(conversationId) {
+  return `${LEGACY_CONVERSATION_WORK_PREFIX}:state:${conversationId}`;
+}
+function threadStateKey(conversationId) {
+  return `${THREAD_STATE_PREFIX}:${conversationId}`;
+}
+function uniqueStrings(values) {
+  return [...new Set(values)];
+}
+function uniqueStringValues(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return uniqueStrings(
+    value.map((value2) => typeof value2 === "string" ? value2 : void 0).filter((value2) => Boolean(value2))
+  );
+}
+function normalizeSource(value) {
+  if (value === "api" || value === "internal" || value === "plugin" || value === "scheduler" || value === "slack") {
+    return value;
+  }
+  return void 0;
+}
+function normalizeMetadata(value) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  return value;
+}
+function normalizeInput(value) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  const text = toOptionalString(value.text);
+  if (!text) {
+    return void 0;
+  }
+  return {
+    text,
+    authorId: toOptionalString(value.authorId),
+    attachments: Array.isArray(value.attachments) ? [...value.attachments] : void 0,
+    metadata: normalizeMetadata(value.metadata)
+  };
+}
+function normalizeMessage(value) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  const conversationId = toOptionalString(value.conversationId);
+  const inboundMessageId = toOptionalString(value.inboundMessageId);
+  const source = normalizeSource(value.source);
+  const destination = parseDestination(value.destination);
+  const createdAtMs = toOptionalNumber(value.createdAtMs);
+  const receivedAtMs = toOptionalNumber(value.receivedAtMs);
+  const input = normalizeInput(value.input);
+  if (!conversationId || !destination || !inboundMessageId || !source || typeof createdAtMs !== "number" || typeof receivedAtMs !== "number" || !input) {
+    return void 0;
+  }
+  return {
+    conversationId,
+    destination,
+    inboundMessageId,
+    source,
+    createdAtMs,
+    receivedAtMs,
+    input,
+    injectedAtMs: toOptionalNumber(value.injectedAtMs)
+  };
+}
+function normalizeLegacyLease(value) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  const token = toOptionalString(value.leaseToken);
+  const acquiredAtMs = toOptionalNumber(value.acquiredAtMs);
+  const lastCheckInAtMs = toOptionalNumber(value.lastCheckInAtMs);
+  const expiresAtMs = toOptionalNumber(value.leaseExpiresAtMs);
+  if (!token || typeof acquiredAtMs !== "number" || typeof lastCheckInAtMs !== "number" || typeof expiresAtMs !== "number") {
+    return void 0;
+  }
+  return {
+    token,
+    acquiredAtMs,
+    lastCheckInAtMs,
+    expiresAtMs
+  };
+}
+function compareMessages(left, right) {
+  return left.createdAtMs - right.createdAtMs || left.receivedAtMs - right.receivedAtMs || left.inboundMessageId.localeCompare(right.inboundMessageId);
+}
+function normalizeLegacyConversation(conversationId, value) {
+  if (!isRecord(value) || value.schemaVersion !== LEGACY_CONVERSATION_WORK_SCHEMA_VERSION) {
+    return void 0;
+  }
+  const storedConversationId = toOptionalString(value.conversationId);
+  const destination = parseDestination(value.destination);
+  const updatedAtMs = toOptionalNumber(value.updatedAtMs);
+  if (storedConversationId !== conversationId || !destination || typeof updatedAtMs !== "number") {
+    return void 0;
+  }
+  const normalizedMessages = Array.isArray(value.messages) ? value.messages.map(normalizeMessage).filter((message) => Boolean(message)) : [];
+  if (normalizedMessages.some(
+    (message) => message.conversationId === conversationId && !sameDestination(message.destination, destination)
+  )) {
+    return void 0;
+  }
+  const messages = normalizedMessages.filter((message) => message.conversationId === conversationId).sort(compareMessages);
+  const pendingMessages = messages.filter(
+    (message) => message.injectedAtMs === void 0
+  );
+  const lease = normalizeLegacyLease(value.lease);
+  const needsRun = value.needsRun === true || pendingMessages.length > 0;
+  const status = lease ? value.needsRun === true ? "awaiting_resume" : "running" : needsRun ? "pending" : "idle";
+  const messageTimes = messages.flatMap((message) => [
+    message.createdAtMs,
+    message.receivedAtMs
+  ]);
+  const createdAtMs = messageTimes.length > 0 ? Math.min(...messageTimes) : updatedAtMs;
+  const lastActivityAtMs = messageTimes.length > 0 ? Math.max(...messageTimes) : updatedAtMs;
+  return {
+    schemaVersion: CONVERSATION_SCHEMA_VERSION,
+    conversationId,
+    createdAtMs,
+    destination,
+    lastActivityAtMs,
+    source: messages[0]?.source,
+    updatedAtMs,
+    execution: {
+      status,
+      inboundMessageIds: uniqueStrings(
+        messages.map((message) => message.inboundMessageId)
+      ),
+      pendingCount: pendingMessages.length,
+      pendingMessages,
+      ...lease ? { lease } : {},
+      lastEnqueuedAtMs: toOptionalNumber(value.lastEnqueuedAtMs),
+      updatedAtMs
+    }
+  };
+}
+function mergeLegacyConversation(existing, legacy) {
+  if (existing.destination && legacy.destination && !sameDestination(existing.destination, legacy.destination)) {
+    throw new Error(
+      `Legacy conversation work destination does not match conversation ${existing.conversationId}`
+    );
+  }
+  const knownInboundIds = new Set(existing.execution.inboundMessageIds);
+  const pendingMessages = [
+    ...existing.execution.pendingMessages,
+    ...legacy.execution.pendingMessages.filter(
+      (message) => !knownInboundIds.has(message.inboundMessageId)
+    )
+  ].sort(compareMessages);
+  const legacyIsRunnable = legacy.execution.status !== "idle";
+  const existingIsIdle = existing.execution.status === "idle";
+  const legacyLease = existingIsIdle && legacy.execution.lease ? { lease: legacy.execution.lease } : {};
+  const legacyRunId = existingIsIdle && legacy.execution.runId ? { runId: legacy.execution.runId } : {};
+  const legacyCheckpoint = existing.execution.lastCheckpointAtMs === void 0 && legacy.execution.lastCheckpointAtMs !== void 0 ? { lastCheckpointAtMs: legacy.execution.lastCheckpointAtMs } : {};
+  const legacyEnqueue = existing.execution.lastEnqueuedAtMs === void 0 && legacy.execution.lastEnqueuedAtMs !== void 0 ? { lastEnqueuedAtMs: legacy.execution.lastEnqueuedAtMs } : {};
+  const executionUpdatedAtMs = Math.max(
+    existing.execution.updatedAtMs ?? existing.updatedAtMs,
+    legacy.execution.updatedAtMs ?? legacy.updatedAtMs
+  );
+  const status = existingIsIdle && legacyIsRunnable ? legacy.execution.lease ? legacy.execution.status : "pending" : pendingMessages.length > 0 && existingIsIdle ? "pending" : existing.execution.status;
+  return {
+    ...existing,
+    destination: existing.destination ?? legacy.destination,
+    source: existing.source ?? legacy.source,
+    createdAtMs: Math.min(existing.createdAtMs, legacy.createdAtMs),
+    lastActivityAtMs: Math.max(
+      existing.lastActivityAtMs,
+      legacy.lastActivityAtMs
+    ),
+    updatedAtMs: Math.max(existing.updatedAtMs, legacy.updatedAtMs),
+    execution: {
+      ...existing.execution,
+      ...legacyLease,
+      ...legacyRunId,
+      ...legacyCheckpoint,
+      ...legacyEnqueue,
+      status,
+      inboundMessageIds: uniqueStrings([
+        ...existing.execution.inboundMessageIds,
+        ...legacy.execution.inboundMessageIds
+      ]),
+      pendingCount: pendingMessages.length,
+      pendingMessages,
+      updatedAtMs: executionUpdatedAtMs
+    }
+  };
+}
+function compareIndexDescending(left, right) {
+  return right.score - left.score || right.conversationId.localeCompare(left.conversationId);
+}
+function compareIndexAscending(left, right) {
+  return left.score - right.score || left.conversationId.localeCompare(right.conversationId);
+}
+function normalizeIndexEntry(value) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  const conversationId = toOptionalString(value.conversationId);
+  const score = toOptionalNumber(value.score);
+  if (!conversationId || typeof score !== "number") {
+    return void 0;
+  }
+  return { conversationId, score };
+}
+function uniqueIndexEntries(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  const entries = /* @__PURE__ */ new Map();
+  for (const item of value) {
+    const entry = normalizeIndexEntry(item);
+    if (!entry) {
+      continue;
+    }
+    const existing = entries.get(entry.conversationId);
+    if (!existing || entry.score > existing.score) {
+      entries.set(entry.conversationId, entry);
+    }
+  }
+  return [...entries.values()];
+}
+function normalizeAwaitingContinuationSummary(value) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  const conversationId = toOptionalString(value.conversationId);
+  const sessionId = toOptionalString(value.sessionId);
+  const state = value.state;
+  const resumeReason = value.resumeReason;
+  const destination = parseDestination(value.destination);
+  const updatedAtMs = toOptionalNumber(value.updatedAtMs);
+  if (!conversationId || !sessionId || state !== "awaiting_resume" || resumeReason !== "timeout" && resumeReason !== "yield" || !destination || typeof updatedAtMs !== "number") {
+    return void 0;
+  }
+  return {
+    conversationId,
+    destination,
+    resumeReason,
+    sessionId,
+    state,
+    updatedAtMs
+  };
+}
+function uniqueAwaitingContinuationSummaries(values) {
+  const summaries = /* @__PURE__ */ new Map();
+  for (const value of [...values].reverse()) {
+    const summary = normalizeAwaitingContinuationSummary(value);
+    if (!summary) {
+      continue;
+    }
+    const key = `${summary.conversationId}:${summary.sessionId}`;
+    if (!summaries.has(key)) {
+      summaries.set(key, summary);
+    }
+  }
+  return [...summaries.values()];
+}
+function redisIndexKey(indexKey) {
+  const prefix = getChatConfig().state.keyPrefix;
+  return [...prefix ? [prefix] : [], indexKey].join(":");
+}
+async function upsertEmulatedIndexEntry(args) {
+  const existing = uniqueIndexEntries(
+    await args.stateAdapter.get(args.indexKey)
+  );
+  const next = [
+    ...existing.filter((entry) => entry.conversationId !== args.conversationId),
+    { conversationId: args.conversationId, score: args.score }
+  ];
+  const retained = args.indexKey === CONVERSATION_BY_ACTIVITY_INDEX_KEY ? next.sort(compareIndexDescending).slice(0, CONVERSATION_ACTIVITY_INDEX_MAX_LENGTH) : next.sort(compareIndexAscending);
+  await args.stateAdapter.set(
+    args.indexKey,
+    retained,
+    JUNIOR_THREAD_STATE_TTL_MS
+  );
+}
+async function removeEmulatedIndexEntry(args) {
+  const existing = uniqueIndexEntries(
+    await args.stateAdapter.get(args.indexKey)
+  );
+  const next = existing.filter(
+    (entry) => entry.conversationId !== args.conversationId
+  );
+  if (next.length === existing.length) {
+    return;
+  }
+  await args.stateAdapter.set(args.indexKey, next, JUNIOR_THREAD_STATE_TTL_MS);
+}
+async function upsertRedisIndexEntry(args) {
+  const key = redisIndexKey(args.indexKey);
+  if (args.indexKey === CONVERSATION_BY_ACTIVITY_INDEX_KEY) {
+    const upsertBoundedActivityScript = `
+      redis.call("ZADD", KEYS[1], ARGV[1], ARGV[2])
+      redis.call("PEXPIRE", KEYS[1], ARGV[3])
+      local extra = redis.call("ZCARD", KEYS[1]) - tonumber(ARGV[4])
+      if extra > 0 then
+        redis.call("ZREMRANGEBYRANK", KEYS[1], 0, extra - 1)
+      end
+      return 1
+    `;
+    await args.client.sendCommand([
+      "EVAL",
+      upsertBoundedActivityScript,
+      "1",
+      key,
+      String(args.score),
+      args.conversationId,
+      String(JUNIOR_THREAD_STATE_TTL_MS),
+      String(CONVERSATION_ACTIVITY_INDEX_MAX_LENGTH)
+    ]);
+    return;
+  }
+  await args.client.sendCommand([
+    "ZADD",
+    key,
+    String(args.score),
+    args.conversationId
+  ]);
+  await args.client.sendCommand([
+    "PEXPIRE",
+    key,
+    String(JUNIOR_THREAD_STATE_TTL_MS)
+  ]);
+}
+async function removeRedisIndexEntry(args) {
+  await args.client.sendCommand([
+    "ZREM",
+    redisIndexKey(args.indexKey),
+    args.conversationId
+  ]);
+}
+async function upsertConversationIndexes(args) {
+  const redisClient = args.redisStateAdapter?.getClient();
+  const upsert = redisClient ? (indexKey, score) => upsertRedisIndexEntry({
+    client: redisClient,
+    conversationId: args.conversation.conversationId,
+    indexKey,
+    score
+  }) : (indexKey, score) => upsertEmulatedIndexEntry({
+    stateAdapter: args.stateAdapter,
+    conversationId: args.conversation.conversationId,
+    indexKey,
+    score
+  });
+  const remove = redisClient ? (indexKey) => removeRedisIndexEntry({
+    client: redisClient,
+    conversationId: args.conversation.conversationId,
+    indexKey
+  }) : (indexKey) => removeEmulatedIndexEntry({
+    stateAdapter: args.stateAdapter,
+    conversationId: args.conversation.conversationId,
+    indexKey
+  });
+  await upsert(
+    CONVERSATION_BY_ACTIVITY_INDEX_KEY,
+    args.conversation.lastActivityAtMs
+  );
+  if (args.conversation.execution.status === "idle") {
+    await remove(CONVERSATION_ACTIVE_INDEX_KEY);
+    return;
+  }
+  await upsert(
+    CONVERSATION_ACTIVE_INDEX_KEY,
+    args.conversation.execution.updatedAtMs ?? args.conversation.updatedAtMs
+  );
+}
+async function removeLegacyIndexEntry(args) {
+  const existing = uniqueStringValues(
+    await args.stateAdapter.get(LEGACY_CONVERSATION_WORK_INDEX_KEY)
+  );
+  const next = existing.filter((id) => id !== args.conversationId);
+  if (next.length === existing.length) {
+    return;
+  }
+  if (next.length === 0) {
+    await args.stateAdapter.delete(LEGACY_CONVERSATION_WORK_INDEX_KEY);
+    return;
+  }
+  await args.stateAdapter.set(
+    LEGACY_CONVERSATION_WORK_INDEX_KEY,
+    next,
+    JUNIOR_THREAD_STATE_TTL_MS
+  );
+}
+async function migrateLegacyConversationWorkRedisState(context) {
+  const legacyIds = uniqueStringValues(
+    await context.stateAdapter.get(LEGACY_CONVERSATION_WORK_INDEX_KEY)
+  );
+  const result = {
+    existing: 0,
+    migrated: 0,
+    missing: 0,
+    scanned: legacyIds.length
+  };
+  for (const conversationId of legacyIds) {
+    const legacyKey = legacyConversationWorkKey(conversationId);
+    const raw = await context.stateAdapter.get(legacyKey);
+    if (raw == null) {
+      result.missing += 1;
+      await removeLegacyIndexEntry({
+        conversationId,
+        stateAdapter: context.stateAdapter
+      });
+      continue;
+    }
+    const conversation = normalizeLegacyConversation(conversationId, raw);
+    if (!conversation) {
+      throw new Error(
+        `Legacy conversation work state is invalid for ${conversationId}`
+      );
+    }
+    const existingConversation = await getConversation({
+      conversationId,
+      state: context.stateAdapter
+    });
+    if (existingConversation) {
+      const mergedConversation = mergeLegacyConversation(
+        existingConversation,
+        conversation
+      );
+      await context.stateAdapter.set(
+        conversationKey(conversationId),
+        mergedConversation,
+        JUNIOR_THREAD_STATE_TTL_MS
+      );
+      await upsertConversationIndexes({
+        conversation: mergedConversation,
+        redisStateAdapter: context.redisStateAdapter,
+        stateAdapter: context.stateAdapter
+      });
+      result.existing += 1;
+      await context.stateAdapter.delete(legacyKey);
+      await removeLegacyIndexEntry({
+        conversationId,
+        stateAdapter: context.stateAdapter
+      });
+      continue;
+    }
+    await context.stateAdapter.set(
+      conversationKey(conversationId),
+      conversation,
+      JUNIOR_THREAD_STATE_TTL_MS
+    );
+    await upsertConversationIndexes({
+      conversation,
+      redisStateAdapter: context.redisStateAdapter,
+      stateAdapter: context.stateAdapter
+    });
+    await context.stateAdapter.delete(legacyKey);
+    await removeLegacyIndexEntry({
+      conversationId,
+      stateAdapter: context.stateAdapter
+    });
+    result.migrated += 1;
+  }
+  return result;
+}
+async function isActiveContinuationSummary(context, summary) {
+  const rawState = await context.stateAdapter.get(
+    threadStateKey(summary.conversationId)
+  ) ?? {};
+  const conversation = coerceThreadConversationState(rawState);
+  return conversation.processing.activeTurnId === summary.sessionId;
+}
+async function seedAwaitingContinuationConversationWork(context, result) {
+  const summaries = uniqueAwaitingContinuationSummaries(
+    await context.stateAdapter.getList(AGENT_TURN_SESSION_INDEX_KEY)
+  );
+  result.scanned += summaries.length;
+  for (const summary of summaries) {
+    if (!await isActiveContinuationSummary(context, summary)) {
+      continue;
+    }
+    const existingConversation = await getConversation({
+      conversationId: summary.conversationId,
+      state: context.stateAdapter
+    });
+    if (existingConversation?.destination && !sameDestination(existingConversation.destination, summary.destination)) {
+      throw new Error(
+        `Awaiting continuation destination does not match conversation ${summary.conversationId}`
+      );
+    }
+    if (existingConversation && existingConversation.execution.status !== "idle") {
+      continue;
+    }
+    await requestConversationWork({
+      conversationId: summary.conversationId,
+      destination: summary.destination,
+      nowMs: Math.max(
+        summary.updatedAtMs,
+        existingConversation?.updatedAtMs ?? 0
+      ),
+      state: context.stateAdapter
+    });
+    if (existingConversation) {
+      result.existing += 1;
+    } else {
+      result.migrated += 1;
+    }
+  }
+}
+async function migrateRedisConversationState(context) {
+  const result = await migrateLegacyConversationWorkRedisState(context);
+  await seedAwaitingContinuationConversationWork(context, result);
+  return result;
+}
+var redisConversationStateMigration = {
+  // TODO(after 2026-07-01): remove after deployed installs have had a release
+  // window to move legacy conversation-work Redis state forward.
+  name: "migrate-redis-conversation-state",
+  run: migrateRedisConversationState
+};
+
+// src/cli/upgrade.ts
+var DEFAULT_IO = {
+  info: console.log
+};
+var MIGRATIONS = [redisConversationStateMigration];
+function formatMigrationResult(result) {
+  return [
+    `scanned=${result.scanned}`,
+    `migrated=${result.migrated}`,
+    `existing=${result.existing}`,
+    `missing=${result.missing}`
+  ].join(" ");
+}
+async function runUpgradeMigrations(context) {
+  const results = [];
+  for (const migration of MIGRATIONS) {
+    context.io.info(`Running migration ${migration.name}...`);
+    const result = await migration.run(context);
+    context.io.info(
+      `Finished migration ${migration.name}: ${formatMigrationResult(result)}`
+    );
+    results.push(result);
+  }
+  return results;
+}
+async function runUpgrade(io = DEFAULT_IO) {
+  try {
+    const { redisStateAdapter, stateAdapter } = await getConnectedStateContext();
+    io.info("Running Junior upgrade migrations...");
+    await runUpgradeMigrations({ io, redisStateAdapter, stateAdapter });
+    io.info("Junior upgrade complete.");
+  } finally {
+    await disconnectStateAdapter();
+  }
+}
+export {
+  runUpgrade,
+  runUpgradeMigrations
+};

package/dist/nitro.d.ts

@@ -1,4 +1,4 @@
-import { type JuniorPluginSet } from "@/plugins";
+import { type JuniorPluginSet } from "./plugins";
 export interface JuniorPluginModuleReference {
     /** Runtime-safe module that exports a `defineJuniorPlugins(...)` set. */
     module: string;

package/dist/nitro.js

@@ -2,19 +2,20 @@ import {
   pluginCatalogConfigFromPluginSet,
   pluginHookRegistrationsFromPluginSet,
   resolveConversationWorkQueueTopic
-} from "./chunk-XE2VFQQN.js";
-import "./chunk-76YMBKW7.js";
+} from "./chunk-ICKIDP7G.js";
 import {
   JUNIOR_CONVERSATION_WORK_CALLBACK_ROUTE,
   JUNIOR_HEARTBEAT_CRON_SCHEDULE,
   JUNIOR_HEARTBEAT_ROUTE
 } from "./chunk-6YY4Q3D4.js";
-import "./chunk-JS4HURDT.js";
+import "./chunk-XC33FJZN.js";
 import {
   discoverInstalledPluginPackageContent,
   isValidPackageName,
   resolvePackageDir
-} from "./chunk-BBXYXOJW.js";
+} from "./chunk-KVZL5NZS.js";
+import "./chunk-ZJQPA67D.js";
+import "./chunk-6GEYPE6T.js";
 import "./chunk-Z3YD6NHK.js";
 import "./chunk-2KG3PWR4.js";
 

package/dist/plugins.d.ts

@@ -1,5 +1,5 @@
 import type { JuniorPluginRegistration } from "@sentry/junior-plugin-api";
-import type { PluginCatalogConfig, PluginManifestConfig } from "@/chat/plugins/types";
+import type { PluginCatalogConfig, PluginManifestConfig } from "./chat/plugins/types";
 export type JuniorPluginInput = JuniorPluginRegistration | string;
 export interface JuniorPluginSetOptions {
     /** Install-level manifest overrides applied before validation. */