@abtnode/core 1.17.8-beta-20260109-075740-5f484e08 → 1.17.8-beta-20260111-112953-aed5ff39

package/lib/blocklet/manager/disk/config-manager.js

@@ -0,0 +1,191 @@
+const pick = require('lodash/pick');
+const defaultsDeep = require('lodash/defaultsDeep');
+const logger = require('@abtnode/logger')('@abtnode/core:blocklet:manager:config');
+const { getBlockletInfo } = require('@blocklet/meta/lib/info');
+const { CustomError } = require('@blocklet/error');
+const { sendToUser } = require('@blocklet/sdk/lib/util/send-notification');
+const { emailConfigSchema } = require('@abtnode/auth/lib/email');
+const { BlockletEvents, BlockletInternalEvents } = require('@blocklet/constant');
+
+const states = require('../../../states');
+const { blockletThemeSchema } = require('../../../validators/theme');
+
+/**
+ * Config navigations
+ * @param {Object} manager - BlockletManager instance
+ * @param {Object} params
+ * @param {Object} context
+ * @returns {Promise<Object>}
+ */
+async function configNavigations(manager, { did, navigations = [] }, context) {
+  if (!Array.isArray(navigations)) {
+    throw new Error('navigations is not an array');
+  }
+  await states.blockletExtras.setSettings(did, { navigations });
+
+  const newState = await manager.getBlocklet(did);
+  manager.emit(BlockletInternalEvents.appSettingChanged, { appDid: did });
+  manager.emit(BlockletEvents.updated, { ...newState, context });
+  return newState;
+}
+
+/**
+ * Config theme
+ * @param {Object} manager - BlockletManager instance
+ * @param {Object} params
+ * @param {Object} context
+ * @returns {Promise<Object>}
+ */
+async function configTheme(manager, { did, theme = {} }, context) {
+  const { error, value } = blockletThemeSchema.validate(theme);
+  if (error) {
+    throw new Error(error.message);
+  }
+
+  const currentSettings = await states.blockletExtras.getSettings(did);
+  const currentTheme = currentSettings.theme || {};
+
+  if (value.concepts && currentTheme.meta?.locked) {
+    throw new CustomError(403, 'Theme is locked and cannot be modified');
+  }
+
+  const updatedTheme = { ...currentTheme, ...value };
+  await states.blockletExtras.setSettings(did, { theme: updatedTheme });
+
+  const newState = await manager.getBlocklet(did);
+  manager.emit(BlockletInternalEvents.appSettingChanged, { appDid: did });
+  manager.emit(BlockletEvents.updated, { ...newState, context });
+  manager.emit(BlockletEvents.configTheme, { args: { did, theme }, result: newState.settings.theme, context });
+  return newState;
+}
+
+/**
+ * Config authentication
+ * @param {Object} manager - BlockletManager instance
+ * @param {Object} params
+ * @param {Object} context
+ * @returns {Promise<Object>}
+ */
+async function configAuthentication(manager, { did, authentication = {} }, context) {
+  const oldConfig = await states.blockletExtras.getSettings(did, 'authentication', {});
+  const parsedData = JSON.parse(authentication);
+  const mergeConfig = defaultsDeep(parsedData, oldConfig);
+  await states.blockletExtras.setSettings(did, { authentication: mergeConfig });
+  const newState = await manager.getBlocklet(did);
+  manager.emit(BlockletInternalEvents.appSettingChanged, { appDid: did });
+  manager.emit(BlockletEvents.updated, { ...newState, context });
+  return newState;
+}
+
+/**
+ * Config DID connect
+ * @param {Object} manager - BlockletManager instance
+ * @param {Object} params
+ * @param {Object} context
+ * @returns {Promise<Object>}
+ */
+async function configDidConnect(manager, { did, didConnect = {} }, context) {
+  const oldConfig = await states.blockletExtras.getSettings(did, 'didConnect', {});
+  const parsedData = JSON.parse(didConnect);
+  const mergeConfig = defaultsDeep(parsedData, oldConfig);
+  await states.blockletExtras.setSettings(did, { didConnect: mergeConfig });
+  const newState = await manager.getBlocklet(did);
+  manager.emit(BlockletInternalEvents.appSettingChanged, { appDid: did });
+  manager.emit(BlockletEvents.updated, { ...newState, context });
+  return newState;
+}
+
+/**
+ * Config notification
+ * @param {Object} manager - BlockletManager instance
+ * @param {Object} params
+ * @param {Object} context
+ * @returns {Promise<Object>}
+ */
+async function configNotification(manager, { did, notification = {} }, context) {
+  let newConfig = {};
+  try {
+    newConfig = JSON.parse(notification);
+  } catch (error) {
+    logger.error('parse configNotification error', { error });
+    throw new Error('parse configNotification error');
+  }
+  const enabled = newConfig?.email?.enabled;
+  if (enabled) {
+    const { error } = emailConfigSchema.validate(
+      pick(newConfig?.email || {}, ['from', 'host', 'port', 'user', 'password', 'secure'])
+    );
+    if (error) {
+      logger.error('configNotification validate error', { error });
+      throw new Error(error.message);
+    }
+  }
+  const oldConfig = await states.blockletExtras.getSettings(did, 'notification', {});
+  const mergeConfig = { ...oldConfig, ...newConfig };
+  await states.blockletExtras.setSettings(did, { notification: mergeConfig });
+  const newState = await manager.getBlocklet(did);
+  manager.emit(BlockletInternalEvents.appSettingChanged, { appDid: did });
+  manager.emit(BlockletEvents.updated, { ...newState, context });
+  return newState;
+}
+
+/**
+ * Send test email
+ * @param {Object} manager - BlockletManager instance
+ * @param {Object} params
+ * @returns {Promise<Object>}
+ */
+async function sendEmail(manager, { did, receiver, email }) {
+  const blocklet = await manager.getBlocklet(did);
+  const nodeInfo = await states.node.read();
+  const { wallet } = getBlockletInfo(blocklet, nodeInfo.sk);
+
+  const [result] = await sendToUser(
+    receiver,
+    JSON.parse(email),
+    {
+      appDid: wallet.address,
+      appSk: wallet.secretKey,
+    },
+    undefined,
+    'send-to-mail'
+  );
+  if (result && result.status === 'fulfilled') {
+    return result.value;
+  }
+  throw new Error(result?.reason || 'failed to send email');
+}
+
+/**
+ * Send push notification
+ * @param {Object} manager - BlockletManager instance
+ * @param {Object} params
+ * @returns {Promise<Object>}
+ */
+async function sendPush(manager, { did, receiver, notification }) {
+  const blocklet = await manager.getBlocklet(did);
+  const nodeInfo = await states.node.read();
+  const { wallet } = getBlockletInfo(blocklet, nodeInfo.sk);
+
+  const result = await sendToUser(
+    receiver,
+    JSON.parse(notification),
+    {
+      appDid: wallet.address,
+      appSk: wallet.secretKey,
+    },
+    undefined,
+    'send-to-push-kit'
+  );
+  return result;
+}
+
+module.exports = {
+  configNavigations,
+  configTheme,
+  configAuthentication,
+  configDidConnect,
+  configNotification,
+  sendEmail,
+  sendPush,
+};

