@geraldmaron/construct 1.2.2 → 1.3.0

package/lib/chat/web-launcher.mjs

@@ -1,63 +0,0 @@
-/**
- * lib/chat/web-launcher.mjs — start dashboard server and open /chat for construct chat --web.
- *
- * Reuses lib/service-manager.mjs startDashboard so the browser surface shares auth,
- * CSRF, and static hosting with the operations dashboard.
- */
-
-import { spawn } from 'node:child_process';
-import { startDashboard, readDashboardState } from '../service-manager.mjs';
-
-function openBrowser(url) {
-  const platform = process.platform;
-  let cmd;
-  let args;
-  if (platform === 'darwin') {
-    cmd = 'open';
-    args = [url];
-  } else if (platform === 'win32') {
-    cmd = 'cmd';
-    args = ['/c', 'start', '', url];
-  } else {
-    cmd = 'xdg-open';
-    args = [url];
-  }
-  try {
-    spawn(cmd, args, { detached: true, stdio: 'ignore' }).unref();
-  } catch {
-    /* browser open is best-effort */
-  }
-}
-
-export async function runWebChat({
-  cwd = process.cwd(),
-  env = process.env,
-  output = process.stdout,
-  errorOutput = process.stderr,
-  surface = null,
-} = {}) {
-  let dash = readDashboardState();
-  if (!dash?.port) {
-    const result = await startDashboard({ rootDir: cwd, preferredPort: parseInt(env.PORT || env.DASHBOARD_PORT || '4242', 10) });
-    if (result.started || result.reused) {
-      dash = { port: result.port, url: result.url || `http://127.0.0.1:${result.port}` };
-    } else {
-      errorOutput.write(`Failed to start dashboard: ${result.reason || 'unknown error'}\n`);
-      return 1;
-    }
-  }
-
-  const base = (dash.url || `http://127.0.0.1:${dash.port}`).replace(/\/$/, '');
-  const chatUrl = surface === 'desktop'
-    ? `${base}/chat/?surface=desktop`
-    : `${base}/chat/`;
-  output.write(`Construct web chat: ${chatUrl}\n`);
-  output.write('Press Ctrl-C to stop the dashboard server.\n');
-  openBrowser(chatUrl);
-
-  await new Promise((resolve) => {
-    process.once('SIGINT', resolve);
-    process.once('SIGTERM', resolve);
-  });
-  return 0;
-}

package/lib/chat/web-picker-keys.mjs

@@ -1,46 +0,0 @@
-/**
- * lib/chat/web-picker-keys.mjs — keyboard routing for the web list picker.
- *
- * Arrow/enter/escape handling shared with Ink via list-picker.mjs; this module
- * adapts DOM KeyboardEvent shapes for tests and the React overlay.
- */
-
-import {
-  getPickerSelectedItem,
-  getPickerVisibleItems,
-  movePickerIndex,
-  reducePickerKey,
-} from './list-picker.mjs';
-
-export { getPickerSelectedItem, getPickerVisibleItems, movePickerIndex };
-
-export function domKeyToPickerKey(event) {
-  const key = event?.key || '';
-  return {
-    char: key.length === 1 && !event.ctrlKey && !event.metaKey && !event.altKey ? key : undefined,
-    key: {
-      escape: key === 'Escape',
-      return: key === 'Enter',
-      upArrow: key === 'ArrowUp',
-      downArrow: key === 'ArrowDown',
-      backspace: key === 'Backspace',
-      delete: key === 'Delete',
-      ctrl: event.ctrlKey,
-      meta: event.metaKey,
-    },
-  };
-}
-
-export function isPickerNavigationKey(key) {
-  return key === 'ArrowUp' || key === 'ArrowDown' || key === 'Enter' || key === 'Escape';
-}
-
-export function reduceWebPickerKey(state, event) {
-  return reducePickerKey(state, domKeyToPickerKey(event));
-}
-
-export function commitWebPickerSelection(state) {
-  const item = getPickerSelectedItem(state);
-  if (!item || item.disabled) return { ok: false, item: null };
-  return { ok: true, item };
-}

package/lib/chat/web-session.mjs

