@givolt/i3-composer-agent 3.1.0 → 4.0.0

package/skills/i3-ui-prototype/scripts/prototype-locations.cjs

@@ -1,69 +0,0 @@
-'use strict';
-const fs = require('node:fs');
-const path = require('node:path');
-const os = require('node:os');
-const crypto = require('node:crypto');
-// Reviewed mirror of i3's installer target table; maintenance tests require byte equality.
-const registry = require('../assets/optional-skills/host-targets.json');
-const aliases = { claude: 'claude-code', gemini: 'gemini-cli', copilot: 'github-copilot' };
-function globalSkillsDir(agent, home, env) {
-  const config = agent.globalSkillsDir;
-  if (!config) return null;
-  let base = home;
-  if (config.base === 'config') base = env.XDG_CONFIG_HOME && path.isAbsolute(env.XDG_CONFIG_HOME) ? env.XDG_CONFIG_HOME : path.join(home, '.config');
-  if (config.base === 'env') base = env[config.env]?.trim() || path.join(home, config.fallback);
-  if (['CODEBUDDY_CONFIG_DIR','WORKBUDDY_CONFIG_DIR'].includes(config.env) && (!path.isAbsolute(base) || /[\x00\r\n]/.test(base))) throw new Error(`${config.env} must be an absolute safe directory`);
-  if (config.alternatives && !fs.existsSync(path.join(home, path.dirname(config.path)))) {
-    const alternative = config.alternatives.find(relative => fs.existsSync(path.join(home, path.dirname(relative))));
-    if (alternative) return path.join(home, alternative);
-  }
-  return path.resolve(base, config.path);
-}
-function installedContext() {
-  const file = path.resolve(__dirname, '../../../.i3-composer-agent.json');
-  if (!fs.existsSync(file)) return {};
-  const data = JSON.parse(fs.readFileSync(file, 'utf8'));
-  if (data.name !== 'i3-composer-agent' || !Array.isArray(data.agents)) throw new Error('Invalid i3 installation context');
-  return { hosts: data.agents, scope: data.scope };
-}
-function resolveLocations(options = {}) {
-  const installed = installedContext();
-  if (!options.host && installed.hosts?.length > 1) throw new Error('Multiple installed hosts; specify --host');
-  const selected = options.host || installed.hosts?.[0] || 'codebuddy';
-  const host = aliases[selected] || selected, scope = options.scope || 'project';
-  const agent = registry.agents.find(item => item.id === host);
-  if (!agent) throw new Error(`Unknown host: ${host}`);
-  if (!['project', 'global'].includes(scope)) throw new Error('Use scope project or global');
-  const project = fs.realpathSync(path.resolve(options.project || '.'));
-  if (!fs.statSync(project).isDirectory()) throw new Error('Project must be a directory');
-  const home = path.resolve(options.home || os.homedir()), env = options.env || process.env;
-  const projectSkills = path.resolve(project, agent.projectSkillsDir), globalSkills = globalSkillsDir(agent, home, env);
-  if (scope === 'global' && !globalSkills) throw new Error(`${agent.label}: project installation only`);
-  const skillsDirectory = scope === 'project' ? projectSkills : globalSkills, base = path.dirname(skillsDirectory);
-  const projectBase = path.dirname(projectSkills), globalBase = globalSkills ? path.dirname(globalSkills) : null;
-  // Some hosts put skills directly in the workspace; tools still get a host directory.
-  const projectToolsBase = projectBase === project ? path.join(project, `.${host}`) : projectBase;
-  const projectKey = `${path.basename(project).replace(/[^a-zA-Z0-9_-]/g, '-').slice(0, 32) || 'project'}-${crypto.createHash('sha256').update(project).digest('hex').slice(0, 16)}`;
-  const cacheBase = path.join(scope === 'global' ? globalBase : projectToolsBase, 'cache/i3-prototype');
-  return { host, scope, project, home, skillsDirectory, base, projectSkills, globalSkills,
-    projectBase, globalBase, projectToolsBase, projectKey, cacheDirectory: scope === 'global' ? path.join(cacheBase, projectKey) : cacheBase,
-    toolsDirectory: path.join(scope === 'global' ? globalBase : projectToolsBase, 'tools/i3-prototype') };
-}
-function scopeBases(context) {
-  return context.scope === 'global' ? [[context.globalBase, 'global']] : [[context.projectBase, 'project'], ...(context.globalBase ? [[context.globalBase, 'global']] : [])];
-}
-function toolCandidates(context, options = {}) {
-  if (options.tool !== undefined) {
-    if (!path.isAbsolute(options.tool)) throw new Error('--tool requires an absolute antDv package directory');
-    return [{ root: path.resolve(options.tool), source: 'explicit-tool' }];
-  }
-  return [
-    ...toolBases(context).map(([base, scope]) => ({ root: path.join(base, 'tools/i3-prototype/antdv-cli/node_modules/@antdv-next/cli'), source: `${scope}-tool` })),
-    ...(context.scope === 'project' ? ['.prototype-tools/antdv-cli/node_modules/@antdv-next/cli', '.prototype-tools/node_modules/@antdv-next/cli']
-      .map(relative => ({ root: path.join(context.project, relative), source: 'legacy-project-tool' })) : []),
-  ].filter((item, index, all) => all.findIndex(other => other.root === item.root) === index);
-}
-function toolBases(context) {
-  return context.scope === 'global' ? [[context.globalBase, 'global']] : [[context.projectToolsBase, 'project'], ...(context.globalBase ? [[context.globalBase, 'global']] : [])];
-}
-module.exports = { registry, globalSkillsDir, resolveLocations, scopeBases, toolBases, toolCandidates };

