@arcfold/dsh-method-ui 0.0.0-stage → 0.4.0

package/src/model-host.mjs

@@ -0,0 +1,56 @@
+import { TypertRemoteService, RemoteError } from '@deepseek-ai/dsh-typert-protocol';
+const SERVICE = 'arcfoldModelWeb', NAMESPACE = 'arcfoldModels';
+const fail = (code, message) => { throw new RemoteError(code, message, {}); };
+async function runModelRequest({ models, connection }, method, request, signal, peer) {
+  if (!peer || peer !== connection.browserPeer || peer.principal?.kind !== 'owner' ||
+      peer.interactions !== 'answer' || peer.signal?.aborted !== false || signal?.aborted !== false)
+    fail('trusted_browser_required', '此操作只接受当前已认证网页的请求。');
+  if (!models) fail('model_settings_unavailable', '当前部署尚未接通模型设置。');
+  if (!request || typeof request !== 'object' || Array.isArray(request)) fail('invalid_model_request', '设置请求格式无效。');
+  if (method === 'read') {
+    if (Object.keys(request).length) fail('invalid_model_request', '读取模型设置不接受会话或其他参数。');
+    const result = await models.read(); signal.throwIfAborted(); return result;
+  }
+  if (method === 'saveLearning') {
+    const fields = ['expectedRevision', 'provider', 'model', 'reasoningEffort'];
+    if (Object.keys(request).sort().join() !== fields.sort().join() || !Number.isSafeInteger(request.expectedRevision) || request.expectedRevision < 1 ||
+        ['provider', 'model', 'reasoningEffort'].some(key => typeof request[key] !== 'string' || !request[key] || request[key].length > 256))
+      fail('invalid_model_request', '只接受当前版本和完整的学习模型选择。');
+    // A disconnected browser must not leave an awaited catalog read able to
+    // commit its setting. The service invokes this again just before saving.
+    return models.saveLearning(request, () => {
+      signal.throwIfAborted();
+      if (peer !== connection.browserPeer || peer.signal.aborted || peer.principal?.kind !== 'owner' || peer.interactions !== 'answer') fail('trusted_browser_required', '网页连接已变化，请刷新设置。');
+    });
+  }
+  fail('model_endpoint_not_found', '不存在的模型设置操作。');
+}
+const knownErrors = {
+  revision_conflict: '学习设置已在其他页面修改，请刷新后重新选择。',
+  learning_configuration_unavailable: '当前部署无法使用所选的学习模型，请检查设置。',
+  invalid_learning_defaults: '请提交完整的模型选择和当前设置版本。',
+  ARCFOLD_RUNTIME_RESTART_REQUIRED: '运行配置已变化，请通过启动器重新启动后再保存。',
+  ARCFOLD_RUNTIME_NOT_READY: '运行环境尚未就绪，请稍后刷新。',
+};
+export async function dispatchModelRequest(...args) {
+  try { return await runModelRequest(...args); }
+  catch (error) {
+    if (error instanceof RemoteError) throw error;
+    const code = Object.hasOwn(knownErrors, error?.code) ? error.code : 'model_settings_failed';
+    throw new RemoteError(code, knownErrors[code] ?? '模型设置未完成，请刷新查看实际保存结果。', {});
+  }
+}
+class ModelWeb extends TypertRemoteService {
+  constructor(ctx) { super(ctx, SERVICE, { namespace: NAMESPACE }); }
+  dispatch(method, request) {
+    const { signal, peer } = this.ctx.invocation ?? {};
+    return dispatchModelRequest({ models: this.ctx.get('arcfoldRuntimeModels'), connection: this.ctx.connection }, method, request, signal, peer);
+  }
+  read(request) { return this.dispatch('read', request); }
+  saveLearning(request) { return this.dispatch('saveLearning', request); }
+}
+export const modelInvocations = ['read', 'saveLearning'].map(method => ({
+  id: `@arcfold/dsh-method-ui#${NAMESPACE}/${method}`, service: SERVICE, namespace: NAMESPACE, method,
+  invocation: { kind: 'direct' },
+  parameters: [{ name: 'request', wire: 'request', source: 'json', codec: { mode: 'src-json' } }], result: { mode: 'src-json' } }));
+export function installModelWeb(ctx) { return new ModelWeb(ctx); }

package/src/model-settings-locales.mjs