package/lib/blocklet/manager/disk/controller-manager.js

@@ -0,0 +1,64 @@
+const isEmpty = require('lodash/isEmpty');
+const logger = require('@abtnode/logger')('@abtnode/core:blocklet:manager:controller');
+const { BLOCKLET_CONTROLLER_STATUS, SUSPENDED_REASON } = require('@blocklet/constant');
+
+const states = require('../../../states');
+const launcher = require('../../../util/launcher');
+
+/**
+ * Check controller status
+ * @param {Object} manager - BlockletManager instance
+ * @param {Object} blocklet - Blocklet
+ * @param {string} action - Action name
+ * @returns {Promise<void>}
+ */
+async function checkControllerStatus(manager, blocklet, action) {
+  if (isEmpty(blocklet.controller)) {
+    return;
+  }
+
+  const isExpired = await launcher.isBlockletExpired(blocklet.meta.did, blocklet.controller);
+
+  if (isExpired) {
+    if (blocklet.controller.status?.value !== BLOCKLET_CONTROLLER_STATUS.suspended) {
+      await states.blockletExtras.updateByDid(blocklet.meta.did, {
+        controller: {
+          ...blocklet.controller,
+          status: {
+            value: BLOCKLET_CONTROLLER_STATUS.suspended,
+            reason: SUSPENDED_REASON.expired,
+          },
+        },
+      });
+      logger.info('update blocklet controller status to suspended', {
+        did: blocklet.meta.did,
+        nftId: blocklet.controller?.nftId,
+      });
+    }
+    logger.error(`try to ${action} an expired blocklet`, {
+      did: blocklet.meta.did,
+      nftId: blocklet.controller?.nftId,
+    });
+    throw new Error(`Can not ${action} an expired blocklet`);
+  }
+
+  if (
+    blocklet.controller.status?.value === BLOCKLET_CONTROLLER_STATUS.suspended &&
+    blocklet.controller.status?.reason === SUSPENDED_REASON.expired
+  ) {
+    // 如果是因为过期被暂停的，续期后, 并且不影响启动
+    await states.blockletExtras.updateByDid(blocklet.meta.did, {
+      controller: {
+        ...blocklet.controller,
+        status: {
+          value: BLOCKLET_CONTROLLER_STATUS.normal,
+          reason: '',
+        },
+      },
+    });
+  }
+}
+
+module.exports = {
+  checkControllerStatus,
+};

