@punal_manalan/blender-project-harness 0.0.0-stage → 1.0.2

package/installer/install.mjs

@@ -0,0 +1,325 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { applyEdits, modify, parse, printParseErrorCode } from 'jsonc-parser';
+
+export const PACKAGE_NAME = '@punal_manalan/blender-project-harness';
+export const INSTALL_RELATIVE = '.kilo/blender-project-harness';
+export const BACKUP_RELATIVE = '.temp/blender-project-harness-backups';
+export const SERVER_RELATIVE = `${INSTALL_RELATIVE}/tools/harness/server.mjs`;
+
+const FORMAT = { formattingOptions: { insertSpaces: true, tabSize: 2 } };
+const GITIGNORE_HEADER = '# Blender project harness';
+const GITIGNORE_LINES = ['/.kilo/blender-project-harness/config.json', '.temp/'];
+
+function exists(file) {
+  try { fs.lstatSync(file); return true; } catch { return false; }
+}
+
+function readJson(file) {
+  return JSON.parse(fs.readFileSync(file, 'utf8').replace(/^\uFEFF/, ''));
+}
+
+function writeJson(file, value) {
+  fs.writeFileSync(file, JSON.stringify(value, null, 2) + '\n');
+}
+
+function copyFile(source, destination) {
+  fs.mkdirSync(path.dirname(destination), { recursive: true });
+  fs.copyFileSync(source, destination);
+}
+
+function copyTree(source, destination) {
+  const base = path.resolve(source);
+  const skip = new Set(['node_modules', '__pycache__', '.pytest_cache']);
+  fs.cpSync(source, destination, {
+    recursive: true,
+    filter: (candidate) => {
+      const relative = path.relative(base, path.resolve(candidate));
+      return !relative.split(path.sep).some((part) => skip.has(part));
+    },
+  });
+}
+
+function movePath(source, destination) {
+  fs.mkdirSync(path.dirname(destination), { recursive: true });
+  try {
+    fs.renameSync(source, destination);
+  } catch (error) {
+    if (error.code !== 'EXDEV') throw error;
+    copyTree(source, destination);
+    fs.rmSync(source, { recursive: true, force: true });
+  }
+}
+
+function stamp() {
+  return new Date().toISOString().replace(/[-:]/g, '').replace(/\.\d+Z$/, 'Z');
+}
+
+function uniqueBackup(root, version) {
+  const parent = path.join(root, BACKUP_RELATIVE);
+  const base = `${version || 'unknown'}-${stamp()}`;
+  let candidate = path.join(parent, base);
+  let index = 2;
+  while (exists(candidate)) candidate = path.join(parent, `${base}-${index++}`);
+  return candidate;
+}
+
+function installedVersion(installDir) {
+  const versionFile = path.join(installDir, 'VERSION');
+  if (exists(versionFile)) return fs.readFileSync(versionFile, 'utf8').trim() || null;
+  const stateFile = path.join(installDir, 'install.json');
+  if (!exists(stateFile)) return null;
+  try { return readJson(stateFile).version ?? null; } catch { return null; }
+}
+
+function readState(installDir) {
+  const file = path.join(installDir, 'install.json');
+  if (!exists(file)) return null;
+  try { return readJson(file); } catch { return null; }
+}
+
+function chooseConfig({ installDir, packageRoot, resetConfig }) {
+  if (!resetConfig) {
+    const current = path.join(installDir, 'config.json');
+    if (exists(current)) {
+      try {
+        JSON.parse(fs.readFileSync(current, 'utf8').replace(/^\uFEFF/, ''));
+        return current;
+      } catch (error) {
+        throw new Error(`invalid config ${current}: ${error.message}`);
+      }
+    }
+  }
+  const example = path.join(packageRoot, '.kilo', 'blender-project-harness', 'config.example.json');
+  if (!exists(example)) throw new Error(`package config example missing: ${example}`);
+  return example;
+}
+
+function runNpmCi(harnessDir) {
+  const args = ['ci', '--omit=dev', '--ignore-scripts', '--no-audit', '--no-fund'];
+  const result = spawnSync('npm', args, {
+    cwd: harnessDir,
+    env: process.env,
+    shell: process.platform === 'win32',
+    stdio: 'inherit',
+    windowsHide: false,
+  });
+  if (result.error) throw new Error(`npm ci failed to start: ${result.error.message}`);
+  if (result.status !== 0) throw new Error(`npm ci failed in ${harnessDir} with exit ${result.status}`);
+}
+
+function edit(text, pointer, value) {
+  const edits = modify(text, pointer, value, FORMAT);
+  return edits.length ? applyEdits(text, edits) : text;
+}
+
+function prepareKiloConfig(root) {
+  const file = path.join(root, '.kilo', 'kilo.jsonc');
+  let text = exists(file) ? fs.readFileSync(file, 'utf8') : '{\n  "$schema": "https://app.kilo.ai/config.json",\n  "mcp": {}\n}\n';
+  const errors = [];
+  parse(text, errors);
+  if (errors.length) {
+    throw new Error(`invalid .kilo/kilo.jsonc: ${printParseErrorCode(errors[0].error)} at offset ${errors[0].offset}`);
+  }
+  text = edit(text, ['mcp', 'blender', 'type'], 'local');
+  text = edit(text, ['mcp', 'blender', 'command'], ['node', SERVER_RELATIVE]);
+  text = edit(text, ['mcp', 'blender', 'enabled'], true);
+  const parsed = parse(text, []);
+  if (!parsed?.mcp?.blender?.environment?.BLENDER_PORT) {
+    text = edit(text, ['mcp', 'blender', 'environment', 'BLENDER_PORT'], '9877');
+  }
+  return text.endsWith('\n') ? text : `${text}\n`;
+}
+
+function preparePlugin() {
+  return [
+    "import { server } from '../blender-project-harness/tools/harness/plugin.mjs';",
+    '',
+    "export default { id: 'blender-workflow-harness', server };",
+    '',
+  ].join('\n');
+}
+
+function prepareGitignore(root) {
+  const file = path.join(root, '.gitignore');
+  const text = exists(file) ? fs.readFileSync(file, 'utf8') : '';
+  if (text.includes(GITIGNORE_HEADER)) return text;
+  const lines = [GITIGNORE_HEADER, ...GITIGNORE_LINES];
+  const separator = text && !text.endsWith('\n') ? '\n\n' : text ? '\n' : '';
+  return `${text}${separator}${lines.join('\n')}\n`;
+}
+
+function copyMissingFile(source, destination) {
+  if (exists(destination)) return false;
+  copyFile(source, destination);
+  return true;
+}
+
+function copyMissingTree(source, destination) {
+  if (!exists(source)) return [];
+  const copied = [];
+  const entries = fs.readdirSync(source, { withFileTypes: true });
+  for (const entry of entries) {
+    const from = path.join(source, entry.name);
+    const to = path.join(destination, entry.name);
+    if (entry.isDirectory()) {
+      if (!exists(to)) {
+        copyTree(from, to);
+        copied.push(path.relative(source, from));
+      } else {
+        copied.push(...copyMissingTree(from, to).map((name) => path.join(entry.name, name)));
+      }
+    } else if (entry.isFile() && !exists(to)) {
+      copyFile(from, to);
+      copied.push(entry.name);
+    }
+  }
+  return copied;
+}
+
+function backupWorkspaceFile(root, relative, version) {
+  const source = path.join(root, relative);
+  if (!exists(source)) return null;
+  const backup = path.join(root, BACKUP_RELATIVE, `${version || 'unknown'}-${stamp()}-workspace`, relative);
+  copyFile(source, backup);
+  return path.relative(root, backup).replaceAll('\\', '/');
+}
+
+function installSurfaces({ root, packageRoot, version, backupRoot }) {
+  const warnings = [];
+  const actions = [];
+  const written = [];
+  if (copyMissingFile(path.join(packageRoot, 'AGENTS.md'), path.join(root, 'AGENTS.md'))) actions.push('AGENTS.md');
+  if (copyMissingFile(path.join(packageRoot, 'README.md'), path.join(root, 'README.md'))) actions.push('README.md');
+  const skills = copyMissingTree(path.join(packageRoot, '.kilo', 'skills'), path.join(root, '.kilo', 'skills'));
+  if (skills.length) actions.push(`${skills.length} skill file(s)`);
+  const agents = copyMissingTree(path.join(packageRoot, '.kilo', 'agent'), path.join(root, '.kilo', 'agent'));
+  if (agents.length) actions.push(`${agents.length} agent file(s)`);
+  if (copyMissingFile(path.join(packageRoot, 'Blender', 'README.md'), path.join(root, 'Blender', 'README.md'))) actions.push('Blender/README.md');
+
+  const plugin = path.join(root, '.kilo', 'plugins', 'blender-workflow.js');
+  const pluginText = preparePlugin();
+  if (exists(plugin) && fs.readFileSync(plugin, 'utf8') !== pluginText) {
+    const backup = backupWorkspaceFile(root, '.kilo/plugins/blender-workflow.js', version);
+    if (backup) warnings.push(`previous plugin backed up to ${backup}`);
+  }
+  copyFile(path.join(packageRoot, '.kilo', 'plugins', 'blender-workflow.js'), plugin);
+  fs.writeFileSync(plugin, pluginText);
+  written.push('.kilo/plugins/blender-workflow.js');
+
+  const kiloFile = path.join(root, '.kilo', 'kilo.jsonc');
+  const kiloText = prepareKiloConfig(root);
+  const oldKilo = exists(kiloFile) ? fs.readFileSync(kiloFile, 'utf8') : null;
+  if (oldKilo !== kiloText) {
+    fs.mkdirSync(path.dirname(kiloFile), { recursive: true });
+    fs.writeFileSync(kiloFile, kiloText);
+    written.push('.kilo/kilo.jsonc');
+  }
+
+  const gitignoreFile = path.join(root, '.gitignore');
+  const gitignoreText = prepareGitignore(root);
+  if (!exists(gitignoreFile) || fs.readFileSync(gitignoreFile, 'utf8') !== gitignoreText) {
+    fs.writeFileSync(gitignoreFile, gitignoreText);
+    written.push('.gitignore');
+  }
+
+  if (backupRoot && exists(backupRoot)) warnings.push(`previous install backed up to ${path.relative(root, backupRoot).replaceAll('\\', '/')}`);
+  return { actions, warnings, written };
+}
+
+export function install({ root, packageRoot, version, skipDeps = false, resetConfig = false, force = false, dryRun = false }) {
+  root = path.resolve(root);
+  packageRoot = path.resolve(packageRoot);
+  if (!version) throw new Error('package version is missing');
+  const installDir = path.join(root, INSTALL_RELATIVE);
+  const previousVersion = exists(installDir) ? installedVersion(installDir) : null;
+  const current = previousVersion === version;
+  if (current && !force) {
+    return { ok: true, status: 'current', root, installDir, version, previousVersion, backup: null };
+  }
+  const backup = exists(installDir) ? uniqueBackup(root, previousVersion) : null;
+  const configSource = chooseConfig({ installDir, packageRoot, resetConfig });
+  const dependencies = skipDeps ? 'skipped' : 'install';
+  if (dryRun) {
+    return {
+      ok: true,
+      dryRun: true,
+      status: current ? 'current' : previousVersion ? 'update' : 'install',
+      root,
+      installDir,
+      version,
+      previousVersion,
+      backup: backup ? path.relative(root, backup).replaceAll('\\', '/') : null,
+      config: path.relative(root, configSource).replaceAll('\\', '/'),
+      dependencies,
+    };
+  }
+
+  const stage = path.join(root, '.kilo', `.blender-project-harness-${crypto.randomUUID().replaceAll('-', '')}`);
+  let moved = false;
+  const dependencyState = skipDeps ? 'skipped' : 'installed';
+  try {
+    fs.mkdirSync(stage, { recursive: true });
+    const source = path.join(packageRoot, '.kilo', 'blender-project-harness');
+    copyTree(path.join(source, 'tools'), path.join(stage, 'tools'));
+    copyFile(path.join(source, 'config.example.json'), path.join(stage, 'config.example.json'));
+    copyFile(configSource, path.join(stage, 'config.json'));
+    copyFile(path.join(packageRoot, 'AGENTS.md'), path.join(stage, 'AGENTS.md'));
+    fs.writeFileSync(path.join(stage, 'VERSION'), `${version}\n`);
+    if (!skipDeps) runNpmCi(path.join(stage, 'tools', 'harness'));
+    writeJson(path.join(stage, 'install.json'), {
+      schemaVersion: 1,
+      package: PACKAGE_NAME,
+      version,
+      installedAt: new Date().toISOString(),
+      dependencies: dependencyState,
+      node: process.version,
+      server: SERVER_RELATIVE,
+      agents: 'AGENTS.md',
+      backup: backup ? path.relative(root, backup).replaceAll('\\', '/') : null,
+    });
+
+    if (backup) {
+      movePath(installDir, backup);
+      moved = true;
+    }
+    try {
+      movePath(stage, installDir);
+    } catch (error) {
+      if (moved) movePath(backup, installDir);
+      throw error;
+    }
+  } catch (error) {
+    fs.rmSync(stage, { recursive: true, force: true });
+    throw error;
+  }
+
+  const surfaces = installSurfaces({ root, packageRoot, version, backupRoot: backup });
+  return {
+    ok: true,
+    status: previousVersion ? 'updated' : 'installed',
+    root,
+    installDir,
+    version,
+    previousVersion,
+    backup: backup ? path.relative(root, backup).replaceAll('\\', '/') : null,
+    dependencies: dependencyState,
+    ...surfaces,
+  };
+}
+
+export function status({ root }) {
+  root = path.resolve(root);
+  const installDir = path.join(root, INSTALL_RELATIVE);
+  const state = readState(installDir);
+  return {
+    installed: Boolean(state),
+    installDir,
+    version: state?.version ?? installedVersion(installDir),
+    installedAt: state?.installedAt ?? null,
+    backup: state?.backup ?? null,
+    server: state?.server ?? SERVER_RELATIVE,
+  };
+}