@@ -0,0 +1,91 @@
+export const modelsZh = {
+  modelsPhaseReady: "已就绪",
+  modelsPhaseStarting: "启动中",
+  modelsPhaseRestart: "需重启",
+  modelsPhaseFailed: "启动失败",
+  modelsPhaseClosed: "已停止",
+  modelsReasonNoModel: "尚未选择模型。",
+  modelsReasonCredential: "尚未填写所选提供方的凭据。",
+  modelsReasonUnsupported: "所选模型或思考强度不受当前部署支持。",
+  modelsReasonChanged: "设置刚刚变化，请刷新查看。",
+  modelsReasonNotReady: "当前尚未就绪，请稍后刷新。",
+  modelsReasonRestart: "运行配置已变化，请重启后再使用。",
+  modelsReasonUnknown: "暂时无法使用，请刷新查看。",
+  modelsEffortOff: "关闭",
+  modelsEffortLow: "低",
+  modelsEffortMedium: "中",
+  modelsEffortHigh: "高",
+  modelsEffortXHigh: "很高",
+  modelsEffortMax: "最高",
+  modelsEffortOther: "其他",
+  modelsTitle: '模型与学习', modelsRefresh: '刷新状态', modelsLoading: '正在读取设置…',
+  modelsReadFailed: '未能读取当前设置；暂不可保存，请刷新后再试。', modelsUnavailable: '当前不可用',
+  modelsMain: '主会话模型', modelsMainScope: '在会话输入区使用原生模型按钮。更改影响该会话下一次回答，并保存为新会话默认；其他已有会话保留自己的选择。',
+  modelsDefault: '新会话默认', modelsLearn: '回答后的学习', modelsLearnScope: '这里独立选择学习模型。已开始的学习保留原配置；修改只影响之后开始的学习，不重发未知请求。',
+  modelsLearnDisabled: '此部署未启用学习。', modelsNoDefault: '尚无可用的学习默认配置。', modelsProvider: '提供方',
+  modelsModel: '模型', modelsReasoning: '思考强度', modelsChoose: '请选择', modelsSave: '保存学习设置',
+  modelsSaved: '已保存并读回。', modelsSavedUnread: '保存已返回成功，但最新状态未能读回；请刷新确认。',
+  modelsConflict: '设置已变化，未覆盖。已尝试刷新，请查看当前版本后重新选择。',
+  modelsRefused: '保存被拒绝，设置未获确认。请刷新状态后检查可用选项。',
+  modelsUnknown: '未收到明确结果；没有自动重发。请刷新核对后再决定是否重新操作。',
+  modelsBusy: '正在处理…', modelsCredentials: '连接凭据', modelsCredentialScope: '仅写入官方凭据存储，不显示旧密钥。“已配置”不代表已通过服务商验证。这里不会发送模型测试请求。',
+  modelsConfigured: '已配置', modelsNotConfigured: '未配置', modelsCredentialReadFailed: '凭据状态暂不可读。',
+  modelsReadOnly: '当前凭据来源不可写。', modelsCredential: '新密钥', modelsCredentialSave: '保存密钥',
+  modelsCredentialRemove: '移除已存密钥', modelsCredentialCancel: '清空输入', modelsCredentialFailed: '凭据操作未获确认；输入已清空。请刷新状态后重试。',
+  modelsCredentialUnknown: '凭据操作结果未知，输入已清空且未自动重发。请先刷新核对状态。',
+  modelsSource: '来源', modelsNoRoutes: '没有已部署的可用路线。', modelsUsage: '用量与费用',
+  modelsUsageMissing: '当前用量不可读；不按零费用显示。', modelsRequests: '请求数', modelsUnknownCount: '结果未知',
+  modelsSpent: '已结算', modelsReserved: '预留', modelsCeiling: '上限', modelsNoCeiling: '此范围无金额上限',
+  modelsPrompt: '输入 token', modelsCompletion: '输出 token', modelsCached: '缓存输入 token', modelsPending: '待结算',
+  modelsTokensOnly: '这里只记录 token 用量，未提供人民币费用估算。',
+  modelsUsageBoundary: '各范围独立显示；网页用量不与开发预算相加。改变模型设置不修改费用授权。',
+  modelsScopeLimited: '开发研究预算（独立范围）', modelsScopeWeb: 'DeepSeek 网页', modelsScopeOpenai: 'OpenAI 网页',
+  modelsGate: '运行状态', modelsRevision: '设置版本',
+};
+export const modelsEn = {
+  modelsPhaseReady: "Ready",
+  modelsPhaseStarting: "Starting",
+  modelsPhaseRestart: "Restart required",
+  modelsPhaseFailed: "Startup failed",
+  modelsPhaseClosed: "Stopped",
+  modelsReasonNoModel: "No model is selected.",
+  modelsReasonCredential: "Credentials for the selected provider have not been entered.",
+  modelsReasonUnsupported: "The selected model or reasoning effort is not supported by this deployment.",
+  modelsReasonChanged: "Settings just changed. Refresh to see the current selection.",
+  modelsReasonNotReady: "The runtime is not ready. Refresh shortly.",
+  modelsReasonRestart: "Runtime configuration changed. Restart before continuing.",
+  modelsReasonUnknown: "Temporarily unavailable. Refresh to check again.",
+  modelsEffortOff: "Off",
+  modelsEffortLow: "Low",
+  modelsEffortMedium: "Medium",
+  modelsEffortHigh: "High",
+  modelsEffortXHigh: "Very high",
+  modelsEffortMax: "Maximum",
+  modelsEffortOther: "Other",
+  modelsTitle: 'Models and learning', modelsRefresh: 'Refresh status', modelsLoading: 'Loading settings…',
+  modelsReadFailed: 'Settings could not be read. Refresh before saving.', modelsUnavailable: 'Unavailable',
+  modelsMain: 'Conversation model', modelsMainScope: 'Use the native model picker in the conversation input. A change applies to that conversation’s next answer and the default for new conversations; other existing conversations keep their selection.',
+  modelsDefault: 'New conversation default', modelsLearn: 'Learning after an answer', modelsLearnScope: 'Learning has its own model selection. Started learning keeps its original configuration; changes apply only to learning started later and never resend unknown requests.',
+  modelsLearnDisabled: 'Learning is not enabled for this deployment.', modelsNoDefault: 'No learning default is available.',
+  modelsProvider: 'Provider', modelsModel: 'Model', modelsReasoning: 'Reasoning effort', modelsChoose: 'Select',
+  modelsSave: 'Save learning settings', modelsSaved: 'Saved and read back.',
+  modelsSavedUnread: 'Save returned success, but the latest state could not be read. Refresh to confirm.',
+  modelsConflict: 'Settings changed and were not overwritten. A refresh was attempted; review the current version before selecting again.',
+  modelsRefused: 'Save was refused. Refresh and check the available choices.',
+  modelsUnknown: 'No definite result was received. Nothing was retried automatically. Refresh before deciding whether to submit again.',
+  modelsBusy: 'Working…', modelsCredentials: 'Credentials',
+  modelsCredentialScope: 'Write only to the native credential store. Existing keys are never displayed. Configured does not mean verified with the provider; this page makes no model test calls.',
+  modelsConfigured: 'Configured', modelsNotConfigured: 'Not configured', modelsCredentialReadFailed: 'Credential status is unavailable.',
+  modelsReadOnly: 'This credential source is not writable.', modelsCredential: 'New key',
+  modelsCredentialSave: 'Save key', modelsCredentialRemove: 'Remove stored key', modelsCredentialCancel: 'Clear input',
+  modelsCredentialFailed: 'Credential operation was not confirmed. The input was cleared. Refresh before trying again.',
+  modelsCredentialUnknown: 'Credential outcome is unknown. The input was cleared and nothing was retried. Refresh to check status.',
+  modelsSource: 'Source', modelsNoRoutes: 'No supported route is deployed.', modelsUsage: 'Usage and cost',
+  modelsUsageMissing: 'Usage is unavailable; it is not shown as zero.', modelsRequests: 'Requests',
+  modelsUnknownCount: 'Unknown outcomes', modelsSpent: 'Settled', modelsReserved: 'Reserved', modelsCeiling: 'Limit',
+  modelsNoCeiling: 'No monetary limit for this scope', modelsPrompt: 'Input tokens', modelsCompletion: 'Output tokens',
+  modelsCached: 'Cached input tokens', modelsPending: 'Pending', modelsTokensOnly: 'Token usage only. No CNY cost estimate is supplied.',
+  modelsUsageBoundary: 'Scopes are shown separately; web usage is not added to the development budget. Model settings do not change spending authorization.',
+  modelsScopeLimited: 'Development research budget (separate)', modelsScopeWeb: 'DeepSeek web',
+  modelsScopeOpenai: 'OpenAI web', modelsGate: 'Runtime status', modelsRevision: 'Settings revision',
+};