package/skills/i3-ui-prototype/scripts/ptc-callbacks.cjs

@@ -1,131 +0,0 @@
-'use strict';
-// Native Pre/Post callbacks are the evidence. REPL source and claimed returns are never interpreted.
-const fs=require('node:fs'),path=require('node:path'),assert=require('node:assert/strict');
-const F=require('./native-files.cjs'),E=require('./execution-evidence.cjs'),C=require('./codebuddy-context.cjs'),P=require('./execution-policy.cjs');
-const {toolName}=require('./native-tool-name.cjs');
-const canonical=x=>Array.isArray(x)?x.map(canonical):x&&typeof x==='object'?Object.fromEntries(Object.keys(x).sort().map(k=>[k,canonical(x[k])])):x;
-const digest=x=>E.sha(JSON.stringify(canonical(x)));
-const fileFor=(record,project,sessionId)=>path.join(C.sessionDirectory(record,project,sessionId),'ptc-callbacks.json');
-function load(file){
- if(!fs.existsSync(file))return null;
- assert.ok(!fs.lstatSync(file).isSymbolicLink()&&fs.statSync(file).size<=64*1024*1024,'Invalid PTC callback journal');return JSON.parse(fs.readFileSync(file,'utf8'));
-}
-function locked(file,work){
- const folder=path.dirname(file);fs.mkdirSync(folder,{recursive:true,mode:0o700});const lock=file+'.lock';let acquired=false;
- for(let n=0;n<40;n++){try{fs.mkdirSync(lock);acquired=true;break;}catch(error){if(error.code!=='EEXIST')throw error;Atomics.wait(new Int32Array(new SharedArrayBuffer(4)),0,0,10);}}
- assert.ok(acquired,'Concurrent native PTC callback; retry without inventing evidence');
- try{return work();}finally{fs.rmdirSync(lock);}
-}
-function validate(store,source,{record,project,sessionId}){
- assert.equal(store.schemaVersion,1,'Unsupported PTC callback schema');assert.equal(store.sessionId,sessionId,'PTC callback session differs');assert.equal(store.project,project,'PTC callback project differs');
- assert.equal(store.registrationDigest,record.registrationDigest,'PTC callback registration digest changed');assert.equal(store.settingsDigest,record.settingsDigest,'PTC callback settings digest changed');
- assert.equal(store.sourcePath,source.path,'PTC native transcript path changed');
- assert.ok(Number.isSafeInteger(store.sequence)&&store.sequence>=0&&store.sequence<900000,'Invalid native callback sequence');
- const sequences=new Set();
- const sequence=value=>{assert.ok(Number.isSafeInteger(value)&&value>0&&value<=store.sequence&&!sequences.has(value),'Invalid or duplicate native callback sequence');sequences.add(value);};
- for(const [id,item] of Object.entries(store.calls)) {
-  assert.equal(item.id,id,'Native callback call ID changed');assert.equal(item.sessionId,sessionId,'Native callback call session changed');
-  assert.equal(digest(item.pre),digest({id:item.id,name:item.name,input:item.input,sessionId:item.sessionId,parentId:item.parentId,cwd:item.cwd}),'Native callback request changed');
-  sequence(item.preSequence);
-  if(item.post){sequence(item.postSequence);assert.ok(item.postSequence>item.preSequence,'Native callback Post must follow Pre');}
-  else assert.equal(item.postSequence,undefined,'Native callback result sequence without a result');
- }
- for(const parent of Object.values(store.parents)){
-  const call=source.calls.find(c=>c.toolCallId===parent.toolCallId);
-  assert.ok(call?.name==='REPL'&&call.sessionId===sessionId,'Native parent REPL request missing or session differs');
-  assert.equal(call.requestDigest,parent.requestDigest,'Native parent request digest changed');assert.equal(call.requestLine,parent.requestLine,'Native parent request cursor changed');
-  assert.ok(source.prompts.some(p=>p.line===parent.promptLine&&p.digest===parent.promptDigest),'Native parent task source changed');
- }
-}
-function read(source,{record,project,sessionId}){
- source={...source,calls:source.calls.filter(c=>c.evidenceSource!=='native-hook-callback')};
- const store=load(fileFor(record,project,sessionId));if(!store)return source;
- validate(store,source,{record,project,sessionId});
- const inner=[];
- for(const item of Object.values(store.calls)){
-  const parent=store.parents[item.parentId];assert.ok(parent,'PTC parent callback anchor missing');
-  const name=toolName(item.name),input=item.input,skillName=name==='Skill'?input?.skill||input?.name||input?.command:null;
-  assert.ok(!source.calls.some(c=>c.toolCallId===item.id),'Duplicate native inner tool call ID');
-  const call={toolCallId:item.id,name,input,skillName:skillName||null,skill:P.skillKey(skillName),sessionId,cwd:item.cwd,contextLine:parent.contextLine,promptLine:parent.promptLine,
-   requestLine:parent.requestLine+item.preSequence/1e6,requestDigest:digest(item.pre),success:false,parentToolCallId:item.parentId,evidenceSource:'native-hook-callback'};
-  if(item.post){
-   let result=item.post.response;
-   if(item.cliResult){
-    const value=item.cliResult;assert.equal(E.sha(fs.readFileSync(value.script)),value.scriptDigest,'Captured CLI script bytes changed');
-    assert.equal(value.inputDigest,digest(item.input),'Captured CLI input differs');
-    assert.equal(item.post.response?.exitCode,value.exitCode,'Native Bash exit differs from captured CLI result');
-    result={type:'execute_command_result',stdout:typeof value.result==='string'?value.result:JSON.stringify(value.result),exitCode:value.exitCode};
-   }
-   call.result=result;call.resultLine=parent.requestLine+item.postSequence/1e6;call.resultDigest=digest({post:item.post,cliResult:item.cliResult||null});
-   call.success=!item.denied&&!result?.interrupted&&!result?.sandboxDenied&&!result?.signal&&E.successful({content:result});
-  }
-  inner.push(call);
- }
- return {...source,calls:[...source.calls,...inner].sort((a,b)=>a.requestLine-b.requestLine),callMode:'ptc-repl',callbackJournal:{path:fileFor(record,project,sessionId),digest:digest(store),tamperProof:false}};
-}
-function observe({payload,record,project,source}){
- const sessionId=payload.session_id,name=toolName(payload.tool_name),id=payload.tool_use_id||payload.call_id;
- assert.ok(sessionId&&id,'Native PTC session and tool call ID required');
- assert.ok(!payload.agent_id&&!payload.parent_agent_id,'PTC main task cannot inherit subagent callbacks');
- assert.ok(source.calls.every(c=>c.sessionId===sessionId),'Native PTC callback session differs');
- const task=source.prompts.at(-1);assert.ok(task,'Native PTC user task missing');
- const candidates=source.calls.filter(c=>c.name==='REPL'&&!c.resultLine&&c.requestLine>task.line&&c.contextLine===source.contextLine);
- const direct=source.calls.find(c=>c.toolCallId===id);
- if(direct&&!direct.evidenceSource&&direct.name!=='REPL')return source;
- if(name==='REPL'&&payload.hook_event_name==='PostToolUse'&&direct?.name==='REPL')return read(source,{record,project,sessionId});
- assert.equal(candidates.length,1,'Native PTC callback requires a unique pending parent REPL');
- const parent=candidates[0],file=fileFor(record,project,sessionId);
- locked(file,()=>{
-  const store=load(file)||{schemaVersion:1,sessionId,project,sourcePath:source.path,registrationDigest:record.registrationDigest,settingsDigest:record.settingsDigest,sequence:0,parents:{},calls:{}};
-  validate(store,source,{record,project,sessionId});
-  const next=()=>{assert.ok(++store.sequence<900000,'Native PTC callback journal limit reached');return store.sequence;};
-  if(name==='REPL'){
-   assert.equal(id,parent.toolCallId,'Native outer REPL call differs');assert.equal(digest(payload.tool_input||{}),digest(parent.input),'Native outer REPL input differs');
-   if(payload.hook_event_name==='PreToolUse')store.parents[id]||={toolCallId:id,requestDigest:parent.requestDigest,requestLine:parent.requestLine,promptLine:task.line,promptDigest:task.digest,contextLine:source.contextLine};
-  }else{
-   assert.ok(store.parents[parent.toolCallId],'Native parent PreToolUse callback missing');
-   const input=payload.tool_input||{},pre={id,name,input,sessionId,parentId:parent.toolCallId,cwd:payload.cwd};
-   if(payload.hook_event_name==='PreToolUse'){
-    if(store.calls[id])assert.equal(digest(store.calls[id].pre),digest(pre),'Conflicting native PTC call input or parent changed');
-    else store.calls[id]={...pre,pre,preSequence:next()};
-   }else if(payload.hook_event_name==='PostToolUse'){
-    const item=store.calls[id];assert.ok(item,'Paired native PTC PreToolUse request missing');assert.equal(digest(item.pre),digest(pre),'Native PTC Post input differs');
-    assert.ok(Object.hasOwn(payload,'tool_response'),'Native PTC Post response missing');const post={response:payload.tool_response};
-    if(item.post)assert.equal(digest(item.post),digest(post),'Conflicting native PTC Post result changed');
-    else {item.post=post;item.postSequence=next();}
-   }
-  }
-  F.write(path.dirname(file),path.basename(file),store);fs.chmodSync(file,0o600);
- });
- return read(source,{record,project,sessionId});
-}
-function captureResult({script,argv,project=process.cwd(),result,exitCode}){
- // Only an actually running first-party entry may capture stdout. Match its exact pending native command.
- const candidates=[path.join(project,'.codebuddy')];let folder=path.dirname(script);
- for(let n=0;n<5;n++,folder=path.dirname(folder))candidates.push(folder);
- const global=C.globalBase();candidates.push(global);
- const matches=[];
- for(const base of [...new Set(candidates)]){
-  if(!fs.existsSync(path.join(base,'state/i3-prototype/installation.json')))continue;
-  const record=C.registration(base),parent=path.join(base,'state/i3-prototype',C.projectKey(project));if(!fs.existsSync(parent))continue;
-  for(const session of fs.readdirSync(parent)){
-   if(!/^[a-f0-9]{24}$/.test(session))continue;const file=path.join(parent,session,'ptc-callbacks.json'),store=load(file);if(!store)continue;
-   if(store.registrationDigest!==record.registrationDigest||store.project!==project)continue;
-   for(const item of Object.values(store.calls)){
-    if(item.name!=='Bash'||item.post||item.cliResult)continue;
-    const tokens=require('./native-command.cjs').tokens(item.input?.command);
-    if(!tokens||tokens.length!==argv.length+2||digest(tokens.slice(2))!==digest(argv))continue;
-    const cwd=item.cwd||project,real=file=>{try{return fs.realpathSync(file);}catch{return null;}};
-    const executable=tokens[0].includes(path.sep)?path.resolve(cwd,tokens[0]):(process.env.PATH||'').split(path.delimiter).map(dir=>path.resolve(cwd,dir,tokens[0])).find(file=>{try{fs.accessSync(file,fs.constants.X_OK);return fs.statSync(file).isFile();}catch{return false;}});
-    if(executable&&real(executable)===real(process.execPath)&&real(path.resolve(cwd,tokens[1]))===real(script))matches.push({file,item});
-   }
-  }
- }
- if(!matches.length)return false;assert.equal(matches.length,1,'Captured CLI result has multiple pending native requests');
- const {file,item}=matches[0];locked(file,()=>{
-  const store=load(file),current=store.calls[item.id];assert.ok(current&&!current.post&&!current.cliResult,'Captured CLI callback changed');
-  current.cliResult={script,scriptDigest:E.sha(fs.readFileSync(script)),argv,inputDigest:digest(current.input),result,exitCode,at:new Date().toISOString()};
-  F.write(path.dirname(file),path.basename(file),store);
- });return true;
-}
-module.exports={observe,read,captureResult};