@@ -1,159 +0,0 @@
-/**
- * lib/chat/web-session.mjs — owned-loop runtime factory for browser chat.
- *
- * Builds the same driver + session shape as lib/chat/cli.mjs so dashboard SSE
- * and construct chat --web share one configuration path. One runtime instance
- * is kept per conversation id for the lifetime of the server process.
- */
-import { randomBytes } from 'crypto';
-import { createOwnedLoopDriver } from '../../apps/chat/engine/loop-driver.mjs';
-import { resolveChatModelSelectionAsync, resolveSessionModel } from '../../apps/chat/engine/models.mjs';
-import { loadChatConfig } from './config.mjs';
-import { loadConstructEnv } from '../env-config.mjs';
-import { resolveLayers } from './transparency.mjs';
-import { buildSystemPrompt } from './system-prompt.mjs';
-import { createSessionUsage } from './tui/usage.mjs';
-import { resolveExecutionCapabilityProfile } from '../models/execution-capability-profile.mjs';
-import { compileExecutionPolicy } from '../models/execution-policy.mjs';
-import { resolveDemoGuideForChat } from '../demo-surface.mjs';
-
-const runtimes = new Map();
-const pendingPermissions = new Map();
-
-function createPermissionHandler({ session, onPermission = null }) {
-  return async (req) => {
-    const mode = session.permissionMode || 'allow_once';
-    if (mode === 'reject') return 'reject';
-    if (mode === 'allow_always') return 'allow_always';
-    if (mode === 'allow_once') return 'allow';
-    if (mode === 'ask') {
-      const requestId = req.requestId || `perm-${randomBytes(8).toString('hex')}`;
-      onPermission?.({
-        type: 'permission',
-        requestId,
-        toolCall: { title: req.tool || req.toolCall?.title || 'tool', input: req.input ?? null },
-        options: ['allow', 'allow_always', 'reject'],
-      });
-      return new Promise((resolve) => {
-        pendingPermissions.set(requestId, { resolve, req, convId: session.convId });
-        setTimeout(() => {
-          if (pendingPermissions.has(requestId)) {
-            pendingPermissions.delete(requestId);
-            resolve('reject');
-          }
-        }, 120_000);
-      });
-    }
-    return 'allow';
-  };
-}
-
-export function resolveWebPermission(requestId, decision) {
-  const pending = pendingPermissions.get(requestId);
-  if (!pending) return false;
-  pendingPermissions.delete(requestId);
-  pending.resolve(decision);
-  return true;
-}
-
-export function listPendingPermissions(convId) {
-  return [...pendingPermissions.entries()]
-    .filter(([, p]) => p.convId === convId)
-    .map(([requestId, p]) => ({
-      requestId,
-      title: p.req?.toolCall?.title || 'tool',
-      options: p.req?.options || ['allow', 'reject'],
-    }));
-}
-
-export function getWebChatRuntime(convId) {
-  return runtimes.get(convId) || null;
-}
-
-export async function ensureWebChatRuntime({
-  convId,
-  cwd = process.cwd(),
-  env = process.env,
-  onPermission = null,
-} = {}) {
-  if (runtimes.has(convId)) return runtimes.get(convId);
-
-  const effectiveEnv = loadConstructEnv({ rootDir: cwd, env, warn: false });
-  const { config } = loadChatConfig({ cwd });
-  const layers = resolveLayers({ flags: {}, env: effectiveEnv });
-  for (const key of Object.keys(config.layers || {})) {
-    if (config.layers[key] === false) layers[key] = false;
-  }
-
-  let modelMode = config.modelMode || 'pinned';
-  let resolvedModel = config.model || null;
-  if (modelMode === 'free-router') {
-    const sessionStub = { modelMode: 'free-router', failedModels: new Set() };
-    resolvedModel = await resolveSessionModel(sessionStub, { env: effectiveEnv, tier: 'standard' });
-  }
-
-  const modelResolution = modelMode === 'free-router' && resolvedModel
-    ? { id: resolvedModel, notice: null }
-    : await resolveChatModelSelectionAsync({ env: effectiveEnv, requested: resolvedModel });
-
-  const demoName = effectiveEnv.CONSTRUCT_DEMO || null;
-  const demoPack = demoName ? resolveDemoGuideForChat(demoName, { cwd, repoRoot: cwd }) : null;
-
-  const session = {
-    convId,
-    model: modelResolution.id || resolvedModel,
-    modelMode,
-    permissionMode: config.permissionMode || 'allow_once',
-    sandbox: config.sandbox || 'workspace-write',
-    layers,
-    usage: createSessionUsage(),
-    demoGuide: demoPack?.guide || null,
-    demoTitle: demoPack?.script?.title || null,
-  };
-
-  const handlers = {
-    getSandbox: () => session.sandbox,
-    getPermissionMode: () => session.permissionMode,
-    requestPermission: createPermissionHandler({ session, onPermission }),
-  };
-
-  const { createAiSdkAgent } = await import('../../apps/chat/engine/ai-sdk-agent.mjs');
-  const driver = createOwnedLoopDriver({
-    env: effectiveEnv,
-    cwd,
-    model: session.model,
-    handlers,
-    systemPrompt: buildSystemPrompt({
-      capabilityTier: compileExecutionPolicy({
-        profile: resolveExecutionCapabilityProfile({ model: session.model }),
-      }).prompt.systemPromptTier,
-    }),
-    createAgent: (opts) => createAiSdkAgent(opts),
-  });
-
-  const runtime = { convId, driver, session, layers, cwd, env: effectiveEnv, _started: false };
-  runtimes.set(convId, runtime);
-
-  if (!demoPack?.guide) {
-    await driver.start();
-    runtime._started = true;
-  }
-
-  return runtime;
-}
-
-export async function ensureDriverStarted(runtime) {
-  if (!runtime || runtime._started) return runtime;
-  await runtime.driver.start();
-  runtime._started = true;
-  return runtime;
-}
-
-export const createWebChatRuntime = ensureWebChatRuntime;
-
-export function dropWebChatRuntime(convId) {
-  const runtime = runtimes.get(convId);
-  if (!runtime) return;
-  try { runtime.driver.stop?.(); } catch { /* already stopped */ }
-  runtimes.delete(convId);
-}