package/src/model-settings-source.mjs

@@ -0,0 +1,119 @@
+// A visible-page read cache. Credentials and mutations never enter its snapshot.
+const PROVIDERS = new Set(['deepseek-official', 'openai']);
+const own = (value, keys) => value && typeof value === 'object' && !Array.isArray(value) &&
+  Object.keys(value).length === keys.length && keys.every(key => Object.hasOwn(value, key));
+const refused = code => ({ status: 'refused', code });
+const remoteCode = code => ['revision_conflict', 'learning_defaults_conflict'].includes(code) ? 'conflict' : 'refused';
+export function deployedRoutes(data) {
+  return (data?.routes || []).filter(route => PROVIDERS.has(route.provider));
+}
+export function validLearningChoice(data, request) {
+  const route = deployedRoutes(data).find(row => row.provider === request.provider);
+  const model = route?.models?.find(row => row.id === request.model);
+  return Boolean(model?.reasoningEfforts?.includes(request.reasoningEffort));
+}
+
+export function createModelSettingsSource({ rpc, subscribeReset }) {
+  let snapshot = { loading: false, data: null, error: null, credentials: {}, credentialError: false };
+  const listeners = new Set();
+  let generation = 0, readController, mutationController, reset, disposed = false, writing = false;
+  const publish = patch => {
+    snapshot = { ...snapshot, ...patch };
+    for (const listener of listeners) listener();
+  };
+  const active = () => !disposed && listeners.size > 0;
+  async function refresh() {
+    if (!active()) return false;
+    readController?.abort();
+    const controller = new AbortController(), current = ++generation;
+    readController = controller;
+    const stillCurrent = () => active() && current === generation && !controller.signal.aborted;
+    publish({ loading: true, error: null });
+    try {
+      const reply = await rpc.call('/api', 'arcfoldModels/read', { args: { request: {} } }, controller.signal);
+      if (reply?.ok !== true) throw new Error('read refused');
+      if (!stillCurrent()) return false;
+      const data = reply.value;
+      const refs = [...new Set(deployedRoutes(data).map(route => route.apiKeyRef))];
+      let credentials = {}, credentialError = false;
+      if (refs.length) {
+        try {
+          const result = await rpc.call('/api', 'credentials/describe', { args: { refs } }, controller.signal);
+          if (result?.ok !== true) throw new Error('credential metadata refused');
+          credentials = Object.fromEntries(refs.map(ref => {
+            const value = result.value?.[ref];
+            return [ref, { configured: value?.configured === true, writable: value?.writable === true,
+              ...(typeof value?.source === 'string' ? { source: value.source } : {}) }];
+          }));
+        } catch { credentialError = true; }
+      }
+      if (!stillCurrent()) return false;
+      publish({ loading: false, data, error: null, credentials, credentialError });
+      return true;
+    } catch {
+      if (stillCurrent()) publish({ loading: false, error: 'read_failed' });
+      return false;
+    }
+  }
+  function stop() {
+    reset?.(); reset = undefined;
+    readController?.abort(); mutationController?.abort(); generation++;
+  }
+  async function mutate(endpoint, args, credential = false) {
+    if (!active() || writing) return refused('unavailable');
+    writing = true;
+    const controller = new AbortController();
+    mutationController = controller;
+    try {
+      const result = await rpc.call('/api', endpoint, { args }, controller.signal);
+      if (result?.ok !== true) {
+        const code = credential ? 'credential_refused' : remoteCode(result?.error?.code);
+        await refresh();
+        return refused(code);
+      }
+      const refreshed = await refresh();
+      return { status: 'saved', refreshed };
+    } catch {
+      // No exception, response details or input value is retained or rethrown.
+      return { status: 'unknown', code: credential ? 'credential_unknown' : 'unknown' };
+    } finally {
+      writing = false;
+      if (mutationController === controller) mutationController = undefined;
+    }
+  }
+  return {
+    getSnapshot: () => snapshot,
+    subscribe(listener) {
+      if (disposed) return () => {};
+      listeners.add(listener);
+      if (listeners.size === 1) {
+        reset = subscribeReset(() => { void refresh(); });
+        void refresh();
+      }
+      return () => { listeners.delete(listener); if (!listeners.size) stop(); };
+    },
+    refresh,
+    saveLearning(request) {
+      const data = snapshot.data;
+      if (!own(request, ['expectedRevision', 'provider', 'model', 'reasoningEffort']) ||
+          !Number.isSafeInteger(request.expectedRevision) || request.expectedRevision < 1 ||
+          data?.gate?.phase !== 'ready' || snapshot.error || snapshot.loading ||
+          !data?.learning?.enabled || !data.learning.defaults ||
+          !validLearningChoice(data, request)) return Promise.resolve(refused('unavailable'));
+      return mutate('arcfoldModels/saveLearning', { request: { ...request } });
+    },
+    storeCredential(provider, value) {
+      const route = deployedRoutes(snapshot.data).find(row => row.provider === provider);
+      if (!route || !snapshot.credentials[route.apiKeyRef]?.writable || snapshot.error || snapshot.loading ||
+          typeof value !== 'string' || !value.trim()) return Promise.resolve(refused('credential_unavailable'));
+      return mutate('credentials/set', { ref: route.apiKeyRef, value }, true);
+    },
+    removeCredential(provider) {
+      const route = deployedRoutes(snapshot.data).find(row => row.provider === provider);
+      if (!route || !snapshot.credentials[route.apiKeyRef]?.writable || snapshot.error || snapshot.loading)
+        return Promise.resolve(refused('credential_unavailable'));
+      return mutate('credentials/unset', { ref: route.apiKeyRef }, true);
+    },
+    dispose() { disposed = true; stop(); listeners.clear(); },
+  };
+}

package/src/opportunity-host.mjs