package/skills/i3-ui-prototype/scripts/sync-template.cjs

@@ -1,19 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-const { prepareTemplate, syncTemplate, loadTemplate } = require('./template-contract.cjs');
-try {
-  const args = process.argv.slice(2);
-  const option = name => { const index = args.indexOf(name); return index < 0 ? undefined : args[index + 1]; };
-  let result;
-  if (args.includes('--prepare')) {
-    if (!option('--project')) throw new Error('--prepare requires --project <directory>');
-    const prepared = prepareTemplate({ project: option('--project'), id: option('--id') });
-    result = { status: 'passed', directory: prepared.directory, created: prepared.created, digest: prepared.index.digest };
-  } else {
-    const directory = args.find(arg => !arg.startsWith('--'));
-    if (!directory) throw new Error('Usage: sync-template.cjs <directory> [--check] | --prepare --project <directory> [--id <id>]');
-    const index = args.includes('--check') ? loadTemplate(directory).index : syncTemplate(directory);
-    result = { status: 'passed', templateId: index.templateId, digest: index.digest, bindings: index.bindings.length };
-  }
-  process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
-} catch (error) { process.stderr.write(`${error.message}\n`); process.exitCode = 1; }

package/skills/i3-ui-prototype/scripts/template-adapters.cjs

@@ -1,89 +0,0 @@
-'use strict';
-const fs = require('node:fs');
-const path = require('node:path');
-const crypto = require('node:crypto');
-const assert = require('node:assert/strict');
-const builtins = Object.freeze({
-  'easel-html': require('./adapters/easel-html.cjs'),
-  'legacy-html': require('./adapters/legacy-html.cjs'),
-});
-const hash = bytes => crypto.createHash('sha256').update(bytes).digest('hex');
-const identifier = value => typeof value === 'string' && /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(value);
-function safePath(root, relative) {
-  assert.ok(typeof relative === 'string' && relative && !path.isAbsolute(relative) && !path.win32.isAbsolute(relative) && !relative.includes('\\') && relative.split('/').every(part => part && part !== '.' && part !== '..'), 'Unsafe template path / 模板路径无效');
-  let file = root;
-  for (const part of relative.split('/')) {
-    file = path.join(file, part);
-    assert.ok(!fs.lstatSync(file).isSymbolicLink(), 'Refusing template symlink / 模板符号链接');
-  }
-  return file;
-}
-function inventory(root, relative) {
-  const file = safePath(root, relative), stat = fs.statSync(file);
-  if (stat.isDirectory()) return fs.readdirSync(file).sort().flatMap(name => inventory(root, `${relative}/${name}`));
-  assert.ok(stat.isFile(), 'Template resource must be a regular file');
-  return [relative];
-}
-function createTemplateRegistry({ assetRoot = path.resolve(__dirname, '../assets/templates'), adapters = builtins } = {}) {
-  const root = fs.realpathSync(assetRoot);
-  const read = file => JSON.parse(fs.readFileSync(safePath(root, file), 'utf8'));
-  function catalog() {
-    const value = read('catalog.json');
-    assert.equal(value.schemaVersion, 2, 'Invalid template catalog');
-    assert.ok(Array.isArray(value.templates) && Array.isArray(value.legacyTemplates), 'Invalid template entries');
-    const ids = new Set();
-    for (const entry of [...value.templates, ...value.legacyTemplates]) {
-      assert.ok(identifier(entry.id) && !ids.has(entry.id), 'Duplicate or invalid template identifier'); ids.add(entry.id);
-      assert.ok(['available', 'planned', 'legacy'].includes(entry.availability), 'Invalid template availability');
-      if (entry.preview) {
-        const preview = entry.preview.split(/[?#]/)[0];
-        safePath(root, preview);
-      }
-    }
-    assert.ok(identifier(value.defaultTemplate) && value.templates.some(entry => entry.id === value.defaultTemplate && entry.availability === 'available'), 'Invalid default template');
-    return value;
-  }
-  function resolve(id) {
-    assert.ok(identifier(id), 'Invalid template identifier');
-    const value = catalog(), entry = [...value.templates, ...value.legacyTemplates].find(item => item.id === id);
-    assert.ok(entry, 'Unknown template');
-    assert.notEqual(entry.availability, 'planned', 'Template is planned / 该类型尚未建设，不能生成替代演示');
-    assert.ok(typeof entry.version === 'string' && entry.version, 'Template version is required');
-    assert.ok(typeof entry.manifest === 'string' && entry.manifest.startsWith(`${id}/`), 'Template manifest must belong to its template');
-    const manifest = read(entry.manifest);
-    assert.equal(manifest.schemaVersion, 1, 'Invalid template manifest');
-    assert.ok(identifier(manifest.adapter) && Object.hasOwn(adapters, manifest.adapter), 'Unknown template adapter; no common-runtime fallback');
-    const adapter = adapters[manifest.adapter], runtime = adapter.runtime;
-    assert.ok(typeof adapter.version === 'string' && adapter.version && ['fingerprintInputs', 'initialize', 'validateRuntime'].every(method => typeof adapter[method] === 'function'), 'Invalid template adapter contract');
-    assert.ok(runtime && identifier(runtime.kind), 'Invalid runtime contract');
-    for (const key of ['requiredFiles', 'identityFields', 'excludedBrowserPrefixes', 'protectedFiles', 'protectedDirectories']) assert.ok(Array.isArray(runtime[key]) && runtime[key].every(item => typeof item === 'string'), `Invalid runtime contract: ${key}`);
-    assert.ok(manifest.resources && typeof manifest.resources === 'object' && !Array.isArray(manifest.resources), 'Template resources are required');
-    assert.ok(typeof manifest.defaultTitle === 'string' && manifest.defaultTitle, 'Template default title is required');
-    safePath(root, manifest.preset);
-    for (const resource of Object.values(manifest.resources)) inventory(root, resource);
-    const context = { entry, manifest, resources: manifest.resources, resource(name) {
-      assert.ok(Object.hasOwn(manifest.resources, name), `Missing declared template resource: ${name}`);
-      return safePath(root, manifest.resources[name]);
-    } };
-    const inputs = adapter.fingerprintInputs(context);
-    assert.ok(Array.isArray(inputs) && inputs.length, 'Adapter fingerprint inputs are required');
-    const paths = [...new Set([entry.manifest, manifest.preset, ...inputs].flatMap(file => inventory(root, file)))].sort();
-    const implementations = [__filename, ...(adapter.implementationFiles || [])].map(file => ({ file: path.basename(file), digest: hash(fs.readFileSync(file)) }));
-    const digest = hash(JSON.stringify({ catalogEntry: entry, adapter: manifest.adapter, version: adapter.version, runtime, implementations, files: paths.map(file => [file, hash(fs.readFileSync(safePath(root, file)))]) }));
-    return { entry: { ...entry, digest }, adapterId: manifest.adapter, adapter, runtime, context, preset: read(manifest.preset) };
-  }
-  return {
-    defaultId: () => catalog().defaultTemplate,
-    resolve,
-    list(options = {}) {
-      const value = catalog(), entries = options.legacy ? value.legacyTemplates : options.includeLegacy ? [...value.templates, ...value.legacyTemplates] : value.templates;
-      return entries.map(entry => entry.availability === 'planned' ? { ...entry, digest: null } : resolve(entry.id).entry);
-    },
-    forInstance(metadata) {
-      const template = resolve(metadata.template?.id);
-      assert.ok(!metadata.template.adapter || metadata.template.adapter === template.adapterId, 'Template adapter does not match registered runtime');
-      return template;
-    },
-  };
-}
-module.exports = { createTemplateRegistry };