package/lib/blocklet/manager/disk/delete-reset-manager.js

@@ -0,0 +1,328 @@
+/* eslint-disable no-await-in-loop */
+const fs = require('fs-extra');
+const path = require('path');
+const pick = require('lodash/pick');
+const logger = require('@abtnode/logger')('@abtnode/core:blocklet:manager:delete-reset');
+const { BlockletEvents, BlockletStatus } = require('@blocklet/constant');
+const {
+  forEachBlockletSync,
+  isInProgress,
+  getDisplayName,
+  isExternalBlocklet,
+  isDeletableBlocklet,
+} = require('@blocklet/meta/lib/util');
+
+const { APP_CONFIG_DIR, COMPONENT_ENV_FILE_NAME } = require('@blocklet/constant');
+const states = require('../../../states');
+const hooks = require('../../hooks');
+const {
+  deleteBlockletProcess,
+  getRuntimeEnvironments,
+  getHookArgs,
+  removeAppConfigsFromComponent,
+} = require('../../../util/blocklet');
+const checkNeedRunDocker = require('../../../util/docker/check-need-run-docker');
+const { dockerExec } = require('../../../util/docker/docker-exec');
+const { dockerExecChown } = require('../../../util/docker/docker-exec-chown');
+const checkDockerRunHistory = require('../../../util/docker/check-docker-run-history');
+const parseDockerName = require('../../../util/docker/parse-docker-name');
+const { removeDockerNetwork } = require('../../../util/docker/docker-network');
+
+/**
+ * Safely remove directories
+ */
+async function _safeRemoveDir(manager, did, childDid, inputDirs) {
+  const dirs = inputDirs.filter(Boolean);
+  try {
+    for (const dir of dirs) {
+      fs.removeSync(dir);
+      logger.info(`removed blocklet ${did} ${childDid}: ${dir}`);
+    }
+  } catch (error) {
+    const nodeInfo = await states.node.read();
+    // 如果删除因为权限问题失败，尝试用 docker 用户去调整用户组为宿主机当前用户
+    if (checkDockerRunHistory(nodeInfo) && error?.message?.includes('EACCES')) {
+      await dockerExecChown({ name: `${did}-${childDid}-remove-catch`, dirs, force: true });
+      for (const dir of dirs) {
+        fs.removeSync(dir);
+        logger.info(`removed blocklet ${did} ${childDid}: ${dir}`);
+      }
+    } else {
+      throw error;
+    }
+  }
+}
+
+/**
+ * Delete blocklet
+ */
+async function deleteBlocklet(manager, { did, keepData, keepLogsDir, keepConfigs, sessionId }, context) {
+  logger.info('delete blocklet', { did, keepData, sessionId });
+
+  const blocklet = await manager.getBlocklet(did);
+
+  try {
+    if (isDeletableBlocklet(blocklet) === false) {
+      throw new Error('Blocklet is protected from accidental deletion');
+    }
+
+    const nodeInfo = await states.node.read();
+    const nodeEnvironments = await states.node.getEnvironments(nodeInfo);
+    await deleteBlockletProcess(blocklet, {
+      preDelete: async (b, { ancestors }) => {
+        const needRunDocker = await checkNeedRunDocker(
+          b.meta,
+          getRuntimeEnvironments(b, nodeEnvironments, ancestors),
+          nodeInfo,
+          isExternalBlocklet(blocklet)
+        );
+        const hookArgs = getHookArgs(b);
+        const nextEnv = getRuntimeEnvironments(b, nodeEnvironments, ancestors);
+        if (needRunDocker) {
+          if (b.meta.scripts?.preUninstall) {
+            await dockerExec({
+              blocklet,
+              meta: b.meta,
+              env: nextEnv,
+              script: b.meta.scripts.preUninstall,
+              hookName: 'preUninstall',
+              nodeInfo,
+              retry: 0,
+              ...hookArgs,
+            });
+          }
+          return null;
+        }
+        return hooks.preUninstall(b.meta.title, {
+          appDir: b.env.appDir,
+          hooks: Object.assign(b.meta.hooks || {}, b.meta.scripts || {}),
+          env: nextEnv,
+          did, // root blocklet did
+          notification: states.notification,
+          context,
+          exitOnError: false,
+          ...hookArgs,
+        });
+      },
+    });
+
+    const doc = await manager._deleteBlocklet({ did, keepData, keepLogsDir, keepConfigs }, context);
+    manager._createNotification(
+      doc.meta.did,
+      {
+        title: 'Blocklet Deleted',
+        description: `Blocklet ${getDisplayName(blocklet)} is deleted.`,
+        entityType: 'blocklet',
+        entityId: doc.meta.did,
+        severity: 'success',
+      },
+      {
+        skipGetBlocklet: true,
+      }
+    );
+    await removeDockerNetwork(parseDockerName(did, 'docker-network'));
+    return doc;
+  } catch (error) {
+    // If we installed a corrupted blocklet accidentally, just cleanup the disk and state db
+    logger.error('blocklet delete failed, will delete again', { did, error });
+    const doc = await manager._deleteBlocklet({ did, keepData, keepLogsDir, keepConfigs }, context);
+    await removeDockerNetwork(parseDockerName(did, 'docker-network'));
+
+    manager._createNotification(
+      doc.meta.did,
+      {
+        title: 'Blocklet Deleted',
+        description: `Blocklet ${getDisplayName(blocklet)} is deleted.`,
+        entityType: 'blocklet',
+        entityId: doc.meta.did,
+        severity: 'success',
+      },
+      {
+        skipGetBlocklet: true,
+      }
+    );
+
+    return doc;
+  }
+}
+
+/**
+ * Reset blocklet
+ */
+async function reset(manager, { did, childDid }, context = {}) {
+  logger.info('reset blocklet', { did, childDid });
+
+  const blocklet = await manager.getBlocklet(did);
+
+  if (!childDid) {
+    if (isInProgress(blocklet.status || blocklet.status === BlockletStatus.running)) {
+      throw new Error('Cannot reset when blocklet is in progress');
+    }
+
+    try {
+      await manager.deleteProcess({ did }, context);
+    } catch {
+      // do nothing
+    }
+
+    // Cleanup disk storage
+    const { cacheDir, logsDir, dataDir } = blocklet.env;
+    await _safeRemoveDir(manager, did, blocklet.meta.did, [cacheDir, dataDir, logsDir]);
+
+    // Reset config in db
+    await manager._resetExtras(blocklet.meta.did);
+    await manager._updateBlockletEnvironment(did);
+    await manager.resetSiteByDid(did, context);
+  } else {
+    const child = blocklet.children.find((x) => x.meta.did === childDid);
+
+    if (!child) {
+      throw new Error('Child does not exist');
+    }
+
+    if (isInProgress(child.status || child.status === BlockletStatus.running)) {
+      throw new Error('Cannot reset when component is in progress');
+    }
+
+    try {
+      await manager.deleteProcess({ did, componentDids: [child.meta.did] }, context);
+    } catch {
+      // do nothing
+    }
+
+    // Cleanup disk storage
+    const { cacheDir, logsDir, dataDir } = child.env;
+    await _safeRemoveDir(manager, did, child.meta.did, [cacheDir, dataDir, logsDir]);
+
+    // Reset config in db
+    await states.blockletExtras.delConfigs([blocklet.meta.did, child.meta.did]);
+    await manager._setConfigsFromMeta(blocklet.meta.did, child.meta.did);
+    await manager._updateBlockletEnvironment(did);
+  }
+
+  logger.info('blocklet reset', { did, childDid });
+  return blocklet;
+}
+
+/**
+ * Delete component
+ */
+async function deleteComponent(manager, { did, rootDid, keepData, keepState, sessionId }, context) {
+  logger.info('delete blocklet component', { did, rootDid, keepData, keepState, sessionId });
+
+  const nodeInfo = await states.node.read();
+  if (checkDockerRunHistory(nodeInfo)) {
+    await dockerExecChown({
+      name: `${did}-${rootDid}-deleteComponent`,
+      dirs: [path.join(process.env.ABT_NODE_DATA_DIR, 'data', rootDid)],
+      force: true,
+    });
+  }
+  const app = await manager.getBlocklet(rootDid);
+
+  const child = app.children.find((x) => x.meta.did === did);
+  if (!child) {
+    throw new Error('Component does not exist');
+  }
+
+  // delete state
+  const doc = await states.blocklet.getBlocklet(rootDid);
+  doc.children = doc.children.filter((x) => x.meta.did !== did);
+  const deletedChildren = await states.blockletExtras.getSettings(did, 'children', []);
+  if (keepData !== false && keepState !== false) {
+    deletedChildren.push({
+      meta: pick(child.meta, ['did', 'name', 'bundleDid', 'bundleName', 'version', 'title', 'description']),
+      mountPoint: child.mountPoint,
+      status: BlockletStatus.deleted,
+      deletedAt: new Date(),
+    });
+  }
+
+  await states.blocklet.updateBlocklet(rootDid, doc);
+  states.blockletExtras.setSettings(doc.meta.did, { children: deletedChildren });
+
+  // delete process
+  try {
+    const skippedProcessIds = [];
+    forEachBlockletSync(app, (b) => {
+      if (!b.env.id.startsWith(child.env.id)) {
+        skippedProcessIds.push(b.env.processId);
+      }
+    });
+    await deleteBlockletProcess(app, { skippedProcessIds });
+    logger.info('delete blocklet process for deleting component', { did, rootDid });
+  } catch (err) {
+    logger.error('delete blocklet process for deleting component', { did, rootDid, error: err });
+  }
+
+  // delete storage
+  const { cacheDir, logsDir, dataDir } = child.env;
+  await _safeRemoveDir(
+    manager,
+    rootDid,
+    child.meta.did,
+    [
+      cacheDir,
+      logsDir,
+      path.join(app.env.dataDir, APP_CONFIG_DIR, child.meta.did, COMPONENT_ENV_FILE_NAME),
+      keepData === false ? dataDir : null,
+    ].filter(Boolean)
+  );
+  if (keepData === false) {
+    const componentEnvs = await states.blockletExtras.getConfigs([app.meta.did, child.meta.did]);
+    await states.blockletExtras.delConfigs([app.meta.did, child.meta.did]);
+
+    // remove app configs if no component use it
+    const tmpApp = await manager.getBlocklet(rootDid);
+    await removeAppConfigsFromComponent(componentEnvs, tmpApp, states.blockletExtras);
+  }
+  const newBlocklet = await manager.getBlocklet(rootDid);
+
+  if (newBlocklet.controller) {
+    const componentDids = [did];
+    const eventType = 'uninstall';
+
+    manager.reportComponentUsageQueue.push({
+      entity: 'blocklet',
+      action: 'reportComponentUsage',
+      did: newBlocklet.meta.did,
+      time: new Date().toISOString(),
+      componentDids,
+      eventType,
+      context,
+    });
+
+    logger.info('pushed reporting uninstall components event job to queue', {
+      did: newBlocklet.meta.did,
+      componentDids,
+      eventType,
+    });
+  }
+
+  await manager._updateDependents(rootDid);
+
+  // support edge case
+  if (newBlocklet.children.length === 0) {
+    await states.blocklet.setBlockletStatus(newBlocklet.meta.did, BlockletStatus.stopped);
+    await removeDockerNetwork(parseDockerName(app.meta.did, 'docker-network'));
+  }
+
+  manager.emit(BlockletEvents.upgraded, { blocklet: newBlocklet, context: { ...context, createAuditLog: false } }); // trigger router refresh
+
+  manager._createNotification(newBlocklet.meta.did, {
+    title: 'Component delete succeed',
+    description: `${child.meta.title} is successfully deleted for ${getDisplayName(newBlocklet)}.`,
+    entityType: 'blocklet',
+    entityId: newBlocklet.meta.did,
+    severity: 'success',
+  });
+
+  return newBlocklet;
+}
+
+module.exports = {
+  _safeRemoveDir,
+  delete: deleteBlocklet,
+  reset,
+  deleteComponent,
+};