@@ -0,0 +1,118 @@
+import { currentMainAgent } from './main-session.mjs';
+import { browseScope } from './browse-scope.mjs';
+import { TypertRemoteService, RemoteError } from '@deepseek-ai/dsh-typert-protocol';
+const NAMESPACE = 'arcfoldOpportunities', SERVICE = 'arcfoldOpportunityWeb';
+const ENDPOINTS = ['list', 'details', 'source', 'savePermission', 'prepare', 'stop', 'dismiss', 'acknowledge', 'continue'];
+const invalid = message => { throw Object.assign(new Error(message), { code: 'invalid_opportunity_request' }); };
+function object(value, fields, required = fields) {
+  if (!value || typeof value !== 'object' || Array.isArray(value) || Object.keys(value).some(key => !fields.includes(key)) ||
+      required.some(key => !Object.hasOwn(value, key))) invalid('机会请求缺少必要内容或含未允许字段。');
+}
+function identity(value) { if (typeof value !== 'string' || !value.trim() || value.length > 512 || value.includes('\0')) invalid('请求身份无效。'); }
+function trusted(connection, signal, peer) {
+  if (!peer || peer !== connection.browserPeer || peer.principal?.kind !== 'owner' || peer.interactions !== 'answer' ||
+      peer.signal?.aborted !== false || signal?.aborted !== false)
+    throw Object.assign(new Error('此操作只接受当前已认证网页用户。'), { code: 'trusted_browser_required' });
+}
+export function createOpportunityHandler({ opportunities, preparation, connection, agents, agentPresets, prompt, inflight = new Map() }) {
+  const main = (sessionId, expected) => {
+    const agent = currentMainAgent({ agents, agentPresets }, sessionId);
+    if (!agent || expected && agent !== expected)
+      throw Object.assign(new Error('请先打开原来的 Arcfold 主交流，再发送继续工作的要求。'), { code: 'opportunity_session_denied' });
+    return agent;
+  };
+  return async (endpoint, payload, signal, peer) => {
+    try {
+      trusted(connection, signal, peer); let value; const userIdentity = 'browser:' + peer.id;
+      if (endpoint === 'list') {
+        object(payload, ['sessionId', 'offset', 'limit', 'viewScope'], ['sessionId']); identity(payload.sessionId); browseScope(payload.viewScope);
+        value = { ...opportunities.list(payload.sessionId, payload), canContinue: currentMainAgent({ agents, agentPresets }, payload.sessionId) !== null };
+      } else if (endpoint === 'details') {
+        object(payload, ['sessionId', 'opportunityId', 'viewScope'], ['sessionId', 'opportunityId']); identity(payload.sessionId); identity(payload.opportunityId);
+        const all = browseScope(payload.viewScope) === 'all';
+        value = opportunities.details(payload.opportunityId);
+        if (!all && value.opportunity.conversationId !== payload.sessionId) invalid('请从机会原来的交流查看。');
+      } else if (endpoint === 'source') {
+        object(payload, ['sourceId']); identity(payload.sourceId);
+        const source = opportunities.store.get('events', payload.sourceId);
+        if (!source) invalid('原件不存在。');
+        value = { source, control: opportunities.store.get('source_controls', payload.sourceId) };
+      } else if (endpoint === 'savePermission') {
+        object(payload, ['sessionId', 'enabled', 'extraSourceIds', 'files', 'expectedRevision', 'requestId']);
+        value = opportunities.savePermission({ ...payload, userIdentity });
+      } else if (endpoint === 'prepare') {
+        object(payload, ['opportunityId', 'expectedRevision', 'permissionRevision', 'requestId']); identity(payload.requestId);
+        const bound = opportunities.bindPreparation({ ...payload, userIdentity }), key = bound.binding.id;
+        if (inflight.has(key)) value = inflight.get(key);
+        else if (!bound.created) value = bound;
+        else {
+          const pending = Promise.resolve().then(async () => {
+            let state = 'failed', runId = null;
+            try {
+              trusted(connection, signal, peer);
+              const run = await preparation.prepare(payload); runId = run.id; state = 'accepted';
+            } catch { /* Failed/uncertain admission remains a consumed request. */ }
+            return { ...bound, binding: opportunities.preparationAdmission(key, state, runId) };
+          });
+          inflight.set(key, pending); value = pending.finally(() => { if (inflight.get(key) === pending) inflight.delete(key); });
+        }
+      } else if (endpoint === 'stop') {
+        object(payload, ['runId', 'expectedRevision', 'requestId']); value = opportunities.stop({ ...payload, userIdentity });
+      } else if (endpoint === 'dismiss') {
+        object(payload, ['opportunityId', 'expectedRevision', 'requestId']); value = opportunities.dismiss({ ...payload, userIdentity });
+      } else if (endpoint === 'acknowledge') {
+        object(payload, ['notificationId']); identity(payload.notificationId); value = opportunities.acknowledge(payload.notificationId);
+      } else if (endpoint === 'continue') {
+        object(payload, ['sessionId', 'opportunityId', 'expectedRevision', 'requestId', 'text']);
+        const agent = main(payload.sessionId);
+        const bound = opportunities.bindContinuation({ ...payload, userIdentity }), key = bound.binding.id;
+        if (inflight.has(key)) value = inflight.get(key);
+        else if (!bound.created) value = bound;
+        else {
+          let entered = false;
+          const pending = Promise.resolve().then(async () => {
+            let state;
+            try {
+              trusted(connection, signal, peer);
+              main(payload.sessionId, agent);
+              if (!opportunities.isMain(payload.sessionId)) invalid('当前主交流不可用。');
+              entered = true;
+              const result = await prompt({ sessionId: payload.sessionId, requestId: payload.requestId, mode: 'queue',
+                content: [{ type: 'text', text: payload.text }] }, signal);
+              state = result?.accepted === true ? 'accepted' : 'unknown';
+            } catch { state = entered ? 'unknown' : 'failed'; }
+            return { ...bound, binding: opportunities.continuationAdmission(key, state) };
+          });
+          inflight.set(key, pending); value = pending.finally(() => { if (inflight.get(key) === pending) inflight.delete(key); });
+        }
+      } else invalid('机会操作不存在。');
+      return { ok: true, value: await value };
+    } catch (error) { return { ok: false, error: { code: error?.code ?? 'opportunity_request_failed', message: error.message ?? '操作未完成。' } }; }
+  };
+}
+class OpportunityWeb extends TypertRemoteService {
+  inflight = new Map();
+  constructor(ctx) { super(ctx, SERVICE, { namespace: NAMESPACE }); }
+  async dispatch(endpoint, payload) {
+    const invocation = this.ctx.invocation, controller = this.ctx.sessionController;
+    const result = await createOpportunityHandler({ opportunities: this.ctx.arcfoldOpportunities, preparation: this.ctx.arcfoldPreparation,
+      connection: this.ctx.connection, agents: this.ctx.agents, agentPresets: this.ctx.agentPresets, inflight: this.inflight,
+      prompt: (payload, signal) => controller.prompt(payload, signal) })(endpoint, payload, invocation?.signal, invocation?.peer);
+    if (!result.ok) throw new RemoteError(result.error.code, result.error.message, {}); return result.value;
+  }
+  list(p) { return this.dispatch('list', p); }
+  details(p) { return this.dispatch('details', p); }
+  source(p) { return this.dispatch('source', p); }
+  savePermission(p) { return this.dispatch('savePermission', p); }
+  prepare(p) { return this.dispatch('prepare', p); }
+  stop(p) { return this.dispatch('stop', p); }
+  dismiss(p) { return this.dispatch('dismiss', p); }
+  acknowledge(p) { return this.dispatch('acknowledge', p); }
+  continue(p) { return this.dispatch('continue', p); }
+}
+export const opportunityInvocations = ENDPOINTS.map(method => ({ id: `@arcfold/dsh-method-ui#${NAMESPACE}/${method}`,
+  service: SERVICE, namespace: NAMESPACE, method, invocation: { kind: 'direct' },
+  parameters: [{ name: 'request', wire: 'request', source: 'json', codec: { mode: 'src-json' } }], result: { mode: 'src-json' } }));
+export function installOpportunityWeb(ctx) {
+  return ctx.inject(['arcfoldOpportunities', 'arcfoldPreparation', 'sessionController', 'connection', 'agents', 'agentPresets'], function opportunityWeb(owner) { new OpportunityWeb(owner); });
+}