package/lib/config/alias.mjs

@@ -1,57 +0,0 @@
-/**
- * lib/config/alias.mjs — resolves the user-facing Construct alias.
- *
- * Lookup precedence:
- *   1. CONSTRUCT_ALIAS env var (per-session override)
- *   2. config.json.aliasOverride in the XDG config dir (user-level, lets each
- *      user on the same project see their own branding without
- *      committing it)
- *   3. construct.config.json.alias (project-level, committed)
- *   4. "Construct" (the default)
- *
- * Pure resolution — no fs writes. The alias flows to the dashboard
- * wordmark (via /api/alias), persona prompts ({{alias}} template at
- * sync time), and CLI banner output.
- */
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { loadProjectConfig } from './project-config.mjs';
-import { configDir } from './xdg.mjs';
-
-export const DEFAULT_ALIAS = 'Construct';
-export const ALIAS_ENV_KEY = 'CONSTRUCT_ALIAS';
-export const ALIAS_TEMPLATE_TOKEN = /\{\{alias\}\}/g;
-
-export function resolveAlias({ cwd = process.cwd(), env = process.env, homeDir = os.homedir() } = {}) {
-  const envAlias = env?.[ALIAS_ENV_KEY];
-  if (typeof envAlias === 'string' && envAlias.trim()) {
-    return { value: envAlias.trim(), source: 'env' };
-  }
-
-  try {
-    const userCfgPath = path.join(configDir(homeDir), 'config.json');
-    if (fs.existsSync(userCfgPath)) {
-      const userCfg = JSON.parse(fs.readFileSync(userCfgPath, 'utf8'));
-      const userAlias = userCfg?.aliasOverride;
-      if (typeof userAlias === 'string' && userAlias.trim()) {
-        return { value: userAlias.trim(), source: 'user' };
-      }
-    }
-  } catch { /* user file is best-effort */ }
-
-  try {
-    const { config, source } = loadProjectConfig(cwd, env);
-    if (source === 'file' && typeof config?.alias === 'string' && config.alias.trim()) {
-      return { value: config.alias.trim(), source: 'project' };
-    }
-  } catch { /* project config is best-effort */ }
-
-  return { value: DEFAULT_ALIAS, source: 'default' };
-}
-
-export function applyAliasToTemplate(text, alias) {
-  if (typeof text !== 'string') return text;
-  const safe = String(alias ?? DEFAULT_ALIAS).trim() || DEFAULT_ALIAS;
-  return text.replace(ALIAS_TEMPLATE_TOKEN, safe);
-}

