@nyte-ai/host 0.0.0-stage → 0.0.18

package/dist/chunks/canvas-preview-mgcx2b2p.js

@@ -0,0 +1,271 @@
+// src/local/tree.ts
+import { watch } from "node:fs";
+import { lstat, readFile, readdir } from "node:fs/promises";
+import { basename, dirname, join, sep } from "node:path";
+import ignore from "ignore";
+var WALK_LIMIT2 = 50000;
+var WALK_PAGE = 500;
+function createIgnores2(root) {
+  const rules = new Map;
+  const loadRules = (directory) => {
+    const known = rules.get(directory);
+    if (known !== undefined)
+      return known;
+    const sources = [join(root, directory, ".gitignore")];
+    if (directory === "")
+      sources.push(join(root, ".git", "info", "exclude"));
+    const loaded = Promise.all(sources.map((source) => readFile(source, "utf8").catch(() => null))).then((texts) => {
+      const found = texts.filter((text) => text !== null);
+      return found.length === 0 ? null : found.reduce((matcher, text) => matcher.add(text), ignore());
+    });
+    rules.set(directory, loaded);
+    return loaded;
+  };
+  const matches = async (path, directory) => {
+    const segments = path.split("/");
+    if (segments.includes(".git"))
+      return true;
+    let result = false;
+    for (let depth = 0;depth < segments.length; depth += 1) {
+      const matcher = await loadRules(segments.slice(0, depth).join("/"));
+      if (matcher === null)
+        continue;
+      const relative = segments.slice(depth).join("/") + (directory ? "/" : "");
+      if (!ignore.isPathValid(relative.replace(/\/$/, "")))
+        continue;
+      const test = matcher.test(relative);
+      if (test.ignored)
+        result = true;
+      else if (test.unignored)
+        result = false;
+    }
+    return result;
+  };
+  return {
+    matches,
+    async ignored(path, directory) {
+      const segments = path.split("/");
+      for (let depth = 1;depth < segments.length; depth += 1)
+        if (await matches(segments.slice(0, depth).join("/"), true))
+          return true;
+      return matches(path, directory);
+    },
+    forget(directory) {
+      rules.delete(directory);
+    }
+  };
+}
+async function* walkTree2(root, options) {
+  const ignores = options.ignores ?? createIgnores2(root);
+  const limit = options.limit ?? WALK_LIMIT2;
+  const size = options.page ?? WALK_PAGE;
+  const queue = [trimSlashes(options.directory ?? "")];
+  let page = [];
+  let count = 0;
+  let denied = false;
+  for (let next = queue.shift();next !== undefined; next = queue.shift()) {
+    const directory = next;
+    const listed = await readdir(join(root, directory), { withFileTypes: true }).catch((error) => {
+      if (readErrorCode2(error) === "EACCES" || readErrorCode2(error) === "EPERM")
+        denied = true;
+      return null;
+    });
+    if (listed === null)
+      continue;
+    listed.sort((left, right) => left.name < right.name ? -1 : left.name > right.name ? 1 : 0);
+    const entries = await Promise.all(listed.map(async (dirent) => {
+      const path = directory === "" ? dirent.name : `${directory}/${dirent.name}`;
+      const kind = dirent.isSymbolicLink() ? "symlink" : dirent.isDirectory() ? "directory" : dirent.isFile() ? "file" : null;
+      if (kind === null || dirent.name === ".git")
+        return null;
+      if (options.ignored === "exclude" && await ignores.matches(path, kind === "directory"))
+        return null;
+      if (kind === "directory")
+        return { path, kind, size: null };
+      const stats = await lstat(join(root, path)).catch(() => null);
+      return stats === null ? null : { path, kind, size: stats.size };
+    }));
+    for (const entry of entries) {
+      if (entry === null)
+        continue;
+      page.push(entry);
+      count += 1;
+      if (entry.kind === "directory")
+        queue.push(entry.path);
+      if (count >= limit) {
+        yield { kind: "entries", entries: page };
+        yield { kind: "incomplete", reason: "limit" };
+        return;
+      }
+      if (page.length >= size) {
+        yield { kind: "entries", entries: page };
+        page = [];
+      }
+    }
+  }
+  if (page.length > 0)
+    yield { kind: "entries", entries: page };
+  yield denied ? { kind: "incomplete", reason: "permission" } : { kind: "complete" };
+}
+function watchTree2(root, options, changed) {
+  let pending = new Set;
+  let timer = null;
+  let polling = null;
+  let watcher = null;
+  let fellBack = false;
+  let stopped = false;
+  const flush = () => {
+    timer = null;
+    const paths = pending;
+    pending = new Set;
+    if (!stopped && paths.size > 0)
+      changed(paths);
+  };
+  const note = (path) => {
+    pending.add(path);
+    timer ??= setTimeout(flush, options.delay);
+  };
+  const poll = (every) => {
+    let known = null;
+    const tick = async () => {
+      const seen = new Map;
+      for await (const frame of walkTree2(root, { ignored: "include" }))
+        if (frame.kind === "entries")
+          for (const entry of frame.entries) {
+            const stats = await lstat(join(root, entry.path)).catch(() => null);
+            seen.set(entry.path, stats === null ? "" : `${stats.size}:${stats.mtimeMs}`);
+          }
+      if (known !== null) {
+        for (const [path, stamp] of seen)
+          if (known.get(path) !== stamp)
+            note(path);
+        for (const path of known.keys())
+          if (!seen.has(path))
+            note(path);
+      }
+      known = seen;
+    };
+    const again = () => {
+      if (stopped)
+        return;
+      polling = setTimeout(() => {
+        tick().then(again, again);
+      }, every);
+    };
+    tick().then(again, again);
+  };
+  const fallback = () => {
+    watcher?.close();
+    watcher = null;
+    if (stopped || fellBack)
+      return;
+    fellBack = true;
+    options.unwatched?.();
+    if (options.poll !== null)
+      poll(options.poll);
+  };
+  try {
+    watcher = watch(root, { recursive: true }, (_event, filename) => note(filename === null ? "" : filename.split(sep).join("/")));
+    watcher.on("error", fallback);
+  } catch {
+    fallback();
+  }
+  return () => {
+    stopped = true;
+    watcher?.close();
+    if (timer !== null)
+      clearTimeout(timer);
+    if (polling !== null)
+      clearTimeout(polling);
+  };
+}
+function watchPath2(target, options, changed) {
+  let pending = new Set;
+  let timer = null;
+  let watchers = [];
+  let generation = 0;
+  let moved = false;
+  let stopped = false;
+  const flush = () => {
+    timer = null;
+    const paths = pending;
+    pending = new Set;
+    if (stopped)
+      return;
+    if (moved) {
+      moved = false;
+      arm();
+    }
+    if (paths.size > 0)
+      changed(paths);
+  };
+  const note = (path, replaced) => {
+    pending.add(path);
+    moved ||= replaced;
+    timer ??= setTimeout(flush, options.delay);
+  };
+  const listen = (at, recursive, heard) => {
+    try {
+      const watcher = watch(at, { recursive, persistent: false }, (event, name) => heard(event, name === null ? null : name.split(sep).join("/")));
+      watcher.on("error", () => note("", true));
+      watchers.push(watcher);
+    } catch {}
+  };
+  const arm = async () => {
+    generation += 1;
+    const armed = generation;
+    for (const watcher of watchers)
+      watcher.close();
+    watchers = [];
+    let existing = target;
+    let missing = null;
+    let stats = await lstat(existing).catch(() => null);
+    while (stats === null) {
+      const parent = dirname(existing);
+      if (parent === existing)
+        return;
+      missing = basename(existing);
+      existing = parent;
+      stats = await lstat(existing).catch(() => null);
+    }
+    if (stopped || armed !== generation)
+      return;
+    if (missing !== null) {
+      const awaited = missing;
+      if (stats.isDirectory())
+        listen(existing, false, (_event, name) => {
+          if (name === null || name === awaited)
+            note("", true);
+        });
+      return;
+    }
+    if (!stats.isDirectory()) {
+      listen(target, false, (event) => note("", event === "rename"));
+      return;
+    }
+    const own = basename(target);
+    listen(target, true, (_event, name) => note(name ?? "", false));
+    listen(dirname(target), false, (event, name) => {
+      if (name === null || name === own)
+        note("", event === "rename");
+    });
+  };
+  arm();
+  return () => {
+    stopped = true;
+    generation += 1;
+    for (const watcher of watchers)
+      watcher.close();
+    watchers = [];
+    if (timer !== null)
+      clearTimeout(timer);
+  };
+}
+function readErrorCode2(error) {
+  return typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" ? error.code : null;
+}
+function trimSlashes(path) {
+  return path.replace(/\\/g, "/").replace(/^\.?\/+|\/+$/g, "").replace(/^\.$/, "");
+}
+
+export { WALK_LIMIT2, createIgnores2, walkTree2, watchTree2, watchPath2, readErrorCode2 };