package/src/opportunity-locales.mjs

@@ -0,0 +1,34 @@
+export const opportunitiesZh = {
+  opportunityReadOnly: '这里汇集值得留意的建议与已有准备稿，供你阅读和判断。',
+  opportunityRationale: '为什么值得关注', opportunitySuggestion: '可以准备什么', opportunityWorkspace: '工作目录', opportunityDismissed: '已忽略',
+  opportunityTitle: '机会与准备', opportunityOpen: '查看机会', opportunityHide: '收起', opportunityEmpty: '暂无已提交的机会。',
+  opportunityBoundary: '机会是待判断的建议。许可只允许在选定材料范围内准备一份新稿，不代表采纳或继续执行。',
+  opportunityPermission: '自动准备范围', opportunityEnable: '允许本交流的新机会自动准备（含未来消息）',
+  opportunityFiles: '本工作目录内的材料文件，每行一个路径，最多四个', opportunitySources: '附加原件编号，每行一个；只授权这些具体原件',
+  opportunityCapacity: '每个文件最多 256 KiB，合计 512 KiB；完整材料最多 1 MiB。每份新稿最多 64 KiB、4 次模型请求、6 次获准工具动作、5 分钟。这是单次容量限制，不是费用上限。',
+  opportunitySave: '保存范围许可', opportunityOff: '自动准备未开启', opportunityOn: '自动准备已开启', opportunityVersion: '许可版本',
+  opportunityHistorical: '开启前已有的机会不会自动启动；需要逐项选择准备。', opportunityPrepare: '准备这一项', opportunityStop: '停止本次准备',
+  opportunityDismiss: '忽略机会', opportunityRead: '标为已读', opportunityContinue: '发送新的委托', opportunityText: '你现在希望怎样继续？请写完整原话。',
+  opportunityMainRequired: '请先打开原来的主交流，再发送继续工作的要求。',
+  opportunityDraft: '已写入并全文回读的准备稿', opportunityEvidence: '冻结时的原件、角色、版本及全部材料', opportunityNotUsefulYet: '完成文件检查不证明建议有用；请审阅内容后决定。',
+  opportunitySaved: '决定已保存。', opportunityFailed: '提交未开始执行，原记录已保留，不会自动重发。', opportunityUnknown: '提交结果未确认，保留原记录，不自动重发。', opportunityAccepted: '原生入口已受理；实际执行仍以工作记录为准。',
+  opportunityRejected: '材料检查未通过，尚未执行', opportunityPending: '尚未启动', opportunityPrepared: '准备提交中', opportunitySubmitted: '已提交原生执行', opportunityUncertain: '结果未确定，需要查看',
+  opportunityStopped: '已停止或依据失效', opportunitySettled: '完成记录已保留', opportunityUnread: '未读', opportunityAlreadyRead: '已读',
+};
+export const opportunitiesEn = {
+  opportunityReadOnly: 'Suggestions and existing drafts, collected here for you to read and consider.',
+  opportunityRationale: 'Why it matters', opportunitySuggestion: 'Suggested preparation', opportunityWorkspace: 'Workspace', opportunityDismissed: 'Dismissed',
+  opportunityTitle: 'Opportunities and drafts', opportunityOpen: 'View opportunities', opportunityHide: 'Hide', opportunityEmpty: 'No committed opportunities yet.',
+  opportunityBoundary: 'An opportunity is a suggestion to review. Permission allows one new draft using selected material; it does not authorize adoption or further work.',
+  opportunityPermission: 'Automatic preparation scope', opportunityEnable: 'Allow new opportunities in this conversation, including future messages, to prepare a draft',
+  opportunityFiles: 'Material files inside this workspace, one path per line, at most four', opportunitySources: 'Additional original source IDs, one per line; only these exact originals are authorized',
+  opportunityCapacity: 'Each file: 256 KiB; combined files: 512 KiB; complete input: 1 MiB. Each draft: 64 KiB, 4 model requests, 6 authorized tool actions and 5 minutes. These are per-attempt capacity limits, not spending limits.',
+  opportunitySave: 'Save scope permission', opportunityOff: 'Automatic preparation is off', opportunityOn: 'Automatic preparation is on', opportunityVersion: 'Permission version',
+  opportunityHistorical: 'Existing opportunities do not start when permission is enabled. Select each one explicitly.', opportunityPrepare: 'Prepare this', opportunityStop: 'Stop preparation',
+  opportunityDismiss: 'Dismiss opportunity', opportunityRead: 'Mark read', opportunityContinue: 'Send new instruction', opportunityText: 'What should happen next? Enter your complete new instruction.',
+  opportunityMainRequired: 'Open the original main conversation before sending a new instruction.',
+  opportunityDraft: 'Draft written and fully read back', opportunityEvidence: 'Originals, roles, versions and complete frozen material', opportunityNotUsefulYet: 'File verification does not prove usefulness. Review the content before deciding.',
+  opportunitySaved: 'Decision saved.', opportunityFailed: 'Execution did not start. The original submission is retained and will not be resent automatically.', opportunityUnknown: 'Submission is unconfirmed. Its original record is retained and will not be resent automatically.', opportunityAccepted: 'The native entry accepted the submission. Actual work is shown by its execution record.',
+  opportunityRejected: 'Admission refused; no execution occurred', opportunityPending: 'Not started', opportunityPrepared: 'Preparing submission', opportunitySubmitted: 'Submitted to native execution', opportunityUncertain: 'Outcome unknown; review needed',
+  opportunityStopped: 'Stopped or supporting material unavailable', opportunitySettled: 'Completion record retained', opportunityUnread: 'Unread', opportunityAlreadyRead: 'Read',
+};