package/lib/dashboard-demo.mjs

@@ -1,71 +0,0 @@
-/**
- * lib/dashboard-demo.mjs — Construct cockpit Playwright demo adapter.
- *
- * Resolves dashboard recording manifests (or legacy script bridge) and delegates
- * to lib/playwright-demo.mjs with dashboard workspace defaults.
- */
-
-import path from 'node:path';
-import { loadDemoRecording } from './demo-recording.mjs';
-import {
-  detectPlaywrightDemo,
-  recordPlaywrightDemo,
-  collectVideoFiles,
-  newestVideo,
-  finalizeDemoVideo,
-  locateFfmpeg,
-  transcodeWebmToMp4,
-  resolvePlaywrightPackage,
-} from './playwright-demo.mjs';
-
-export {
-  collectVideoFiles,
-  newestVideo,
-  finalizeDemoVideo,
-  locateFfmpeg,
-  transcodeWebmToMp4,
-  resolvePlaywrightPackage,
-};
-
-export function dashboardWorkspaceRoot(repoRoot) {
-  return path.join(repoRoot, 'apps', 'dashboard');
-}
-
-export function detectDashboardDemo({ cwd = process.cwd(), repoRoot } = {}) {
-  const root = repoRoot || cwd;
-  return detectPlaywrightDemo({ workspace: dashboardWorkspaceRoot(root), repoRoot: root, cwd });
-}
-
-export function recordDashboardDemo(name, {
-  cwd = process.cwd(),
-  repoRoot,
-  outputDir,
-  outputPath = null,
-  format = 'mp4',
-  artifactDir = null,
-  artifactFile = null,
-  env = process.env,
-} = {}) {
-  const root = repoRoot || cwd;
-  const recording = loadDemoRecording(name, { cwd, repoRoot: root });
-
-  if (!recording) {
-    const detection = detectDashboardDemo({ cwd, repoRoot: root });
-    if (!detection.present) {
-      return { ok: false, name, missing: detection.missing, message: detection.message };
-    }
-    return { ok: false, name, message: `No recording manifest or dashboard demo script for ${name}` };
-  }
-
-  const outDir = outputDir || path.join(cwd, '.cx', 'demos', 'dashboard');
-  return recordPlaywrightDemo(recording, {
-    cwd,
-    repoRoot: root,
-    outputDir: outDir,
-    outputPath,
-    format,
-    artifactDir,
-    artifactFile,
-    env,
-  });
-}

package/lib/dashboard-static.mjs

