@sentry/junior 0.71.2 → 0.72.0

package/dist/{chunk-XE2VFQQN.js → chunk-ICKIDP7G.js}

@@ -1,7 +1,7 @@
 import {
   destinationKey,
   parseDestination
-} from "./chunk-76YMBKW7.js";
+} from "./chunk-XC33FJZN.js";
 
 // src/plugins.ts
 function cloneManifests(manifests) {

package/dist/chunk-KVZL5NZS.js

@@ -0,0 +1,519 @@
+// src/chat/discovery.ts
+import fs, { statSync } from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+function isDirectory(targetPath) {
+  try {
+    return statSync(targetPath).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function isFile(targetPath) {
+  try {
+    return statSync(targetPath).isFile();
+  } catch {
+    return false;
+  }
+}
+function normalizePath(targetPath) {
+  return path.resolve(targetPath);
+}
+function uniqueResolvedPathsInOrder(values) {
+  const seen = /* @__PURE__ */ new Set();
+  const resolved = [];
+  for (const value of values) {
+    const normalized = normalizePath(value);
+    if (seen.has(normalized)) {
+      continue;
+    }
+    seen.add(normalized);
+    resolved.push(normalized);
+  }
+  return resolved;
+}
+function isNodeModulesPath(candidatePath) {
+  return path.basename(candidatePath) === "node_modules";
+}
+function isInsidePnpmStore(candidatePath) {
+  return candidatePath.split(path.sep).includes(".pnpm");
+}
+function runningFromInstalledPackage() {
+  const currentFile = fileURLToPath(import.meta.url);
+  const marker = `${path.sep}node_modules${path.sep}@sentry${path.sep}junior${path.sep}`;
+  return currentFile.includes(marker);
+}
+function listInstalledPackageNodeModulesDirs() {
+  if (!runningFromInstalledPackage()) {
+    return [];
+  }
+  const dirs = [];
+  let current = path.resolve(path.dirname(fileURLToPath(import.meta.url)));
+  while (true) {
+    if (isNodeModulesPath(current) && !isInsidePnpmStore(current) && isDirectory(current)) {
+      dirs.push(current);
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  return dirs;
+}
+function listCwdAncestorNodeModulesDirs(cwd) {
+  const resolvedCwd = normalizePath(cwd);
+  const dirs = [];
+  let current = resolvedCwd;
+  while (true) {
+    const nodeModulesDir = path.join(current, "node_modules");
+    if (isDirectory(nodeModulesDir)) {
+      dirs.push(nodeModulesDir);
+    }
+    if (isFile(path.join(current, "package.json"))) {
+      break;
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  return dirs;
+}
+function discoverNodeModulesDirs(cwd = process.cwd(), options) {
+  const explicit = options?.candidateDirs?.filter((dir) => isDirectory(dir)) ?? [];
+  if (explicit.length > 0) {
+    return uniqueResolvedPathsInOrder(explicit);
+  }
+  return uniqueResolvedPathsInOrder([
+    ...listInstalledPackageNodeModulesDirs(),
+    ...listCwdAncestorNodeModulesDirs(cwd)
+  ]);
+}
+function discoverProjectRoots(cwd = process.cwd(), options) {
+  const roots = discoverNodeModulesDirs(
+    cwd,
+    options?.nodeModulesDirs ? { candidateDirs: options.nodeModulesDirs } : void 0
+  ).map((nodeModulesDir) => path.dirname(nodeModulesDir));
+  return uniqueResolvedPathsInOrder([cwd, ...roots]);
+}
+function unique(values) {
+  return [...new Set(values)];
+}
+function pathExists(targetPath) {
+  try {
+    fs.accessSync(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function hasAnyDataMarkers(appDir) {
+  return pathExists(path.join(appDir, "SOUL.md")) || pathExists(path.join(appDir, "WORLD.md"));
+}
+function scoreAppCandidate(appDir) {
+  let score = 0;
+  if (pathExists(path.join(appDir, "SOUL.md"))) {
+    score += 4;
+  }
+  if (pathExists(path.join(appDir, "WORLD.md"))) {
+    score += 2;
+  }
+  if (pathExists(path.join(appDir, "skills"))) {
+    score += 1;
+  }
+  if (pathExists(path.join(appDir, "plugins"))) {
+    score += 1;
+  }
+  return score;
+}
+function resolveCandidateAppDirs(cwd, projectRoots) {
+  const roots = projectRoots ?? discoverProjectRoots(cwd);
+  const resolved = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const root of roots) {
+    const appDir = path.resolve(root, "app");
+    if (!pathExists(appDir)) {
+      continue;
+    }
+    if (seen.has(appDir)) {
+      continue;
+    }
+    seen.add(appDir);
+    resolved.push(appDir);
+  }
+  return resolved;
+}
+function homeDir() {
+  return resolveHomeDir();
+}
+function resolveHomeDir(cwd = process.cwd(), options) {
+  const resolvedCwd = path.resolve(cwd);
+  const directApp = path.resolve(resolvedCwd, "app");
+  if (pathExists(directApp) && hasAnyDataMarkers(directApp)) {
+    return directApp;
+  }
+  const candidates = resolveCandidateAppDirs(
+    resolvedCwd,
+    options?.projectRoots
+  );
+  if (candidates.length === 0) {
+    return directApp;
+  }
+  candidates.sort((left, right) => {
+    const leftScore = scoreAppCandidate(left);
+    const rightScore = scoreAppCandidate(right);
+    if (leftScore !== rightScore) {
+      return rightScore - leftScore;
+    }
+    const leftDistance = path.relative(resolvedCwd, left).split(path.sep).length;
+    const rightDistance = path.relative(resolvedCwd, right).split(path.sep).length;
+    if (leftDistance !== rightDistance) {
+      return leftDistance - rightDistance;
+    }
+    return left.localeCompare(right);
+  });
+  return candidates[0];
+}
+function resolveContentRoots(subdir) {
+  if (subdir === "data") {
+    return [homeDir()];
+  }
+  return [path.join(homeDir(), subdir)];
+}
+function dataRoots() {
+  return unique(resolveContentRoots("data"));
+}
+function skillRoots() {
+  return unique(resolveContentRoots("skills"));
+}
+function pluginRoots() {
+  return unique(resolveContentRoots("plugins"));
+}
+function soulPathCandidates() {
+  const candidates = dataRoots().map((root) => path.join(root, "SOUL.md"));
+  return unique(candidates);
+}
+function worldPathCandidates() {
+  const candidates = dataRoots().map((root) => path.join(root, "WORLD.md"));
+  return unique(candidates);
+}
+var RESERVED_APP_FILES = /* @__PURE__ */ new Set([
+  "SOUL.md",
+  "WORLD.md",
+  "DESCRIPTION.md",
+  "ABOUT.md"
+]);
+function listReferenceFiles() {
+  const appDir = homeDir();
+  try {
+    const entries = fs.readdirSync(appDir, { withFileTypes: true });
+    return entries.filter(
+      (entry) => entry.isFile() && entry.name.endsWith(".md") && !RESERVED_APP_FILES.has(entry.name)
+    ).map((entry) => path.join(appDir, entry.name)).sort();
+  } catch {
+    return [];
+  }
+}
+
+// src/package-resolution.ts
+import { statSync as statSync2 } from "fs";
+import { createRequire } from "module";
+import path2 from "path";
+function isDirectory2(targetPath) {
+  try {
+    return statSync2(targetPath).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function isFile2(targetPath) {
+  try {
+    return statSync2(targetPath).isFile();
+  } catch {
+    return false;
+  }
+}
+function uniqueResolvedPathsInOrder2(values) {
+  const seen = /* @__PURE__ */ new Set();
+  const resolved = [];
+  for (const value of values) {
+    const normalized = path2.resolve(value);
+    if (seen.has(normalized)) {
+      continue;
+    }
+    seen.add(normalized);
+    resolved.push(normalized);
+  }
+  return resolved;
+}
+function ancestorNodeModulesDirs(cwd) {
+  const dirs = [];
+  let current = path2.resolve(cwd);
+  while (true) {
+    const nodeModulesDir = path2.join(current, "node_modules");
+    if (isDirectory2(nodeModulesDir)) {
+      dirs.push(nodeModulesDir);
+    }
+    const parent = path2.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  return dirs;
+}
+function packageDirInNodeModules(nodeModulesDir, packageName) {
+  const packageDir = path2.join(nodeModulesDir, ...packageName.split("/"));
+  return isDirectory2(packageDir) ? path2.resolve(packageDir) : void 0;
+}
+function isValidPackageSegment(segment) {
+  return Boolean(segment) && segment !== "." && segment !== ".." && !segment.startsWith(".") && /^[A-Za-z0-9._~-]+$/.test(segment);
+}
+function isValidPackageName(packageName) {
+  if (!packageName || packageName.includes("\\") || path2.isAbsolute(packageName)) {
+    return false;
+  }
+  const parts = packageName.split("/");
+  if (parts[0].startsWith("@")) {
+    return parts.length === 2 && parts[0].length > 1 && isValidPackageSegment(parts[0].slice(1)) && isValidPackageSegment(parts[1]);
+  }
+  return parts.length === 1 && isValidPackageSegment(parts[0]);
+}
+function findPackageRoot(entryPath) {
+  let dir = path2.dirname(entryPath);
+  while (dir !== path2.dirname(dir)) {
+    if (isFile2(path2.join(dir, "package.json"))) {
+      return path2.resolve(dir);
+    }
+    dir = path2.dirname(dir);
+  }
+  return void 0;
+}
+function findPackageNodeModulesDir(packageDir, packageName) {
+  const parts = path2.resolve(packageDir).split(path2.sep);
+  const packageParts = packageName.split("/");
+  for (let index = parts.length - 1; index >= 0; index -= 1) {
+    if (parts[index] !== "node_modules") {
+      continue;
+    }
+    const candidatePackageParts = parts.slice(
+      index + 1,
+      index + 1 + packageParts.length
+    );
+    if (candidatePackageParts.join("/") !== packageParts.join("/")) {
+      continue;
+    }
+    return path2.resolve(parts.slice(0, index + 1).join(path2.sep) || path2.sep);
+  }
+  return void 0;
+}
+function resolvePackageWithNode(cwd, packageName) {
+  let requireFromCwd;
+  try {
+    requireFromCwd = createRequire(path2.join(cwd, "package.json"));
+  } catch {
+    return void 0;
+  }
+  for (const specifier of [`${packageName}/package.json`, packageName]) {
+    try {
+      const resolved = requireFromCwd.resolve(specifier);
+      const dir = specifier.endsWith("/package.json") ? path2.dirname(resolved) : findPackageRoot(resolved);
+      if (!dir) {
+        continue;
+      }
+      const nodeModulesDir = findPackageNodeModulesDir(dir, packageName);
+      return {
+        dir,
+        ...nodeModulesDir ? { nodeModulesDir } : {}
+      };
+    } catch {
+    }
+  }
+  return void 0;
+}
+function resolvePackageLocation(cwd, packageName, options) {
+  if (!isValidPackageName(packageName)) {
+    return void 0;
+  }
+  const nodeModulesDirs = uniqueResolvedPathsInOrder2([
+    ...options?.nodeModulesDirs ?? [],
+    ...ancestorNodeModulesDirs(cwd)
+  ]);
+  for (const nodeModulesDir of nodeModulesDirs) {
+    const dir = packageDirInNodeModules(nodeModulesDir, packageName);
+    if (dir) {
+      return { dir, nodeModulesDir };
+    }
+  }
+  return resolvePackageWithNode(cwd, packageName);
+}
+function resolvePackageDir(cwd, packageName) {
+  return resolvePackageLocation(cwd, packageName)?.dir;
+}
+
+// src/chat/plugins/package-discovery.ts
+import path3 from "path";
+function normalizeForGlob(targetPath) {
+  return targetPath.split(path3.sep).join("/");
+}
+function uniqueStringsInOrder(values) {
+  const seen = /* @__PURE__ */ new Set();
+  const resolved = [];
+  for (const value of values) {
+    if (seen.has(value)) {
+      continue;
+    }
+    seen.add(value);
+    resolved.push(value);
+  }
+  return resolved;
+}
+function pathForTracingInclude(cwd, targetPath) {
+  const relative = path3.relative(cwd, targetPath);
+  if (!relative || path3.isAbsolute(relative) || relative === ".." || relative.startsWith(`..${path3.sep}`)) {
+    return null;
+  }
+  const normalized = normalizeForGlob(relative);
+  return normalized.startsWith(".") ? normalized : `./${normalized}`;
+}
+function normalizePluginPackageNames(packageNames) {
+  if (packageNames === void 0) {
+    return [];
+  }
+  if (!Array.isArray(packageNames)) {
+    throw new Error("Plugin package names must be an array");
+  }
+  const normalized = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const packageName of packageNames) {
+    const normalizedPackageName = typeof packageName === "string" ? packageName.trim() : "";
+    if (!normalizedPackageName || !isValidPackageName(normalizedPackageName)) {
+      throw new Error("Plugin package names must be valid npm package names");
+    }
+    if (seen.has(normalizedPackageName)) {
+      continue;
+    }
+    seen.add(normalizedPackageName);
+    normalized.push(normalizedPackageName);
+  }
+  return normalized;
+}
+function formatNodeModulesDirs(candidateNodeModulesDirs) {
+  return candidateNodeModulesDirs.length > 0 ? candidateNodeModulesDirs.join(", ") : "none found";
+}
+function resolvePackageDirFromName(cwd, packageName, candidateNodeModulesDirs) {
+  return resolvePackageLocation(cwd, packageName, {
+    nodeModulesDirs: candidateNodeModulesDirs
+  }) ?? null;
+}
+function readPluginPackageFlags(dir) {
+  const hasRootPluginManifest = isFile(path3.join(dir, "plugin.yaml"));
+  const hasPluginsDir = isDirectory(path3.join(dir, "plugins"));
+  const hasSkillsDir = isDirectory(path3.join(dir, "skills"));
+  if (!hasRootPluginManifest && !hasPluginsDir && !hasSkillsDir) {
+    return null;
+  }
+  return {
+    hasRootPluginManifest,
+    hasPluginsDir,
+    hasSkillsDir
+  };
+}
+function discoverDeclaredPackages(packageNames, candidateNodeModulesDirs, cwd) {
+  const discovered = [];
+  const seenPackageDirs = /* @__PURE__ */ new Set();
+  for (const packageName of packageNames) {
+    const resolved = resolvePackageDirFromName(
+      cwd,
+      packageName,
+      candidateNodeModulesDirs
+    );
+    if (!resolved) {
+      throw new Error(
+        `Plugin package "${packageName}" was configured but could not be resolved from node_modules or package resolution (${formatNodeModulesDirs(candidateNodeModulesDirs)})`
+      );
+    }
+    if (seenPackageDirs.has(resolved.dir)) {
+      continue;
+    }
+    const pluginFlags = readPluginPackageFlags(resolved.dir);
+    if (!pluginFlags) {
+      throw new Error(
+        `Plugin package "${packageName}" was configured but does not contain plugin content; expected plugin.yaml, plugins/, or skills/ in ${resolved.dir}`
+      );
+    }
+    seenPackageDirs.add(resolved.dir);
+    discovered.push({
+      name: packageName,
+      dir: resolved.dir,
+      nodeModulesDir: resolved.nodeModulesDir,
+      ...pluginFlags
+    });
+  }
+  return discovered;
+}
+function discoverInstalledPluginPackageContent(cwd = process.cwd(), options) {
+  const resolvedCwd = path3.resolve(cwd);
+  const packageNames = normalizePluginPackageNames(options?.packageNames);
+  const nodeModulesDirs = options?.nodeModulesDirs ?? discoverNodeModulesDirs(resolvedCwd);
+  const discoveredPackages = discoverDeclaredPackages(
+    packageNames,
+    nodeModulesDirs,
+    resolvedCwd
+  );
+  const manifestRoots = [];
+  const skillRoots2 = [];
+  const tracingIncludes = [];
+  for (const pkg of discoveredPackages) {
+    const tracingBasePath = pkg.nodeModulesDir ? pathForTracingInclude(
+      resolvedCwd,
+      path3.join(pkg.nodeModulesDir, ...pkg.name.split("/"))
+    ) : pathForTracingInclude(resolvedCwd, pkg.dir);
+    if (pkg.hasRootPluginManifest) {
+      manifestRoots.push(pkg.dir);
+      if (tracingBasePath) {
+        tracingIncludes.push(`${tracingBasePath}/plugin.yaml`);
+      }
+    }
+    if (pkg.hasPluginsDir) {
+      manifestRoots.push(path3.join(pkg.dir, "plugins"));
+      if (tracingBasePath) {
+        tracingIncludes.push(`${tracingBasePath}/plugins/**/*`);
+      }
+    }
+    if (pkg.hasSkillsDir) {
+      skillRoots2.push(path3.join(pkg.dir, "skills"));
+      if (tracingBasePath) {
+        tracingIncludes.push(`${tracingBasePath}/skills/**/*`);
+      }
+    }
+  }
+  return {
+    packageNames: uniqueStringsInOrder(
+      discoveredPackages.map((pkg) => pkg.name)
+    ),
+    packages: discoveredPackages.map((pkg) => ({
+      dir: pkg.dir,
+      hasSkillsDir: pkg.hasSkillsDir,
+      name: pkg.name
+    })),
+    manifestRoots: uniqueStringsInOrder(manifestRoots),
+    skillRoots: uniqueStringsInOrder(skillRoots2),
+    tracingIncludes: uniqueStringsInOrder(tracingIncludes)
+  };
+}
+
+export {
+  homeDir,
+  skillRoots,
+  pluginRoots,
+  soulPathCandidates,
+  worldPathCandidates,
+  listReferenceFiles,
+  isValidPackageName,
+  resolvePackageDir,
+  normalizePluginPackageNames,
+  discoverInstalledPluginPackageContent
+};

package/dist/chunk-PP7AGSBU.js

@@ -0,0 +1,185 @@
+import {
+  isSlackTeamId
+} from "./chunk-6GEYPE6T.js";
+
+// src/chat/requester.ts
+import { z } from "zod";
+var SLACK_USER_ID_PATTERN = /^[UW][A-Z0-9]{5,}$/;
+var EMAIL_PATTERN = /^[^\s@<>]+@[^\s@<>]+\.[^\s@<>]+$/;
+var exactStoredStringSchema = z.string().min(1).refine((value) => value === value.trim());
+var storedSlackRequesterSchema = z.object({
+  email: exactStoredStringSchema.optional(),
+  fullName: exactStoredStringSchema.optional(),
+  platform: z.literal("slack").optional(),
+  slackUserId: exactStoredStringSchema.optional(),
+  slackUserName: exactStoredStringSchema.optional(),
+  teamId: exactStoredStringSchema.optional()
+}).strict();
+function clean(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : void 0;
+}
+function isSyntheticActorUserId(value) {
+  return value.toLowerCase() === "unknown";
+}
+function isSlackUserId(value) {
+  return SLACK_USER_ID_PATTERN.test(value);
+}
+function parseSlackTeamId(value) {
+  return typeof value === "string" && isSlackTeamId(value) ? value : void 0;
+}
+function cleanRequesterDisplayName(value, userId) {
+  const displayName = clean(value);
+  if (!displayName) {
+    return void 0;
+  }
+  if (displayName.toLowerCase() === "unknown") {
+    return void 0;
+  }
+  if (userId && displayName === userId) {
+    return void 0;
+  }
+  return isSlackUserId(displayName) ? void 0 : displayName;
+}
+function cleanRequesterEmail(value) {
+  const email = clean(value);
+  return email && EMAIL_PATTERN.test(email) ? email : void 0;
+}
+function parseActorUserId(value) {
+  if (typeof value !== "string" || value.length === 0) {
+    return void 0;
+  }
+  if (value !== value.trim() || isSyntheticActorUserId(value)) {
+    return void 0;
+  }
+  return value;
+}
+function isActorUserId(value) {
+  return parseActorUserId(value) === value;
+}
+function createRequester(input, context) {
+  const contextUserId = parseActorUserId(context.userId);
+  if (context.userId !== void 0 && !contextUserId) {
+    return void 0;
+  }
+  const inputUserId = parseActorUserId(input?.userId);
+  if (input?.userId !== void 0 && !inputUserId) {
+    return void 0;
+  }
+  const contextTeamId = parseSlackTeamId(context.teamId);
+  if (context.teamId !== void 0 && !contextTeamId) {
+    return void 0;
+  }
+  const inputTeamId = parseSlackTeamId(input?.teamId);
+  if (input?.teamId !== void 0 && !inputTeamId) {
+    return void 0;
+  }
+  const requesterUserId = contextUserId ?? inputUserId;
+  const requesterTeamId = contextTeamId ?? inputTeamId;
+  if (!requesterUserId || !requesterTeamId) {
+    return void 0;
+  }
+  const canUseInputProfile = (!contextUserId || !inputUserId || contextUserId === inputUserId) && (!contextTeamId || !inputTeamId || contextTeamId === inputTeamId);
+  return {
+    ...canUseInputProfile && cleanRequesterEmail(input?.email) ? { email: cleanRequesterEmail(input?.email) } : {},
+    ...canUseInputProfile && cleanRequesterDisplayName(input?.fullName, requesterUserId) ? {
+      fullName: cleanRequesterDisplayName(input?.fullName, requesterUserId)
+    } : {},
+    platform: "slack",
+    teamId: requesterTeamId,
+    userId: requesterUserId,
+    ...canUseInputProfile && cleanRequesterDisplayName(input?.userName, requesterUserId) ? {
+      userName: cleanRequesterDisplayName(input?.userName, requesterUserId)
+    } : {}
+  };
+}
+function createSlackRequester(teamId, userId, profile) {
+  const actorUserId = parseActorUserId(userId);
+  const actorTeamId = parseSlackTeamId(teamId);
+  if (!actorTeamId || !actorUserId) {
+    throw new Error("Slack requester requires team and user ids");
+  }
+  const requester = createRequester(
+    {
+      email: profile?.email,
+      fullName: profile?.fullName,
+      platform: "slack",
+      teamId: actorTeamId,
+      userId: actorUserId,
+      userName: profile?.userName
+    },
+    { teamId: actorTeamId, userId: actorUserId }
+  );
+  if (!requester) {
+    throw new Error("Slack requester requires team and user ids");
+  }
+  return requester;
+}
+function parseStoredSlackRequester(value) {
+  const parsed = storedSlackRequesterSchema.safeParse(value);
+  if (!parsed.success) {
+    return void 0;
+  }
+  if (parsed.data.slackUserId !== void 0 && !parseActorUserId(parsed.data.slackUserId)) {
+    return void 0;
+  }
+  if (parsed.data.teamId !== void 0 && !parseSlackTeamId(parsed.data.teamId)) {
+    return void 0;
+  }
+  if ((parsed.data.platform !== void 0 || parsed.data.teamId !== void 0) && (!parsed.data.platform || !parsed.data.teamId)) {
+    return void 0;
+  }
+  return parsed.data;
+}
+function toStoredSlackRequester(requester) {
+  return {
+    ...requester.email ? { email: requester.email } : {},
+    ...requester.fullName ? { fullName: requester.fullName } : {},
+    platform: requester.platform,
+    slackUserId: requester.userId,
+    ...requester.userName ? { slackUserName: requester.userName } : {},
+    teamId: requester.teamId
+  };
+}
+function createRequesterFromStoredSlackRequester(args) {
+  const actorUserId = parseActorUserId(args.userId);
+  const actorTeamId = parseSlackTeamId(args.teamId);
+  if (!actorTeamId || !actorUserId) {
+    throw new Error("Slack requester requires team and user ids");
+  }
+  const storedUserId = args.requester?.slackUserId === void 0 ? void 0 : parseActorUserId(args.requester.slackUserId);
+  const storedTeamId = args.requester?.teamId === void 0 ? void 0 : parseSlackTeamId(args.requester.teamId);
+  if (args.requester?.slackUserId !== void 0 && !storedUserId) {
+    throw new Error("Stored Slack requester requires a user id");
+  }
+  if (args.requester?.teamId !== void 0 && !storedTeamId) {
+    throw new Error("Stored Slack requester requires a team id");
+  }
+  if (storedUserId && storedUserId !== actorUserId) {
+    throw new Error("Stored Slack requester must match actor user id");
+  }
+  if (storedTeamId && storedTeamId !== actorTeamId) {
+    throw new Error("Stored Slack requester must match actor team id");
+  }
+  const canUseStoredProfile = Boolean(storedUserId);
+  return createSlackRequester(
+    actorTeamId,
+    actorUserId,
+    canUseStoredProfile ? {
+      email: args.requester?.email,
+      fullName: args.requester?.fullName,
+      userName: args.requester?.slackUserName
+    } : void 0
+  );
+}
+
+export {
+  storedSlackRequesterSchema,
+  parseActorUserId,
+  isActorUserId,
+  createRequester,
+  createSlackRequester,
+  parseStoredSlackRequester,
+  toStoredSlackRequester,
+  createRequesterFromStoredSlackRequester
+};