package/dist/chunks/canvas-preview-rp4x6y1h.js

@@ -0,0 +1,144 @@
+// src/serve/stream-server.ts
+import { deflateSync } from "fflate";
+import { SdkError } from "@nyte-ai/schema";
+import { CHANNEL_HEADER, asSdkError, encodeError, streamBuffer } from "@nyte-ai/protocol";
+var encoder = new TextEncoder;
+var CHUNK_BYTES = 48 * 1024;
+var DEFLATE_MIN_BYTES = 16 * 1024;
+function createStreamChannels2() {
+  const channels = new Map;
+  const owned = (id, connection) => {
+    const channel = channels.get(id);
+    if (channel === undefined)
+      throw new SdkError("unavailable", "The stream channel is closed.");
+    if (channel.connection !== connection)
+      throw new SdkError("denied", "The stream channel belongs to another connection.");
+    return channel;
+  };
+  return {
+    open(connection, signal, deflate) {
+      const id = crypto.randomUUID();
+      const controller = new AbortController;
+      const streams = new Map;
+      let timer;
+      const finish = () => {
+        if (controller.signal.aborted)
+          return;
+        controller.abort();
+        channels.delete(id);
+        clearInterval(timer);
+        signal.removeEventListener("abort", aborted);
+        for (const stream of streams.values())
+          stream.abort();
+        streams.clear();
+      };
+      const buffer = streamBuffer(finish);
+      const fail = (error) => {
+        if (controller.signal.aborted)
+          return;
+        buffer.end(encoder.encode(`event: error
+data: ${JSON.stringify(encodeError(error))}
+
+`));
+        finish();
+      };
+      const aborted = () => {
+        fail(signal.reason instanceof SdkError ? signal.reason : new SdkError("unavailable", "The stream channel disconnected."));
+      };
+      channels.set(id, {
+        connection,
+        signal: controller.signal,
+        deflate,
+        streams,
+        push: (frame, signal) => buffer.write(encoder.encode(`data: ${JSON.stringify(frame)}
+
+`), signal)
+      });
+      buffer.push(encoder.encode(`: connected
+
+`));
+      timer = setInterval(() => {
+        buffer.push(encoder.encode(`: ping
+
+`));
+      }, 15000);
+      if (signal.aborted)
+        aborted();
+      else
+        signal.addEventListener("abort", aborted, { once: true });
+      return new Response(buffer.body, {
+        headers: {
+          "Content-Type": "text/event-stream",
+          "Cache-Control": "no-cache",
+          [CHANNEL_HEADER]: id
+        }
+      });
+    },
+    async start(connection, channelId, streamId, request, serve) {
+      const channel = owned(channelId, connection);
+      if (channel.streams.has(streamId))
+        throw new SdkError("invalid", "The stream identifier is already in use.");
+      const controller = new AbortController;
+      channel.streams.set(streamId, controller);
+      const abortSetup = () => controller.abort(request.reason);
+      request.addEventListener("abort", abortSetup, { once: true });
+      const signal = AbortSignal.any([controller.signal, channel.signal]);
+      (async () => {
+        let reader;
+        const cancel = () => {
+          reader?.cancel().catch(() => {
+            return;
+          });
+        };
+        signal.addEventListener("abort", cancel, { once: true });
+        try {
+          if (request.aborted)
+            abortSetup();
+          signal.throwIfAborted();
+          const response = await serve(signal);
+          reader = response.body?.getReader();
+          request.removeEventListener("abort", abortSetup);
+          if (signal.aborted)
+            return;
+          if (reader !== undefined)
+            for (;; ) {
+              const next = await reader.read();
+              if (signal.aborted || next.done)
+                break;
+              for (let start = 0;start < next.value.byteLength; start += CHUNK_BYTES) {
+                if (signal.aborted)
+                  break;
+                const chunk = next.value.subarray(start, start + CHUNK_BYTES);
+                await channel.push(channel.deflate && chunk.byteLength >= DEFLATE_MIN_BYTES ? {
+                  kind: "deflated",
+                  stream: streamId,
+                  data: deflateSync(chunk, { level: 1 }).toBase64()
+                } : { kind: "chunk", stream: streamId, data: chunk.toBase64() }, signal);
+              }
+            }
+          if (!signal.aborted)
+            await channel.push({ kind: "end", stream: streamId }, signal);
+        } catch (error) {
+          if (!signal.aborted)
+            await channel.push({
+              kind: "error",
+              stream: streamId,
+              error: JSON.stringify(encodeError(asSdkError(error)))
+            }, signal);
+        } finally {
+          request.removeEventListener("abort", abortSetup);
+          signal.removeEventListener("abort", cancel);
+          channel.streams.delete(streamId);
+          controller.abort();
+          cancel();
+        }
+      })();
+      return new Response(null, { status: 202 });
+    },
+    cancel(connection, channelId, streamId) {
+      owned(channelId, connection).streams.get(streamId)?.abort();
+    }
+  };
+}
+
+export { createStreamChannels2 };