@@ -1,175 +0,0 @@
-/**
- * lib/dashboard-static.mjs — build and sync the dashboard static bundle.
- *
- * Keeps the Next.js static export at `apps/dashboard/out/` and the served
- * tree at `lib/server/static/` aligned so the HTTP server picks up the
- * current dashboard build without code changes. Pre-2.0 the dashboard
- * lived at `dashboard/dist/`; the rebuild to Next.js (commit 84cd721)
- * moved the source of truth into `apps/dashboard/out/`.
- */
-
-import fs from 'node:fs';
-import path from 'node:path';
-import { spawnSync } from 'node:child_process';
-import { sanitizeNpmSpawnEnv } from './npm-spawn-env.mjs';
-
-function walkFiles(rootDir, currentDir = rootDir) {
-  if (!fs.existsSync(currentDir)) return [];
-  const entries = [];
-  for (const name of fs.readdirSync(currentDir)) {
-    const fullPath = path.join(currentDir, name);
-    const stat = fs.statSync(fullPath);
-    if (stat.isDirectory()) {
-      entries.push(...walkFiles(rootDir, fullPath));
-    } else {
-      entries.push(path.relative(rootDir, fullPath));
-    }
-  }
-  return entries.sort();
-}
-
-function readBufferIfExists(filePath) {
-  if (!fs.existsSync(filePath)) return null;
-  return fs.readFileSync(filePath);
-}
-
-function compareTrees(sourceDir, targetDir) {
-  const sourceFiles = walkFiles(sourceDir);
-  const targetFiles = walkFiles(targetDir);
-  const sourceSet = new Set(sourceFiles);
-  const targetSet = new Set(targetFiles);
-  const copied = [];
-  const removed = [];
-
-  for (const relPath of sourceFiles) {
-    const source = readBufferIfExists(path.join(sourceDir, relPath));
-    const target = readBufferIfExists(path.join(targetDir, relPath));
-    if (!target || !source.equals(target)) copied.push(relPath);
-  }
-
-  for (const relPath of targetFiles) {
-    if (!sourceSet.has(relPath)) removed.push(relPath);
-  }
-
-  return {
-    copied,
-    removed,
-    sourceFiles,
-    targetFiles,
-    changed: copied.length > 0 || removed.length > 0,
-    inSync: copied.length === 0 && removed.length === 0,
-    sourceExists: fs.existsSync(sourceDir),
-  };
-}
-
-function ensureParentDir(filePath) {
-  fs.mkdirSync(path.dirname(filePath), { recursive: true });
-}
-
-function removeEmptyDirs(dirPath, stopAt) {
-  let current = dirPath;
-  while (current.startsWith(stopAt) && current !== stopAt) {
-    if (!fs.existsSync(current)) {
-      current = path.dirname(current);
-      continue;
-    }
-    if (fs.readdirSync(current).length > 0) break;
-    fs.rmdirSync(current);
-    current = path.dirname(current);
-  }
-}
-
-export function getDashboardPaths({ rootDir = process.cwd() } = {}) {
-  return {
-    rootDir,
-    dashboardDir: path.join(rootDir, 'apps', 'dashboard'),
-    sourceDir: path.join(rootDir, 'apps', 'dashboard', 'out'),
-    targetDir: path.join(rootDir, 'lib', 'server', 'static'),
-  };
-}
-
-export function getDashboardStaticStatus({ rootDir = process.cwd() } = {}) {
-  const { sourceDir, targetDir } = getDashboardPaths({ rootDir });
-  return compareTrees(sourceDir, targetDir);
-}
-
-export function syncDashboardStatic({ rootDir = process.cwd(), check = false } = {}) {
-  const { sourceDir, targetDir } = getDashboardPaths({ rootDir });
-  if (!fs.existsSync(sourceDir)) {
-    throw new Error(`Dashboard build output missing: ${sourceDir}`);
-  }
-
-  const status = compareTrees(sourceDir, targetDir);
-  if (check || !status.changed) return status;
-
-  for (const relPath of status.copied) {
-    const sourcePath = path.join(sourceDir, relPath);
-    const targetPath = path.join(targetDir, relPath);
-    ensureParentDir(targetPath);
-    fs.copyFileSync(sourcePath, targetPath);
-  }
-
-  for (const relPath of status.removed) {
-    const targetPath = path.join(targetDir, relPath);
-    fs.rmSync(targetPath, { force: true });
-    removeEmptyDirs(path.dirname(targetPath), targetDir);
-  }
-
-  return {
-    ...status,
-    inSync: true,
-  };
-}
-
-export function buildDashboardStatic({
-  rootDir = process.cwd(),
-  spawnSyncFn = spawnSync,
-} = {}) {
-  const { dashboardDir } = getDashboardPaths({ rootDir });
-  const nextCache = path.join(dashboardDir, '.next');
-  fs.rmSync(nextCache, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 });
-
-  const env = sanitizeNpmSpawnEnv(process.env);
-  let result;
-  for (let attempt = 1; attempt <= 2; attempt += 1) {
-    result = spawnSyncFn('npm', ['--prefix', dashboardDir, 'run', 'build'], {
-      cwd: rootDir,
-      encoding: 'utf8',
-      stdio: ['ignore', 'pipe', 'pipe'],
-      env,
-    });
-    if (result.status === 0) break;
-    const output = `${result.stdout || ''}\n${result.stderr || ''}`;
-    const transientRename = /ENOENT.*rename.*\.next\/(export|server\/pages)\/500\.html/.test(output);
-    if (!transientRename) break;
-    fs.rmSync(nextCache, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 });
-  }
-  if (result.status !== 0) {
-    throw new Error((result.stderr || result.stdout || 'dashboard build failed').trim());
-  }
-  return result;
-}
-
-export async function runDashboardStaticCli(args = [], { rootDir = process.cwd() } = {}) {
-  const build = args.includes('--build');
-  const check = args.includes('--check');
-
-  if (build) buildDashboardStatic({ rootDir });
-  const status = syncDashboardStatic({ rootDir, check });
-
-  if (check) {
-    if (status.changed) {
-      console.error('Dashboard static assets are out of date. Run `construct dashboard:sync --build`.');
-      return 1;
-    }
-    console.log('Dashboard static assets are up to date.');
-    return 0;
-  }
-
-  if (status.changed) {
-    console.log(`Dashboard static synced: ${status.copied.length} updated, ${status.removed.length} removed.`);
-  } else {
-    console.log('Dashboard static already up to date.');
-  }
-  return 0;
-}