package/lib/blocklet/manager/disk/download-manager.js

@@ -0,0 +1,96 @@
+const logger = require('@abtnode/logger')('@abtnode/core:blocklet:manager:download');
+const { BlockletStatus, fromBlockletStatus } = require('@blocklet/constant');
+const { forEachComponentV2Sync } = require('@blocklet/meta/lib/util');
+
+const states = require('../../../states');
+
+/**
+ * Cancel download
+ * @param {Object} manager - BlockletManager instance
+ * @param {Object} params
+ * @param {string} params.did - Blocklet DID
+ * @param {Object} statusLock - Status lock
+ * @returns {Promise<Object>}
+ */
+async function cancelDownload(manager, { did: inputDid }, statusLock) {
+  await statusLock.acquire('cancel-download');
+  try {
+    const blocklet = await states.blocklet.getBlocklet(inputDid);
+    if (!blocklet) {
+      throw new Error(`Can not cancel download for non-exist blocklet in database. did: ${inputDid}`);
+    }
+
+    const { name, did, version } = blocklet.meta;
+
+    if (
+      ![BlockletStatus.downloading, BlockletStatus.waiting].includes(blocklet.greenStatus) &&
+      ![BlockletStatus.downloading, BlockletStatus.waiting].includes(blocklet.status)
+    ) {
+      throw new Error(`Can not cancel blocklet that status is ${fromBlockletStatus(blocklet.status)}`);
+    }
+
+    const job = await manager.installQueue.get(did);
+
+    // cancel job
+    if (blocklet.greenStatus === BlockletStatus.downloading || blocklet.status === BlockletStatus.downloading) {
+      try {
+        await manager.blockletDownloader.cancelDownload(blocklet.meta.did);
+      } catch (error) {
+        logger.error('failed to exec blockletDownloader.download', { did: blocklet.meta.did, error });
+      }
+    } else if (blocklet.greenStatus === BlockletStatus.waiting || blocklet.status === BlockletStatus.waiting) {
+      try {
+        await manager.installQueue.cancel(blocklet.meta.did);
+      } catch (error) {
+        logger.error('failed to cancel waiting', { did: blocklet.meta.did, error });
+      }
+    }
+
+    // rollback
+    if (job) {
+      const { postAction, oldBlocklet } = job;
+      await manager._rollback(postAction, did, oldBlocklet);
+    } else {
+      const data = await manager._rollbackCache.restore({ did });
+      if (data) {
+        const { action, oldBlocklet } = data;
+        await manager._rollback(action, did, oldBlocklet);
+        await manager._rollbackCache.remove({ did: inputDid });
+      } else {
+        throw new Error(`Cannot find rollback data in queue or backup file of blocklet ${inputDid}`);
+      }
+    }
+
+    logger.info('cancel download blocklet', { did, name, version, status: fromBlockletStatus(blocklet.status) });
+
+    return blocklet;
+  } catch (error) {
+    try {
+      // fallback blocklet status to error
+      const blocklet = await states.blocklet.getBlocklet(inputDid);
+      if (blocklet) {
+        const componentDids = [];
+        forEachComponentV2Sync(blocklet, (x) => {
+          if (
+            [BlockletStatus.waiting, BlockletStatus.downloading].includes(x.status) ||
+            [BlockletStatus.waiting, BlockletStatus.downloading].includes(x.greenStatus)
+          ) {
+            componentDids.push(x.meta.did);
+          }
+        });
+
+        await states.blocklet.setBlockletStatus(blocklet.meta.did, BlockletStatus.error, { componentDids });
+      }
+    } catch (err) {
+      logger.error('Failed to fallback blocklet status to error on cancelDownload', { error });
+    }
+
+    throw error;
+  } finally {
+    await statusLock.releaseLock('cancel-download');
+  }
+}
+
+module.exports = {
+  cancelDownload,
+};