package/dist/chunks/canvas-preview-rp6fz0w5.js

@@ -0,0 +1,130 @@
+import {
+  sha2562
+} from "./canvas-preview-0nq75h9k.js";
+import {
+  run2
+} from "./canvas-preview-azg56359.js";
+
+// src/local/worktrees.ts
+import { randomUUID } from "node:crypto";
+import { copyFile, mkdir, realpath, rm, stat } from "node:fs/promises";
+import { homedir, tmpdir } from "node:os";
+import { basename, dirname, join } from "node:path";
+import { SdkError } from "@nyte-ai/schema";
+var ENV = { GIT_TERMINAL_PROMPT: "0", LC_ALL: "C" };
+function gitCommand(binary = "git") {
+  return async (cwd, args, env) => {
+    const ran = await run2(binary, ["-c", "core.quotepath=off", ...args], {
+      cwd,
+      env: { ...ENV, ...env }
+    });
+    if (ran.code !== 0)
+      throw new SdkError("unavailable", ran.stderr.trim() || `git ${args[0] ?? ""} failed.`);
+    return ran.stdout.toString("utf8");
+  };
+}
+async function listWorktrees2(cwd, options) {
+  const out = await gitCommand(options?.git)(cwd, ["worktree", "list", "--porcelain", "-z"]);
+  return out.split("\x00\x00").flatMap((record) => {
+    const fields = record.split("\x00");
+    const path = fields.find((field) => field.startsWith("worktree "))?.slice(9);
+    const branch = fields.find((field) => field.startsWith("branch refs/heads/"))?.slice(18);
+    return path === undefined ? [] : [{ path, branch: branch ?? null }];
+  });
+}
+async function addWorktree2(cwd, input, options) {
+  await gitCommand(options?.git)(cwd, input.from === undefined ? ["worktree", "add", input.path, input.branch] : ["worktree", "add", "-b", input.branch, input.path, input.from]);
+}
+async function hasBranch2(cwd, name, options) {
+  return gitCommand(options?.git)(cwd, ["show-ref", "--verify", "--quiet", `refs/heads/${name}`]).then(() => true).catch(() => false);
+}
+function localWorktrees2(options) {
+  const git = gitCommand(options?.git);
+  const folders = join(options?.home ?? homedir(), ".nyte", "worktrees");
+  const commitAt = (cwd, revision) => git(cwd, ["rev-parse", "--verify", "--quiet", `${revision}^{commit}`]).then((out) => out.trim(), () => null);
+  const workingTree = async (repo) => {
+    const index = join(tmpdir(), `nyte-worktree-index-${randomUUID()}`);
+    const indexEnv = { GIT_INDEX_FILE: index };
+    try {
+      await copyFile(join(repo.gitDir, "index"), index).catch(() => {
+        return;
+      });
+      await git(repo.root, ["add", "-A", "--", "."], indexEnv);
+      return (await git(repo.root, ["write-tree"], indexEnv)).trim();
+    } finally {
+      await rm(index, { force: true });
+    }
+  };
+  return {
+    async create(env, input) {
+      const repo = await readRepository(git, env.cwd);
+      if (repo === null)
+        throw new SdkError("unavailable", `${env.cwd} is not in a git repository, so it cannot have a worktree.`);
+      const head = await commitAt(repo.root, "HEAD");
+      if (head === null)
+        throw new SdkError("unavailable", `${repo.root} has no commits yet, so a worktree has nothing to branch from.`);
+      const slug = worktreeSlug(input.name, input.title);
+      const branch = `nyte/${slug}`;
+      const below = (root) => ({
+        kind: "local",
+        path: repo.prefix === "" ? root : join(root, repo.prefix).replace(/\/+$/u, "")
+      });
+      const listed = (await listWorktrees2(repo.root, options)).find((worktree) => worktree.branch === branch);
+      if (listed !== undefined)
+        return {
+          target: below(listed.path),
+          branch,
+          base: await commitAt(repo.root, `refs/heads/${branch}`) ?? head
+        };
+      const folder = join(folders, basename(repo.root), slug);
+      const branched = await hasBranch2(repo.root, branch, options);
+      const base = branched ? await commitAt(repo.root, `refs/heads/${branch}`) ?? head : head;
+      const tree = await workingTree(repo);
+      await mkdir(dirname(folder), { recursive: true });
+      await addWorktree2(repo.root, branched ? { path: folder, branch } : { path: folder, branch, from: head }, options);
+      if (tree !== (await git(folder, ["rev-parse", "HEAD^{tree}"])).trim()) {
+        await git(folder, ["read-tree", "-m", "-u", "HEAD", tree]);
+        await git(folder, ["reset", "-q"]);
+      }
+      return { target: below(await realpath(folder)), branch, base };
+    },
+    async remove(worktree) {
+      const path = "path" in worktree.target ? worktree.target.path : null;
+      if (path === null || await stat(path).catch(() => null) === null)
+        return { folder: "removed", branch: "kept" };
+      const [root = path, common = ""] = (await git(path, [
+        "rev-parse",
+        "--show-toplevel",
+        "--path-format=absolute",
+        "--git-common-dir"
+      ])).split(`
+`);
+      const status = await git(root, ["status", "--porcelain", "--ignored", "-z"]);
+      if (status.split("\x00").some((entry) => entry !== "" && !(entry.startsWith("!! ") && entry.endsWith("/"))))
+        return { folder: "kept", branch: "kept" };
+      await git(common, ["worktree", "remove", root]);
+      if (await commitAt(common, `refs/heads/${worktree.branch}`) !== worktree.base)
+        return { folder: "removed", branch: "kept" };
+      await git(common, ["branch", "-D", worktree.branch]);
+      return { folder: "removed", branch: "deleted" };
+    }
+  };
+}
+async function readRepository(git, cwd) {
+  const out = await git(cwd, [
+    "rev-parse",
+    "--show-toplevel",
+    "--absolute-git-dir",
+    "--show-prefix"
+  ]).catch(() => null);
+  const [root, gitDir, prefix = ""] = out?.split(`
+`) ?? [];
+  return root === undefined || gitDir === undefined || root === "" ? null : { root, gitDir, prefix };
+}
+function worktreeSlug(name, title) {
+  const words = (title ?? "").toLowerCase().replace(/[^a-z0-9]+/gu, "-").slice(0, 40).replace(/^-+|-+$/gu, "");
+  const key = sha2562(name).slice(0, 8);
+  return words === "" ? key : `${words}-${key}`;
+}
+
+export { listWorktrees2, addWorktree2, hasBranch2, localWorktrees2 };