package/installer/install.test.mjs

@@ -0,0 +1,134 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import test from 'node:test';
+import { install, status } from './install.mjs';
+
+function makePackage(t) {
+  const temp = fs.mkdtempSync(path.join(os.tmpdir(), 'blender-harness-package-'));
+  t.after(() => fs.rmSync(temp, { recursive: true, force: true }));
+  const packageRoot = path.join(temp, 'package');
+  const write = (name, text) => {
+    const file = path.join(packageRoot, name);
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, text);
+    return file;
+  };
+  write('.kilo/blender-project-harness/tools/harness/server.mjs', '// server\n');
+  write('.kilo/blender-project-harness/tools/harness/package.json', '{ "type": "module" }\n');
+  write('.kilo/blender-project-harness/tools/harness/package-lock.json', '{}\n');
+  write('.kilo/blender-project-harness/config.example.json', JSON.stringify({ blender_subagents: { graders: { enabled: true } } }) + '\n');
+  write('AGENTS.md', '# Agent contract\n');
+  write('README.md', '# Package readme\n');
+  write('.kilo/skills/test-skill/SKILL.md', '# Skill\n');
+  write('.kilo/agent/blender-worker.md', '---\nsteps: 10\n---\n');
+  write('.kilo/plugins/blender-workflow.js', "import { server } from '../../.kilo/blender-project-harness/tools/harness/plugin.mjs';\n");
+  write('Blender/README.md', '# Projects\n');
+  return { temp, packageRoot };
+}
+
+function makeWorkspace(t) {
+  const temp = fs.mkdtempSync(path.join(os.tmpdir(), 'blender-harness-workspace-'));
+  t.after(() => fs.rmSync(temp, { recursive: true, force: true }));
+  const root = path.join(temp, 'workspace');
+  fs.mkdirSync(path.join(root, '.kilo'), { recursive: true });
+  fs.writeFileSync(path.join(root, '.kilo', 'kilo.jsonc'), [
+    '{',
+    '  // keep this comment',
+    '  "mcp": {',
+    '    "blender": {',
+    '      "type": "local",',
+    '      "command": ["node", "tools/harness/server.mjs"],',
+    '      "enabled": true,',
+    '      "environment": { "BLENDER_PORT": "9877" }',
+    '    }',
+    '  }',
+    '}',
+    '',
+  ].join('\n'));
+  return { temp, root };
+}
+
+test('installs the harness, config, and workspace surfaces', (t) => {
+  const { packageRoot } = makePackage(t);
+  const { root } = makeWorkspace(t);
+  const result = install({ root, packageRoot, version: '1.0.0', skipDeps: true });
+  assert.equal(result.status, 'installed');
+  assert.equal(result.dependencies, 'skipped');
+  assert.equal(fs.readFileSync(path.join(root, '.kilo', 'blender-project-harness', 'VERSION'), 'utf8').trim(), '1.0.0');
+  assert.equal(JSON.parse(fs.readFileSync(path.join(root, '.kilo', 'blender-project-harness', 'config.json'), 'utf8')).blender_subagents.graders.enabled, true);
+  assert.equal(fs.existsSync(path.join(root, '.kilo', 'blender-project-harness', 'tools', 'harness', 'server.mjs')), true);
+  assert.equal(fs.readFileSync(path.join(root, '.kilo', 'blender-project-harness', 'AGENTS.md'), 'utf8'), '# Agent contract\n');
+  assert.match(fs.readFileSync(path.join(root, '.kilo', 'kilo.jsonc'), 'utf8'), /keep this comment/);
+  assert.match(fs.readFileSync(path.join(root, '.kilo', 'kilo.jsonc'), 'utf8'), /\.kilo\/blender-project-harness\/tools\/harness\/server\.mjs/);
+  assert.match(fs.readFileSync(path.join(root, '.kilo', 'plugins', 'blender-workflow.js'), 'utf8'), /\.\.\/blender-project-harness\/tools\/harness\/plugin\.mjs/);
+  assert.equal(fs.existsSync(path.join(root, 'AGENTS.md')), true);
+  assert.equal(fs.existsSync(path.join(root, '.kilo', 'skills', 'test-skill', 'SKILL.md')), true);
+  assert.match(fs.readFileSync(path.join(root, '.gitignore'), 'utf8'), /\.kilo\/blender-project-harness\/config\.json/);
+  assert.equal(status({ root }).installed, true);
+});
+
+test('updates to a new version, backs up the old tree, and preserves config', (t) => {
+  const { packageRoot } = makePackage(t);
+  const { root } = makeWorkspace(t);
+  const config = path.join(root, '.kilo', 'blender-project-harness', 'config.json');
+  fs.mkdirSync(path.dirname(config), { recursive: true });
+  fs.writeFileSync(config, JSON.stringify({ custom: true }) + '\n');
+  install({ root, packageRoot, version: '1.0.0', skipDeps: true });
+  fs.writeFileSync(path.join(packageRoot, 'AGENTS.md'), '# Agent contract v2\n');
+  const updated = install({ root, packageRoot, version: '2.0.0', skipDeps: true });
+  assert.equal(updated.status, 'updated');
+  assert.ok(updated.backup);
+  assert.equal(fs.readFileSync(path.join(root, '.kilo', 'blender-project-harness', 'VERSION'), 'utf8').trim(), '2.0.0');
+  assert.equal(JSON.parse(fs.readFileSync(path.join(root, '.kilo', 'blender-project-harness', 'config.json'), 'utf8')).custom, true);
+  assert.equal(fs.readFileSync(path.join(root, '.kilo', 'blender-project-harness', 'AGENTS.md'), 'utf8'), '# Agent contract v2\n');
+  assert.equal(fs.readFileSync(path.join(root, 'AGENTS.md'), 'utf8'), '# Agent contract\n');
+  assert.equal(fs.readFileSync(path.join(root, updated.backup, 'VERSION'), 'utf8').trim(), '1.0.0');
+  assert.equal(fs.readFileSync(path.join(root, updated.backup, 'AGENTS.md'), 'utf8'), '# Agent contract\n');
+});
+
+test('same version is idempotent unless forced', (t) => {
+  const { packageRoot } = makePackage(t);
+  const { root } = makeWorkspace(t);
+  install({ root, packageRoot, version: '1.0.0', skipDeps: true });
+  const current = install({ root, packageRoot, version: '1.0.0', skipDeps: true });
+  assert.equal(current.status, 'current');
+  const forced = install({ root, packageRoot, version: '1.0.0', skipDeps: true, force: true });
+  assert.equal(forced.status, 'updated');
+  assert.ok(forced.backup);
+});
+
+test('dry-run reports the plan without writing', (t) => {
+  const { packageRoot } = makePackage(t);
+  const { root } = makeWorkspace(t);
+  const result = install({ root, packageRoot, version: '1.0.0', skipDeps: true, dryRun: true });
+  assert.equal(result.dryRun, true);
+  assert.equal(result.status, 'install');
+  assert.equal(fs.existsSync(path.join(root, '.kilo', 'blender-project-harness')), false);
+});
+
+test('reset-config uses the package example', (t) => {
+  const { packageRoot } = makePackage(t);
+  const { root } = makeWorkspace(t);
+  install({ root, packageRoot, version: '1.0.0', skipDeps: true });
+  install({ root, packageRoot, version: '2.0.0', skipDeps: true, resetConfig: true });
+  const config = JSON.parse(fs.readFileSync(path.join(root, '.kilo', 'blender-project-harness', 'config.json'), 'utf8'));
+  assert.equal(config.custom, undefined);
+  assert.equal(config.blender_subagents.graders.enabled, true);
+});
+
+test('CLI installs, reports status, and prints JSON', (t) => {
+  const { root } = makeWorkspace(t);
+  const bin = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', 'bin', 'blender-project-harness.mjs');
+  const installResult = spawnSync(process.execPath, [bin, 'install', '--root', root, '--skip-deps', '--json'], { encoding: 'utf8' });
+  assert.equal(installResult.status, 0, installResult.stderr);
+  const installed = JSON.parse(installResult.stdout);
+  assert.equal(installed.status, 'installed');
+  assert.equal(fs.existsSync(path.join(root, '.kilo', 'blender-project-harness', 'VERSION')), true);
+  const statusResult = spawnSync(process.execPath, [bin, 'status', '--root', root, '--json'], { encoding: 'utf8' });
+  assert.equal(statusResult.status, 0, statusResult.stderr);
+  assert.equal(JSON.parse(statusResult.stdout).installed, true);
+});

