@sentry/junior 0.74.1 → 0.76.0

package/dist/cli/run.js

@@ -1,55 +1,8 @@
-import "../chunk-2KG3PWR4.js";
-
-// src/cli/run.ts
-var CLI_USAGE = "usage: junior init <dir>\n       junior snapshot create\n       junior check [dir]\n       junior upgrade\n       junior chat\n       junior chat -p <message>";
-var DEFAULT_IO = {
-  error: console.error
-};
-function normalizeCliArgv(argv) {
-  return argv[0] === "--" ? argv.slice(1) : argv;
-}
-async function runCli(argv, handlers, io = DEFAULT_IO) {
-  const [command, subcommand, ...rest] = normalizeCliArgv(argv);
-  if (command === "chat") {
-    return await handlers.runChat(
-      subcommand === void 0 ? [] : [subcommand, ...rest]
-    );
-  }
-  if (command === "init") {
-    if (!subcommand || rest.length > 0) {
-      io.error(CLI_USAGE);
-      return 1;
-    }
-    await handlers.runInit(subcommand);
-    return 0;
-  }
-  if (command === "snapshot" && subcommand === "create") {
-    if (rest.length > 0) {
-      io.error(CLI_USAGE);
-      return 1;
-    }
-    await handlers.runSnapshotCreate();
-    return 0;
-  }
-  if (command === "check") {
-    if (rest.length > 0) {
-      io.error(CLI_USAGE);
-      return 1;
-    }
-    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;
-}
+import {
+  CLI_USAGE,
+  runCli
+} from "../chunk-4UO6FK4G.js";
+import "../chunk-MLKGABMK.js";
 export {
   CLI_USAGE,
   runCli

package/dist/cli/snapshot-warmup.js

@@ -1,21 +1,22 @@
 import {
   resolveRuntimeDependencySnapshot
-} from "../chunk-6UP2Z2RZ.js";
+} from "../chunk-JBASI5VV.js";
 import "../chunk-G3E7SCME.js";
+import {
+  disconnectStateAdapter
+} from "../chunk-Y5OFBCBZ.js";
+import "../chunk-T77LUIX3.js";
 import {
   getPluginProviders,
   getPluginRuntimeDependencies,
   getPluginRuntimePostinstall
-} from "../chunk-7Q5YOUUT.js";
-import "../chunk-KVZL5NZS.js";
-import {
-  disconnectStateAdapter
-} from "../chunk-F6HWCPOC.js";
-import "../chunk-GM7HTXYC.js";
-import "../chunk-CYUI7JU5.js";
-import "../chunk-3BYAPS6B.js";
-import "../chunk-SJHUF3DP.js";
-import "../chunk-2KG3PWR4.js";
+} from "../chunk-ZLMBNBUG.js";
+import "../chunk-VALUBQ7R.js";
+import "../chunk-Q3XNY442.js";
+import "../chunk-EJN6G5A2.js";
+import "../chunk-OJ53FYVG.js";
+import "../chunk-ST6YNAXG.js";
+import "../chunk-MLKGABMK.js";
 
 // src/cli/snapshot-warmup.ts
 var DEFAULT_RUNTIME = "node22";

package/dist/cli/upgrade.js