package/src/opportunity-source.mjs

@@ -0,0 +1,56 @@
+import { requireViewScope, viewScopeFields } from './browse-source.mjs';
+export async function callOpportunity(rpc, endpoint, payload, signal) {
+  const result = await rpc.call('/api', `arcfoldOpportunities/${endpoint}`, { args: { request: payload } }, signal);
+  if (result?.ok !== true) throw Object.assign(new Error(result?.error?.message ?? '机会请求未完成。'), { code: result?.error?.code ?? 'opportunity_request_failed', remote: true });
+  return result.value;
+}
+export function createOpportunitySource({ rpc, sessionId, viewScope, subscribeReset, intervalMs = 5000 }) {
+  viewScopeFields(viewScope);
+  let state = { items: [], total: 0, offset: 0, nextOffset: null, loading: true, permission: null, error: null, resetVersion: 0 };
+  let generation = 0, disposed = false, controller, timer, reset; const listeners = new Set(), reads = new Set();
+  const publish = value => { state = { ...state, ...value }; for (const listener of listeners) listener(); };
+  function invalidateReads() {
+    controller?.abort(); generation++;
+    for (const read of reads) read.abort();
+    publish({ items: [], total: 0, offset: 0, nextOffset: null, loading: true, permission: null,
+      canPrepare: false, canContinue: false, error: null, resetVersion: state.resetVersion + 1 });
+  }
+  async function refresh(offset = state.offset) {
+    if (disposed) return; controller?.abort(); controller = new AbortController(); const signal = controller.signal, current = ++generation;
+    try { const value = await callOpportunity(rpc, 'list', { sessionId, offset, limit: 20, ...viewScopeFields(viewScope) }, signal);
+      if (!disposed && current === generation && !signal.aborted) publish({ ...value, offset, loading: false, error: null });
+    } catch (error) { if (!disposed && current === generation && !signal.aborted) publish({ loading: false, error: error.message }); }
+  }
+  const assertLive = () => { if (disposed) throw Object.assign(new Error('机会视图已关闭。'), { code: 'opportunity_view_disposed' }); };
+  const stop = () => { clearInterval(timer); timer = undefined; reset?.(); reset = null; invalidateReads(); };
+  return {
+    getSnapshot: () => state,
+    subscribe(listener) { if (disposed) return () => {}; listeners.add(listener);
+      if (listeners.size === 1) { void refresh(); timer = setInterval(() => { void refresh(); }, intervalMs); reset = subscribeReset(() => { invalidateReads(); void refresh(0); }); }
+      return () => { listeners.delete(listener); if (!listeners.size) stop(); }; },
+    refresh,
+    setViewScope(value) {
+      requireViewScope(value);
+      if (disposed || viewScope === value) return;
+      viewScope = value; invalidateReads();
+      if (listeners.size) void refresh(0);
+    },
+    async details(opportunityId) {
+      assertLive(); const version = state.resetVersion, read = new AbortController(); reads.add(read);
+      try {
+        const value = await callOpportunity(rpc, 'details', { sessionId, opportunityId, ...viewScopeFields(viewScope) }, read.signal);
+        assertLive();
+        if (read.signal.aborted || version !== state.resetVersion)
+          throw Object.assign(new Error('查看范围或连接已变化，请重新查看机会。'), { code: 'opportunity_view_reset' });
+        return value;
+      } finally { reads.delete(read); }
+    },
+    source: sourceId => { assertLive(); return callOpportunity(rpc, 'source', { sourceId }); },
+    async act(endpoint, request) {
+      assertLive();
+      const payload = ['savePermission', 'continue'].includes(endpoint) ? { ...request, sessionId } : request;
+      const value = await callOpportunity(rpc, endpoint, payload); await refresh(); return value;
+    },
+    dispose() { disposed = true; stop(); listeners.clear(); },
+  };
+}

package/src/style.css