package/dist/chunks/canvas-preview-s94ebwf5.js

@@ -0,0 +1,112 @@
+import {
+  readErrorCode2
+} from "./canvas-preview-mgcx2b2p.js";
+
+// src/plugins/loader.ts
+import { readdir, realpath, stat } from "node:fs/promises";
+import { isAbsolute, join, relative } from "node:path";
+import { pathToFileURL } from "node:url";
+import { SdkError } from "@nyte-ai/schema";
+import { dev } from "@nyte-ai/core";
+var EXTENSIONS = [".ts", ".mts", ".js", ".mjs"];
+async function loadPluginFiles2(dir) {
+  return loadAll(await pluginFilesIn(dir));
+}
+async function loadPluginDirectory2(dir) {
+  return importEach(await pluginFilesIn(dir));
+}
+function pluginLoader2(dirs) {
+  return async (paths) => {
+    const roots = (await Promise.all(dirs.map((dir) => realpath(dir).catch(() => null)))).filter((root) => root !== null);
+    const files = await Promise.all(paths.map(async (path) => {
+      const real = await realpath(path).catch(() => null);
+      if (real === null)
+        throw new SdkError("invalid", `No plugin file is at ${path}.`);
+      if (!roots.some((root) => inside(root, real)))
+        throw new SdkError("denied", `${path} is not in a plugin directory this host loads.`);
+      return real;
+    }));
+    return (await loadAll(files)).map((loaded) => loaded.plugin);
+  };
+}
+async function loadAll(files) {
+  const { loaded, failed } = await importEach(files);
+  const issues = failed.map((entry) => entry.issue);
+  if (issues.length > 0)
+    throw new SdkError("invalid", `${issues.length === 1 ? "A plugin file" : `${issues.length} plugin files`} did not load: ${failed.map((entry) => `${entry.path}: ${entry.issue.message}`).join("; ")}`, { issues });
+  return loaded;
+}
+async function importEach(files) {
+  const loaded = [];
+  const failed = [];
+  for (const path of files) {
+    const outcome = await importPlugin(path);
+    dev("plugins", "file", { path, outcome: "plugin" in outcome ? "loaded" : "failed" });
+    if ("plugin" in outcome)
+      loaded.push({ plugin: outcome.plugin, path });
+    else
+      failed.push({
+        path,
+        issue: {
+          severity: "error",
+          path: [path],
+          message: outcome.reason,
+          source: { plugin: path, file: path }
+        }
+      });
+  }
+  return { loaded, failed };
+}
+async function pluginFilesIn(dir) {
+  const entries = await readdir(dir, { withFileTypes: true }).catch((error) => {
+    if (readErrorCode2(error) === "ENOENT" || readErrorCode2(error) === "ENOTDIR")
+      return [];
+    throw error;
+  });
+  return (await Promise.all(entries.sort((left, right) => left.name < right.name ? -1 : left.name > right.name ? 1 : 0).map(async (entry) => {
+    const path = join(dir, entry.name);
+    if (entry.isFile())
+      return EXTENSIONS.some((extension) => entry.name.endsWith(extension)) ? [path] : [];
+    if (!entry.isDirectory())
+      return [];
+    for (const extension of EXTENSIONS) {
+      const index = join(path, `index${extension}`);
+      if ((await stat(index).catch(() => null))?.isFile() === true)
+        return [index];
+    }
+    return [];
+  }))).flat();
+}
+async function importPlugin(path) {
+  try {
+    const stats = await stat(path);
+    const url = pathToFileURL(path);
+    url.searchParams.set("nyte", `${stats.mtimeMs}-${stats.size}`);
+    const imported = await import(url.href);
+    const exported = typeof imported === "object" && imported !== null && "default" in imported ? imported.default : undefined;
+    return fitsCorePlugin(exported) ? { plugin: exported } : { reason: "Its default export is not a core plugin (an object with a string id)." };
+  } catch (error) {
+    return { reason: error instanceof Error ? error.message : String(error) };
+  }
+}
+function fitsCorePlugin(value) {
+  if (typeof value !== "object" || value === null || !("id" in value) || typeof value.id !== "string")
+    return false;
+  const object = (field) => field === undefined || typeof field === "object" && field !== null;
+  if ("contribute" in value && !object(value.contribute))
+    return false;
+  if ("hooks" in value && !object(value.hooks))
+    return false;
+  if ("activate" in value && value.activate !== undefined && typeof value.activate !== "function")
+    return false;
+  if (!("environment" in value) || value.environment === undefined)
+    return true;
+  const environment = value.environment;
+  return typeof environment === "object" && environment !== null && "kind" in environment && typeof environment.kind === "string" && "inspect" in environment && typeof environment.inspect === "function" && "attach" in environment && typeof environment.attach === "function";
+}
+function inside(root, path) {
+  const within = relative(root, path);
+  return within !== "" && !within.startsWith("..") && !isAbsolute(within);
+}
+
+export { loadPluginFiles2, loadPluginDirectory2, pluginLoader2 };