@@ -1,33 +1,59 @@
 import {
-  coerceThreadConversationState
-} from "../chunk-M4FLLXXD.js";
-import {
-  JUNIOR_THREAD_STATE_TTL_MS,
-  createNeonJuniorSqlExecutor,
-  createSqlStore,
-  createStateConversationStore,
   getConversation,
+  listConversationsByActivity,
+  recordConversationActivity,
   requestConversationWork
-} from "../chunk-JL2SLRAT.js";
+} from "../chunk-R6Z5XWY3.js";
 import {
-  parseDestination,
-  sameDestination
-} from "../chunk-YRDS7VKO.js";
+  JUNIOR_THREAD_STATE_TTL_MS,
+  coerceThreadConversationState
+} from "../chunk-Z4CIQ3EB.js";
+import {
+  defineJuniorPlugins,
+  pluginCatalogConfigFromEnv,
+  pluginCatalogConfigFromPluginSet,
+  pluginRuntimeRegistrationsFromPluginSet
+} from "../chunk-SG5WAA7H.js";
+import {
+  createPluginLogger,
+  createPluginState
+} from "../chunk-56TBVRJG.js";
+import {
+  createJuniorSqlExecutor,
+  createSqlStore,
+  getDb
+} from "../chunk-NYKJ3KON.js";
 import {
   disconnectStateAdapter,
   getConnectedStateContext
-} from "../chunk-F6HWCPOC.js";
+} from "../chunk-Y5OFBCBZ.js";
+import {
+  parseDestination,
+  sameDestination
+} from "../chunk-Q6XFTRV5.js";
 import {
   getChatConfig
-} from "../chunk-GM7HTXYC.js";
-import "../chunk-CYUI7JU5.js";
+} from "../chunk-T77LUIX3.js";
+import {
+  loadAppPluginSet
+} from "../chunk-Y2CM7HXH.js";
+import {
+  getPluginMigrationRoots,
+  setPluginCatalogConfig
+} from "../chunk-ZLMBNBUG.js";
+import "../chunk-VALUBQ7R.js";
+import "../chunk-Q3XNY442.js";
 import {
   isRecord,
   toOptionalNumber,
   toOptionalString
-} from "../chunk-3BYAPS6B.js";
-import "../chunk-SJHUF3DP.js";
-import "../chunk-2KG3PWR4.js";
+} from "../chunk-EJN6G5A2.js";
+import "../chunk-OJ53FYVG.js";
+import "../chunk-ST6YNAXG.js";
+import "../chunk-MLKGABMK.js";
+
+// src/cli/upgrade.ts
+import { createJiti } from "jiti";
 
 // src/chat/conversations/sql/backfill.ts
 async function backfillToSql(args) {
@@ -44,6 +70,17 @@ async function backfillToSql(args) {
   };
 }
 
+// src/chat/conversations/state.ts
+function createStateConversationStore(state) {
+  return {
+    get: (args) => getConversation({ ...args, state }),
+    recordActivity: (args) => recordConversationActivity({ ...args, state }),
+    recordExecution: async () => {
+    },
+    listByActivity: (args) => listConversationsByActivity({ ...args, state })
+  };
+}
+
 // src/cli/upgrade/migrations/conversations-sql.ts
 var CONVERSATION_BACKFILL_LIMIT = 1e4;
 var REQUIRED_SQL_DATABASE_URL_MESSAGE = "Junior SQL database URL is required for conversation metadata upgrade. Set JUNIOR_DATABASE_URL or DATABASE_URL.";