@@ -0,0 +1,99 @@
+.arcfold-methods {box-sizing:border-box;width:calc(100% - 4 * var(--dsh-composer-dock-inset, 8px));max-width:var(--dsh-composer-card-max-width, 800px);margin:0 auto 8px;padding:10px 12px;border:1px solid var(--dsw-alias-border-l1);border-radius:var(--dsw-radius-md, 12px);background:var(--dsw-specific-menu);color:var(--dsw-alias-label-primary);font-size:13px;line-height:1.5;}
+.arcfold-methods header,.arcfold-methods nav,.arcfold-methods .actions {display:flex;align-items:center;flex-wrap:wrap;gap:8px;}
+.arcfold-methods header strong {flex:1;}
+.arcfold-methods button {font:inherit;color:inherit;background:transparent;border:1px solid var(--dsw-alias-border-l1);border-radius:8px;padding:4px 8px;cursor:pointer;}
+.arcfold-methods button:disabled {opacity:.5;cursor:not-allowed;}
+.arcfold-methods button:focus-visible {outline:2px solid currentColor;outline-offset:2px;}
+.arcfold-methods ul {list-style:none;padding:0;margin:8px 0;}
+.arcfold-methods li {margin:8px 0;padding-block:4px;}
+.arcfold-methods p {margin:6px 0;}
+.arcfold-methods .detail {max-height:min(60vh,36rem);overflow:auto;overscroll-behavior:contain;margin-top:8px;border-top:1px solid var(--dsw-alias-border-l1);padding-top:8px;}
+.arcfold-methods .text {white-space:pre-wrap;overflow-wrap:anywhere;}
+.arcfold-methods .meta {font-size:12px;color:var(--dsw-alias-label-secondary);overflow-wrap:anywhere;}
+.arcfold-methods [role=alert] {color:var(--dsw-alias-state-error-primary);white-space:pre-wrap;}
+.arcfold-methods h3,.arcfold-methods h4 {font-size:13px;margin:12px 0 4px;}
+.arcfold-methods .source {border-left:2px solid var(--dsw-alias-border-l1);padding-left:8px;}
+.arcfold-goals textarea {display:block;box-sizing:border-box;width:100%;min-height:5rem;margin:6px 0;padding:8px;font:inherit;resize:vertical;color:inherit;background:transparent;border:1px solid var(--dsw-alias-border-l1);border-radius:8px;}
+.arcfold-goals .goal-discussion {margin-top:12px;}
+.arcfold-goals .goal-work {margin:10px 0;padding-block:4px;}
+.arcfold-goals .goal-work button {margin:4px 8px 4px 0;}
+.arcfold-goals summary {cursor:pointer;}
+.arcfold-goals .goal-cards {display:grid;gap:14px;}
+.arcfold-goals .goal-card {min-width:0;padding:18px;border:1px solid var(--dsw-alias-border-l1);border-radius:12px;background:var(--dsw-alias-bg-layer-1);overflow-wrap:anywhere;}
+.arcfold-goals .goal-card-heading {align-items:flex-start;justify-content:space-between;gap:12px;}
+.arcfold-goals .goal-card-heading h3 {flex:1;min-width:0;margin:0;font-size:15px;line-height:1.6;}
+.arcfold-goals .goal-status-badge {display:inline-block;flex-shrink:0;border:1px solid var(--dsw-alias-border-l1);border-radius:6px;padding:2px 8px;font-size:11px;color:var(--dsw-alias-label-secondary);}
+.arcfold-goals .goal-outcome {margin-top:12px;color:var(--dsw-alias-label-secondary);}
+.arcfold-goals .goal-card-section {margin-top:18px;}
+.arcfold-goals .goal-card-section h4 {margin:0 0 8px;font-size:12px;color:var(--dsw-alias-label-secondary);}
+.arcfold-goals .goal-work {margin:0;padding:0;}
+.arcfold-goals .goal-work + .goal-work {border-top:1px solid var(--dsw-alias-border-l1);margin-top:14px;padding-top:14px;}
+.arcfold-goals .goal-work-blocker {margin-top:10px;padding:10px 12px;border-left:3px solid var(--dsw-alias-border-l1);background:var(--dsw-specific-menu);border-radius:0 6px 6px 0;}
+.arcfold-goals .goal-work-blocker h5 {margin:0;font-size:12px;}
+.arcfold-goals .goal-work-details {margin-top:8px;font-size:12px;}
+.arcfold-goals .goal-card-evidence {border-top:1px solid var(--dsw-alias-border-l1);margin-top:18px;padding-top:12px;}
+.arcfold-goals .goal-card-evidence > summary,.arcfold-goals .goal-work-details > summary {color:var(--dsw-alias-label-secondary);}
+.arcfold-goals .goal-other-work {margin-top:16px;}
+.arcfold-goals summary:focus-visible {outline:2px solid currentColor;outline-offset:3px;}
+@media (max-width:480px) {.arcfold-goals .goal-card {padding:14px;}.arcfold-goals .goal-card-heading h3 {flex-basis:100%;}}
+
+.arcfold-model-settings {width:100%;max-width:52rem;margin:0;padding:16px;}
+.arcfold-model-settings header h2 {flex:1;font-size:16px;margin:0;}
+.arcfold-model-settings h3 {font-size:14px;margin-top:18px;}
+.arcfold-model-settings .model-card {border-top:1px solid var(--dsw-alias-border-l1);padding:8px 0;}
+.arcfold-model-settings label {display:flex;flex-direction:column;gap:4px;min-width:0;}
+.arcfold-model-settings input,.arcfold-model-settings select {box-sizing:border-box;min-width:0;max-width:100%;width:100%;padding:7px;font:inherit;color:inherit;background:var(--dsw-specific-menu);border:1px solid var(--dsw-alias-border-l1);border-radius:8px;}
+.arcfold-model-settings .model-fields {display:grid;grid-template-columns:repeat(auto-fit,minmax(min(100%,150px),1fr));gap:8px;margin:10px 0;}
+.arcfold-model-settings .actions {margin:8px 0;}
+.arcfold-model-settings dl {margin:8px 0;display:flex;flex-wrap:wrap;gap:8px 20px;}
+.arcfold-model-settings dt {font-size:12px;color:var(--dsw-alias-label-secondary);}
+.arcfold-model-settings dd {margin:0;overflow-wrap:anywhere;}
+
+.arcfold-understandings .text { white-space: pre-wrap; overflow-wrap: anywhere; }
+.arcfold-understandings textarea { display: block; box-sizing: border-box; width: 100%; min-height: 8rem; resize: vertical; }
+.arcfold-understandings summary { cursor: pointer; overflow-wrap: anywhere; }
+
+.arcfold-imports label { display:flex; flex-direction:column; gap:4px; margin:8px 0; }
+.arcfold-imports input,.arcfold-imports select { box-sizing:border-box; width:100%; max-width:100%; min-width:0; padding:7px; font:inherit; color:inherit; background:var(--dsw-specific-menu); border:1px solid var(--dsw-alias-border-l1); border-radius:8px; }
+.arcfold-imports .import-counts { display:flex; flex-wrap:wrap; gap:8px 20px; }
+.arcfold-imports dt { font-size:12px; color:var(--dsw-alias-label-secondary); }
+.arcfold-imports dd { margin:0; }
+.arcfold-imports .import-decision { border-top:1px solid var(--dsw-alias-border-l1); margin-top:12px; padding-top:8px; }
+.arcfold-imports summary { cursor:pointer; overflow-wrap:anywhere; }
+
+.arcfold-view {box-sizing:border-box;width:100%;max-width:60rem;margin:0 auto;padding:16px;min-width:0;color:var(--dsw-alias-label-primary);}
+.arcfold-toolbar {display:flex;align-items:center;justify-content:space-between;flex-wrap:wrap;gap:8px;margin-bottom:16px;}
+.arcfold-toolbar h2 {font-size:16px;margin:0;}
+.arcfold-view-scope {display:flex;flex-wrap:wrap;gap:6px;margin:0 0 16px;}
+.arcfold-view-scope button {font:inherit;color:inherit;background:transparent;border:1px solid var(--dsw-alias-border-l1);border-radius:8px;padding:7px 12px;cursor:pointer;}
+.arcfold-view-scope button[aria-pressed="true"] {background:var(--dsw-alias-bg-layer-1);border-color:currentColor;}
+.arcfold-view-scope button:focus-visible {outline:2px solid currentColor;outline-offset:2px;}
+.arcfold-toolbar button,.arcfold-hero-entry button {font:inherit;color:inherit;background:transparent;border:1px solid var(--dsw-alias-border-l1);border-radius:8px;padding:7px 12px;cursor:pointer;}
+.arcfold-toolbar button:focus-visible,.arcfold-hero-entry button:focus-visible {outline:2px solid currentColor;outline-offset:2px;}
+.arcfold-view > .arcfold-methods,.arcfold-dialog > .arcfold-model-settings {width:100%;max-width:none;}
+.arcfold-view > .arcfold-methods {margin-bottom:16px;padding:18px;border-radius:14px;}
+.arcfold-view > .arcfold-methods > header {gap:10px;min-height:30px;}
+.arcfold-view > .arcfold-methods > header > strong {font-size:14px;}
+.arcfold-view > .arcfold-methods > .detail {max-height:none;overflow:visible;margin-top:16px;padding-top:16px;}
+.arcfold-view > .arcfold-methods > .detail > ul > li {padding:14px;margin:10px 0;border:1px solid var(--dsw-alias-border-l1);border-radius:10px;overflow-wrap:anywhere;}
+.arcfold-opportunities .opportunity-overview {padding:0 0 16px;}
+.arcfold-opportunities .opportunity-overview > p:first-child {margin:0 0 10px;color:var(--dsw-alias-label-secondary);}
+.arcfold-opportunities .opportunity-status {display:flex;align-items:center;flex-wrap:wrap;gap:8px;margin-bottom:10px;}
+.arcfold-opportunities .status-badge {display:inline-block;border:1px solid var(--dsw-alias-border-l1);border-radius:6px;padding:2px 8px;font-size:11px;line-height:1.6;color:var(--dsw-alias-label-secondary);}
+.arcfold-opportunities ul.opportunity-list {display:grid;gap:12px;margin:0;}
+.arcfold-view > .arcfold-opportunities > .detail > ul.opportunity-list > li {min-width:0;margin:0;padding:18px;background:var(--dsw-alias-bg-layer-1);border-radius:12px;}
+.arcfold-opportunities .opportunity-card > h3 {margin:0;font-size:14px;font-weight:600;line-height:1.7;}
+.arcfold-opportunities .opportunity-field {margin-top:14px;}
+.arcfold-opportunities .opportunity-card h4 {margin:0 0 4px;font-size:11px;font-weight:500;color:var(--dsw-alias-label-secondary);}
+.arcfold-opportunities .opportunity-field p {margin:0;line-height:1.7;}
+.arcfold-opportunities .opportunity-draft,.arcfold-opportunities .opportunity-evidence {border-top:1px solid var(--dsw-alias-border-l1);margin-top:16px;padding-top:12px;}
+.arcfold-opportunities .opportunity-evidence summary {cursor:pointer;font-size:12px;color:var(--dsw-alias-label-secondary);}
+.arcfold-opportunities .opportunity-evidence summary:focus-visible {outline:2px solid currentColor;outline-offset:4px;}
+.arcfold-opportunities .opportunity-card pre {font:inherit;font-size:12px;line-height:1.7;max-width:100%;}
+.arcfold-opportunities .opportunity-pagination {margin-top:16px;justify-content:flex-end;}
+.arcfold-hero-entry {display:flex;flex-wrap:wrap;justify-content:center;gap:8px;color:var(--dsw-alias-label-primary);}
+.arcfold-dialog {box-sizing:border-box;width:min(56rem,calc(100vw - 24px));max-width:calc(100vw - 24px);max-height:calc(100dvh - 32px);overflow:auto;overscroll-behavior:contain;padding:16px;border:1px solid var(--dsw-alias-border-l1);border-radius:12px;background:var(--dsw-alias-bg-layer-1);color:var(--dsw-alias-label-primary);}
+.arcfold-dialog::backdrop {background:rgb(0 0 0 / .35);}
+.arcfold-dialog > .arcfold-view {padding:0;}
+@media (max-width:480px) {.arcfold-hero-entry {flex-direction:column;align-items:stretch;}.arcfold-view,.arcfold-dialog {padding:12px;}.arcfold-methods header {align-items:flex-start;}.arcfold-methods header strong {flex-basis:100%;}}
+@media (max-width:480px) {.arcfold-view > .arcfold-methods {padding:14px;margin-bottom:12px;}.arcfold-view > .arcfold-opportunities > .detail > ul.opportunity-list > li {padding:14px;}}