package/package.json

@@ -1,6 +1,58 @@
-{
-  "name": "@punal_manalan/blender-project-harness",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+{
+  "name": "@punal_manalan/blender-project-harness",
+  "version": "1.0.2",
+  "description": "Install and update the guarded Blender project harness for Kilo workspaces.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/punal100/blender-project-harness.git"
+  },
+  "homepage": "https://github.com/punal100/blender-project-harness#readme",
+  "bugs": {
+    "url": "https://github.com/punal100/blender-project-harness/issues"
+  },
+  "author": "Punal Manalan",
+  "type": "module",
+  "bin": {
+    "blender-project-harness": "bin/blender-project-harness.mjs"
+  },
+  "files": [
+    "AGENTS.md",
+    "Blender/README.md",
+    "CHANGELOG.md",
+    "LICENSE",
+    "README.md",
+    "THIRD_PARTY_NOTICES.md",
+    "bin/",
+    "installer/",
+    ".kilo/blender-project-harness/config.example.json",
+    ".kilo/blender-project-harness/tools/",
+    "!.kilo/blender-project-harness/tools/**/node_modules/",
+    "!.kilo/blender-project-harness/tools/**/__pycache__/",
+    "!.kilo/blender-project-harness/tools/**/.pytest_cache/",
+    ".kilo/agent/",
+    ".kilo/plugins/",
+    ".kilo/skills/"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "scripts": {
+    "test": "node --test installer/*.test.mjs .kilo/blender-project-harness/tools/harness/*.test.mjs",
+    "test:installer": "node --test installer/*.test.mjs",
+    "pack:check": "npm pack --dry-run"
+  },
+  "dependencies": {
+    "jsonc-parser": "3.3.1"
+  },
+  "keywords": [
+    "blender",
+    "kilo",
+    "mcp",
+    "workflow",
+    "harness"
+  ],
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  }
+}