@@ -60,8 +97,9 @@ async function migrateConversationsToSql(context, options = {}) {
   let closeTarget;
   if (!target) {
     const databaseUrl = requireConversationSqlDatabaseUrl(context);
-    const executor = createNeonJuniorSqlExecutor({
-      connectionString: databaseUrl
+    const executor = createJuniorSqlExecutor({
+      connectionString: databaseUrl,
+      driver: context.sqlDriver ?? getChatConfig().sql.driver
     });
     target = createSqlStore(executor);
     closeTarget = () => executor.close();
@@ -88,6 +126,294 @@ var sqlConversationMigration = {
   run: migrateConversationsToSql
 };
 
+// src/cli/upgrade/migrations/upgrade-plugins.ts
+function unique(values) {
+  return [...new Set(values)];
+}
+function baseCatalogConfig(context) {
+  return context.pluginCatalogConfig ?? (context.pluginSet ? pluginCatalogConfigFromPluginSet(context.pluginSet) : pluginCatalogConfigFromEnv());
+}
+function inlinePluginName(definition) {
+  return definition.manifest.name;
+}
+function mergeInlineManifests(left, right) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const definition of [...left ?? [], ...right ?? []]) {
+    merged.set(inlinePluginName(definition), definition);
+  }
+  return merged.size > 0 ? [...merged.values()] : void 0;
+}
+function mergeCatalogConfig(base, added) {
+  if (!base) {
+    return added;
+  }
+  if (!added) {
+    return base;
+  }
+  const inlineManifests = mergeInlineManifests(
+    base.inlineManifests,
+    added.inlineManifests
+  );
+  const packages = unique([
+    ...base.packages ?? [],
+    ...added.packages ?? []
+  ]);
+  const manifests = base.manifests || added.manifests ? { ...base.manifests, ...added.manifests } : void 0;
+  return {
+    ...inlineManifests ? { inlineManifests } : {},
+    ...packages.length > 0 ? { packages } : {},
+    ...manifests ? { manifests } : {}
+  };
+}
+function packageNamesFromContext(context, catalog) {
+  return unique([
+    ...context.pluginSet?.packageNames ?? [],
+    ...catalog?.packages ?? []
+  ]);
+}
+async function resolveUpgradePlugins(context) {
+  const catalog = baseCatalogConfig(context);
+  const packageNames = packageNamesFromContext(context, catalog);
+  const registrations = context.pluginSet?.registrations ?? [];
+  const manifests = context.pluginSet?.manifests || catalog?.manifests ? {
+    ...catalog?.manifests,
+    ...context.pluginSet?.manifests
+  } : void 0;
+  const pluginSet = packageNames.length > 0 || registrations.length > 0 || context.pluginSet ? defineJuniorPlugins(
+    [...packageNames, ...registrations],
+    manifests ? { manifests } : {}
+  ) : void 0;
+  return {
+    pluginCatalogConfig: mergeCatalogConfig(
+      catalog,
+      pluginCatalogConfigFromPluginSet(pluginSet)
+    ),
+    ...pluginSet ? { pluginSet } : {}
+  };
+}
+
+// src/cli/upgrade/migrations/plugin-storage.ts
+function emptyResult() {
+  return {
+    existing: 0,
+    migrated: 0,
+    missing: 0,
+    scanned: 0
+  };
+}
+function addResult(left, right) {
+  return {
+    existing: left.existing + right.existing,
+    migrated: left.migrated + right.migrated,
+    missing: left.missing + right.missing,
+    scanned: left.scanned + right.scanned,
+    ...left.skipped !== void 0 || right.skipped !== void 0 ? { skipped: (left.skipped ?? 0) + (right.skipped ?? 0) } : {}
+  };
+}
+function dbForPlugin(context, sqlUrlDb) {
+  return context.db ?? sqlUrlDb ?? getDb();
+}
+async function runPluginStorageMigrations(context) {
+  const { pluginCatalogConfig, pluginSet } = await resolveUpgradePlugins(context);
+  if (!pluginSet) {
+    return emptyResult();
+  }
+  const previousConfig = setPluginCatalogConfig(pluginCatalogConfig);
+  const ownedExecutor = context.db || !context.sqlDatabaseUrl ? void 0 : createJuniorSqlExecutor({
+    connectionString: context.sqlDatabaseUrl,
+    driver: context.sqlDriver ?? getChatConfig().sql.driver
+  });
+  const sqlUrlDb = ownedExecutor ? ownedExecutor.db() : void 0;
+  try {
+    let result = emptyResult();
+    const plugins = pluginRuntimeRegistrationsFromPluginSet(pluginSet).filter((plugin) => plugin.hooks?.migrateStorage).sort(
+      (left, right) => left.manifest.name.localeCompare(right.manifest.name)
+    );
+    for (const plugin of plugins) {
+      const pluginName = plugin.manifest.name;
+      const hook = plugin.hooks?.migrateStorage;
+      if (!hook) {
+        continue;
+      }
+      const db = dbForPlugin(context, sqlUrlDb);
+      const pluginResult = await hook({
+        db,
+        log: createPluginLogger(pluginName),
+        plugin: { name: pluginName },
+        state: createPluginState(pluginName, context.stateAdapter)
+      });
+      if (pluginResult) {
+        result = addResult(result, pluginResult);
+      }
+    }
+    return result;
+  } finally {
+    setPluginCatalogConfig(previousConfig);
+    await ownedExecutor?.close();
+  }
+}
+var pluginStorageMigration = {
+  name: "run-plugin-storage-migrations",
+  run: runPluginStorageMigrations
+};
+
+// src/chat/plugins/db.ts
+import { createHash } from "crypto";
+import { readdirSync, readFileSync, statSync } from "fs";
+import path from "path";
+import { z } from "zod";
+var PLUGIN_SCHEMA_LOCK_NAME = "junior_plugin_schema";
+var MIGRATION_FILENAME_RE = /^[0-9]{4}_[a-z0-9_]+\.sql$/;
+var migrationRecordSchema = z.object({
+  id: z.string().min(1),
+  checksum: z.string().min(1)
+}).strict();
+function checksumSql(sql) {
+  return createHash("sha256").update(sql).digest("hex");
+}
+function parseStoredMigrationRecord(value) {
+  return migrationRecordSchema.parse(value);
+}
+function assertMigrationFilename(filename) {
+  if (!filename || filename !== path.basename(filename) || !MIGRATION_FILENAME_RE.test(filename)) {
+    throw new Error(`Plugin migration filename "${filename}" is invalid`);
+  }
+}
+function assertUniqueMigrationIds(migrations) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const migration of migrations) {
+    if (seen.has(migration.id)) {
+      throw new Error(`Duplicate plugin migration id ${migration.id}`);
+    }
+    seen.add(migration.id);
+  }
+}
+function migrationId(pluginName, filename) {
+  return `plugin:${pluginName}/${filename}`;
+}
+function createMigrationTableSql() {
+  return `
+CREATE TABLE IF NOT EXISTS junior_schema_migrations (
+  id TEXT PRIMARY KEY,
+  checksum TEXT NOT NULL,
+  applied_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP
+)
+`;
+}
+async function listAppliedMigrations(executor) {
+  const rows = await executor.query(
+    "SELECT id, checksum FROM junior_schema_migrations ORDER BY id ASC"
+  );
+  const records = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const record = parseStoredMigrationRecord(row);
+    records.set(record.id, record);
+  }
+  return records;
+}
+async function applyPluginMigration(executor, migration) {
+  await executor.transaction(async () => {
+    await executor.execute(migration.sql);
+    await executor.execute(
+      "INSERT INTO junior_schema_migrations (id, checksum) VALUES ($1, $2)",
+      [migration.id, migration.checksum]
+    );
+  });
+}
+function readPluginMigrations(root) {
+  const migrationsDir = root.dir;
+  let stat;
+  try {
+    stat = statSync(migrationsDir);
+  } catch {
+    return [];
+  }
+  if (!stat.isDirectory()) {
+    throw new Error(
+      `Plugin "${root.pluginName}" migrations path is not a directory`
+    );
+  }
+  return readdirSync(migrationsDir).filter((filename) => filename.endsWith(".sql")).sort((left, right) => left.localeCompare(right)).map((filename) => {
+    assertMigrationFilename(filename);
+    const sql = readFileSync(path.join(migrationsDir, filename), "utf8");
+    if (!sql.trim()) {
+      throw new Error(
+        `Plugin "${root.pluginName}" migration "${filename}" is empty`
+      );
+    }
+    return {
+      checksum: checksumSql(sql),
+      filename,
+      id: migrationId(root.pluginName, filename),
+      pluginName: root.pluginName,
+      sql
+    };
+  });
+}
+async function migratePluginSchemas(executor, migrations) {
+  assertUniqueMigrationIds(migrations);
+  const result = {
+    existing: 0,
+    migrated: 0,
+    scanned: migrations.length
+  };
+  await executor.withLock(PLUGIN_SCHEMA_LOCK_NAME, async () => {
+    await executor.execute(createMigrationTableSql());
+    const applied = await listAppliedMigrations(executor);
+    for (const migration of migrations) {
+      const existing = applied.get(migration.id);
+      if (existing) {
+        if (existing.checksum !== migration.checksum) {
+          throw new Error(`Plugin migration ${migration.id} checksum changed`);
+        }
+        result.existing++;
+        continue;
+      }
+      await applyPluginMigration(executor, migration);
+      result.migrated++;
+    }
+  });
+  return result;
+}
+
+// src/cli/upgrade/migrations/plugin-sql.ts
+var REQUIRED_SQL_DATABASE_URL_MESSAGE2 = "Junior SQL database URL is required for plugin schema migration. Set JUNIOR_DATABASE_URL or DATABASE_URL.";
+function requirePluginSqlDatabaseUrl(context) {
+  const databaseUrl = context.sqlDatabaseUrl ?? getChatConfig().sql.databaseUrl;
+  if (!databaseUrl) {
+    throw new Error(REQUIRED_SQL_DATABASE_URL_MESSAGE2);
+  }
+  return databaseUrl;
+}
+async function migratePluginsToSql(context) {
+  const databaseUrl = requirePluginSqlDatabaseUrl(context);
+  const { pluginCatalogConfig } = await resolveUpgradePlugins(context);
+  const previousConfig = setPluginCatalogConfig(pluginCatalogConfig);
+  const executor = createJuniorSqlExecutor({
+    connectionString: databaseUrl,
+    driver: context.sqlDriver ?? getChatConfig().sql.driver
+  });
+  try {
+    const migrations = getPluginMigrationRoots().flatMap(
+      (root) => readPluginMigrations(root)
+    );
+    const result = await migratePluginSchemas(executor, migrations);
+    return {
+      existing: result.existing,
+      migrated: result.migrated,
+      missing: 0,
+      scanned: result.scanned
+    };
+  } finally {
+    setPluginCatalogConfig(previousConfig);
+    await executor.close();
+  }
+}
+var sqlPluginMigration = {
+  name: "migrate-plugin-sql",
+  run: migratePluginsToSql
+};
+
 // src/cli/upgrade/migrations/redis-conversation-state.ts
 var CONVERSATION_PREFIX = "junior:conversation";
 var CONVERSATION_SCHEMA_VERSION = 1;