package/src/tree-client.mjs

@@ -0,0 +1,15 @@
+import React from 'react';
+import { createTreeSource } from './tree-source.mjs';
+import { TreeView, TreeDock, TreeTurnTail } from './tree-view.mjs';
+// B7 calls this only in the explicit v3 profile, instead of old goal cards.
+export function installTreeClient(ctx) {
+  const sources = new Map();
+  const props = sessionId => {
+    if (!sources.has(sessionId)) sources.set(sessionId, createTreeSource({ rpc: ctx.connection.rpc, sessionId, subscribeReset: listener => ctx.on('connection/reset', listener) }));
+    return { source: sources.get(sessionId) };
+  };
+  ctx.effect(() => () => { sources.forEach(source => source.dispose()); sources.clear(); }, 'Arcfold tree reads');
+  ctx.effect(() => { const style = document.createElement('style'); style.dataset.plugin = 'arcfold-tree-v3'; style.textContent = typeof __ARCFOLD_TREE_CSS__ === 'string' ? __ARCFOLD_TREE_CSS__ : ''; document.head.append(style); return () => style.remove(); }, 'Arcfold tree appearance');
+  for (const [name, component] of [['conversation.input.dock', TreeDock], ['conversation.view', TreeView], ['conversation.chat.turnTail', ({ source, turn }) => React.createElement(TreeTurnTail, { source, nativeTurn: turn.turn })]])
+    ctx.slots.inject(name, () => ctx.slots.register({ name, id: 'arcfold-tree-v3', order: 20, label: 'Arcfold', inject: props }, component));
+}