package/lib/install/desktop-binary-download.mjs

@@ -1,88 +0,0 @@
-/**
- * lib/install/desktop-binary-download.mjs — downloads the Construct chat desktop binary.
- *
- * Fetches the platform-matching construct-chat binary from the latest GitHub
- * release and writes it to the bin/ subdir of the XDG state dir. Called by
- * `construct install --scope=user`.
- * Network failures are non-fatal: returns { status: 'skipped', reason } so the
- * rest of setup can proceed without the desktop binary.
- */
-
-import fs from 'node:fs';
-import path from 'node:path';
-
-import { stateDir } from '../config/xdg.mjs';
-
-const GITHUB_REPO = 'geraldmaron/construct';
-
-function assetName() {
-  const plat = process.platform;
-  const arch = process.arch === 'arm64' ? 'arm64' : 'x64';
-  if (plat === 'win32') return 'construct-chat-windows-x64.exe';
-  if (plat === 'darwin') return `construct-chat-darwin-${arch}`;
-  return `construct-chat-linux-${arch}`;
-}
-
-function destBinaryName() {
-  return process.platform === 'win32' ? 'construct-chat.exe' : 'construct-chat';
-}
-
-async function fetchRelease(env) {
-  const headers = { 'User-Agent': 'construct-installer/1.0' };
-  if (env.GITHUB_TOKEN) headers['Authorization'] = `Bearer ${env.GITHUB_TOKEN}`;
-  const res = await fetch(`https://api.github.com/repos/${GITHUB_REPO}/releases/latest`, { headers });
-  if (!res.ok) throw new Error(`GitHub API ${res.status}: ${await res.text().then((t) => t.slice(0, 120))}`);
-  return res.json();
-}
-
-async function downloadAsset(url, dest, env) {
-  const headers = {
-    'User-Agent': 'construct-installer/1.0',
-    'Accept': 'application/octet-stream',
-  };
-  if (env.GITHUB_TOKEN) headers['Authorization'] = `Bearer ${env.GITHUB_TOKEN}`;
-  const res = await fetch(url, { headers, redirect: 'follow' });
-  if (!res.ok) throw new Error(`Download ${res.status}: ${url}`);
-  const buf = await res.arrayBuffer();
-  fs.writeFileSync(dest, Buffer.from(buf));
-}
-
-// Returns { status: 'downloaded'|'skipped'|'failed' }; 'skipped' and 'failed' are both non-fatal.
-export async function downloadDesktopBinary({ homeDir, env = process.env } = {}) {
-  const binDir = path.join(stateDir(homeDir), 'bin');
-  const dest = path.join(binDir, destBinaryName());
-  const name = assetName();
-
-  let release;
-  try {
-    release = await fetchRelease(env);
-  } catch (err) {
-    return { status: 'skipped', reason: `GitHub API unreachable: ${err.message}` };
-  }
-
-  const asset = release.assets?.find((a) => a.name === name);
-  if (!asset) {
-    return {
-      status: 'skipped',
-      reason: `No desktop binary in ${release.tag_name} for this platform (looked for ${name})`,
-    };
-  }
-
-  fs.mkdirSync(binDir, { recursive: true });
-
-  try {
-    await downloadAsset(asset.browser_download_url, dest, env);
-  } catch (err) {
-    return { status: 'failed', reason: err.message };
-  }
-
-  if (process.platform !== 'win32') {
-    try {
-      fs.chmodSync(dest, 0o755);
-    } catch {
-      /* best effort */
-    }
-  }
-
-  return { status: 'downloaded', dest, version: release.tag_name };
-}