@@ -624,10 +950,34 @@ var redisConversationStateMigration = {
 var DEFAULT_IO = {
   info: console.log
 };
+var localPluginLoader = createJiti(import.meta.url, { moduleCache: false });
 var MIGRATIONS = [
   redisConversationStateMigration,
-  sqlConversationMigration
+  sqlConversationMigration,
+  sqlPluginMigration,
+  pluginStorageMigration
 ];
+function isMissingVirtualConfig(error) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  const code = error.code;
+  return (code === "ERR_PACKAGE_IMPORT_NOT_DEFINED" || code === "ERR_MODULE_NOT_FOUND" || code === "MODULE_NOT_FOUND") && error.message.includes("#junior/config");
+}
+async function resolveUpgradePluginSet() {
+  try {
+    const mod = await import("#junior/config");
+    return mod.pluginSet;
+  } catch (error) {
+    if (!isMissingVirtualConfig(error)) {
+      throw error;
+    }
+  }
+  return await loadAppPluginSet(
+    process.cwd(),
+    async (moduleRef) => localPluginLoader.import(moduleRef.importPath)
+  );
+}
 function formatMigrationResult(result) {
   const fields = [
     `scanned=${result.scanned}`,
@@ -641,29 +991,38 @@ function formatMigrationResult(result) {
   return fields.join(" ");
 }
 async function runUpgradeMigrations(context) {
-  requireConversationSqlDatabaseUrl(context);
+  const plugins = await resolveUpgradePlugins(context);
+  const migrationContext = { ...context, ...plugins };
+  migrationContext.sqlDatabaseUrl ??= requireConversationSqlDatabaseUrl(migrationContext);
   const results = [];
   for (const migration of MIGRATIONS) {
-    context.io.info(`Running migration ${migration.name}...`);
-    const result = await migration.run(context);
-    context.io.info(
+    migrationContext.io.info(`Running migration ${migration.name}...`);
+    const result = await migration.run(migrationContext);
+    migrationContext.io.info(
       `Finished migration ${migration.name}: ${formatMigrationResult(result)}`
     );
     results.push(result);
   }
   return results;
 }
-async function runUpgrade(io = DEFAULT_IO) {
+async function runUpgrade(io = DEFAULT_IO, options = {}) {
   try {
     const { redisStateAdapter, stateAdapter } = await getConnectedStateContext();
+    const pluginSet = options.pluginSet === void 0 ? await resolveUpgradePluginSet() : options.pluginSet ?? void 0;
     io.info("Running Junior upgrade migrations...");
-    await runUpgradeMigrations({ io, redisStateAdapter, stateAdapter });
+    await runUpgradeMigrations({
+      io,
+      pluginSet,
+      redisStateAdapter,
+      stateAdapter
+    });
     io.info("Junior upgrade complete.");
   } finally {
     await disconnectStateAdapter();
   }
 }
 export {
+  resolveUpgradePluginSet,
   runUpgrade,
   runUpgradeMigrations
 };

package/dist/db-7A7PFRGL.js

@@ -0,0 +1,17 @@
+import {
+  closeDb,
+  getConversationStore,
+  getDb
+} from "./chunk-NYKJ3KON.js";
+import "./chunk-Q6XFTRV5.js";
+import "./chunk-T77LUIX3.js";
+import "./chunk-VALUBQ7R.js";
+import "./chunk-EJN6G5A2.js";
+import "./chunk-OJ53FYVG.js";
+import "./chunk-ST6YNAXG.js";
+import "./chunk-MLKGABMK.js";
+export {
+  closeDb,
+  getConversationStore,
+  getDb
+};

package/dist/deployment.d.ts

@@ -1,6 +1,7 @@
 export declare const JUNIOR_HEARTBEAT_ROUTE = "/api/internal/heartbeat";
 export declare const JUNIOR_HEARTBEAT_CRON_SCHEDULE = "* * * * *";
 export declare const JUNIOR_CONVERSATION_WORK_CALLBACK_ROUTE = "/api/internal/agent/continue";
+export declare const JUNIOR_PLUGIN_TASK_CALLBACK_ROUTE = "/api/internal/plugin/tasks";
 export declare const LEGACY_JUNIOR_CONVERSATION_WORK_FUNCTION = "api/internal/agent/continue.ts";
 /** Resolve the deployment version used for release and telemetry correlation. */
 export declare function getDeploymentServiceVersion(): string | undefined;

package/dist/handlers/sandbox-egress-route.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Route authenticated sandbox egress proxy traffic before ordinary app routes.
+ */
+export declare function handleSandboxEgressRoute(request: Request, tracePropagationDomains: string[], next: () => Promise<void>): Promise<Response | void>;

package/dist/handlers/slack-webhook.d.ts

@@ -0,0 +1,4 @@
+import { type SlackWebhookServices } from "@/chat/ingress/slack-webhook";
+import type { WaitUntilFn } from "@/handlers/types";
+/** Handle the production Slack webhook route. */
+export declare function POST(request: Request, waitUntil: WaitUntilFn, services: SlackWebhookServices): Promise<Response>;

package/dist/handlers/webhooks.d.ts

@@ -1,19 +1,12 @@
 import type { SlackAdapter } from "@chat-adapter/slack";
-import { type SlackWebhookServices } from "@/chat/ingress/slack-webhook";
 import { JuniorChat } from "@/chat/ingress/junior-chat";
 import type { WaitUntilFn } from "@/handlers/types";
-type LegacyChatSdkBot = JuniorChat<{
+type ChatSdkBot = JuniorChat<{
     slack: SlackAdapter;
 }>;
-/**
- * Handles `POST /api/webhooks/:platform`.
- *
- * Slack production ingress persists messages into the durable conversation
- * mailbox and wakes the queue worker. The optional `legacyBot` parameter is
- * kept for integration tests that still exercise Chat SDK fixtures directly.
- * The optional `services` parameter carries app-scoped runtime services.
- */
-export declare function handlePlatformWebhook(request: Request, platform: string, waitUntil: WaitUntilFn, legacyBot?: LegacyChatSdkBot, services?: SlackWebhookServices): Promise<Response>;
-/** Handle a platform webhook request from the app route. */
-export declare function POST(request: Request, platform: string, waitUntil: WaitUntilFn, services?: SlackWebhookServices): Promise<Response>;
+type WebhookRunner = () => Promise<Response>;
+/** Run a platform webhook with shared request tracing and error logging. */
+export declare function handleWebhookRequest(request: Request, platform: string, run: WebhookRunner): Promise<Response>;
+/** Handle a Chat SDK webhook fixture through the shared webhook wrapper. */
+export declare function handleChatSdkPlatformWebhook(request: Request, platform: string, waitUntil: WaitUntilFn, chat: ChatSdkBot): Promise<Response>;
 export {};