zet-execute 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ZET Digital
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,352 @@
+# zet-execute
+
+A project-level task runner for teams. Define dev commands in a config file, run them with `x <command>`.
+
+Built for the team at ZET Digital for internal use. You're welcome to use it too.
+
+> This is not a CLI framework like Commander or Yargs. Those help you build CLIs. This is a task runner — it runs your project's commands.
+
+## Install
+
+```sh
+npm install -g zet-execute
+```
+
+Requires Node.js ^18.19 or >=20.6.
+
+## Getting Started
+
+```sh
+mkdir my-project && cd my-project
+x init
+x hello
+```
+
+`x init` creates an `x.config.mjs` with a starter command. Edit it to add your own. Run `x` or `x --help` to see all registered commands.
+
+## Configuration File
+
+`x` traverses up from the current directory looking for `x.config.mjs`. Commands are registered as side effects via named imports.
+
+```js
+import { register } from 'zet-execute';
+
+register('up', 'Start containers')
+  .run`docker compose up -d`;
+```
+
+## API Reference
+
+### Command Registration
+
+```js
+import { register, group } from 'zet-execute';
+
+// Simple command
+register('up', 'Start containers')
+  .run`docker compose up -d`;
+
+// With signature (args, options, rest)
+register('deploy {env} {--Force}', 'Deploy to environment')
+  .callback(async ($) => {
+    const env = $.arg('env');
+    $.info(`Deploying to ${env}...`);
+    if ($.option('--force')) $.warn('Force deploy enabled');
+    await $.mustRun`deploy.sh ${env}`;
+  });
+
+// Group
+const db = group('db', 'Database');
+db.register('migrate ...', 'Run migrations').run`docker compose exec app migrate ...`;
+```
+
+### Signature Syntax
+
+```
+command-name {arg} {arg?} {arg desc} {--option} {--option=} {--Option} {--Opt-Name=} ...
+```
+
+| Token | Meaning |
+|---|---|
+| `{name}` | Required positional argument |
+| `{name?}` | Optional positional argument |
+| `{name description}` | Required argument with description |
+| `{name? description}` | Optional argument with description |
+| `{--name}` | Boolean option (flag) |
+| `{--name=}` | Option that accepts a value |
+| `{--Name}` | Boolean option with short flag `-N` |
+| `{--Preserve-Cache=}` | Value option with short flag `-PC` |
+| `...` | Accept extra arguments (rest) |
+
+Short flags are derived from uppercase letters at the start of hyphen-separated segments: `--Preserve-Cache` -> `-PC`. The long name is always stored lowercase.
+
+### `.run` — Defining Commands
+
+`.run` works as both a tagged template (recommended) and a regular function call.
+
+**Tagged template (recommended)** — whitespace in static parts is split into separate arguments. Interpolated values are kept as single tokens (safe for paths with spaces).
+
+```js
+register('build', 'Build project').run`npm run build`;
+
+// Interpolation keeps the value as one token
+const target = 'my output dir';
+register('clean', 'Clean output').run`rm -rf ${target}`;
+
+// Rest args with ...
+register('npm ...', 'Run npm').run`npm ...`;
+// x npm install lodash  ->  npm install lodash
+```
+
+**Function call** — also accepts variadic string arguments for programmatic use.
+
+```js
+register('up', 'Start containers').run('docker', 'compose', 'up', '-d');
+```
+
+### `.userCwd()` Method
+
+Run a command from the user's current working directory instead of the project root:
+
+```js
+register('ls', 'List files')
+  .userCwd()
+  .run`ls -la`;
+```
+
+### Templates
+
+Reuse common command prefixes:
+
+```js
+import { register, template } from 'zet-execute';
+
+const compose = template((service) => ['docker', 'compose', 'exec', '-it', service]);
+
+register('shell', 'Open shell')
+  .run`${compose('app')} bash`;
+
+register('migrate ...', 'Run migrations')
+  .run`${compose('app')} migrate ...`;
+```
+
+Template functions can return an array of strings or a single string (which gets split on whitespace). Templates validate argument count based on `fn.length`. Zero-arg templates can be used without `()` — `${compose}` works the same as `${compose()}`.
+
+### Callback with `$` Context
+
+Callbacks receive an `ExecutionContext` object (`$`) with everything needed to run commands and access parsed arguments:
+
+```js
+register('deploy {env} {--Verbose}')
+  .callback(async ($) => {
+    const env = $.arg('env');       // string | null
+    const verbose = $.option('--verbose');  // string | true | null
+
+    // Run a command (output visible) — does not throw on failure
+    await $.run`deploy.sh ${env}`;
+
+    // Run and throw on failure
+    await $.mustRun`deploy.sh ${env}`;
+
+    // Run silently (capture output)
+    const result = await $.silent`git rev-parse HEAD`;
+    $.info(`Deployed ${result.stdout.trim()}`);
+  });
+```
+
+`$.run` and `$.silent` also accept variadic args: `await $.run('docker', 'compose', 'up')`.
+
+`$.run` does not throw on failure — use `$.mustRun` or chain `.throw()` to stop on errors.
+
+#### `$` Methods
+
+| Method | Description |
+|---|---|
+| `$.arg(name)` | Get parsed argument (`string \| null`) |
+| `$.option('--name')` | Get option (`string \| true \| null`) |
+| `$.run\`cmd\`` | Spawn with inherited stdio |
+| `$.mustRun\`cmd\`` | Like `$.run` but throws on non-zero exit code |
+| `$.silent\`cmd\`` | Spawn with piped stdio, returns `CommandOutput` |
+| `$.mustSilent\`cmd\`` | Like `$.silent` but throws on non-zero exit code |
+| `$.info(msg)` | Green message to stdout |
+| `$.warn(msg)` | Yellow message to stderr |
+| `$.error(msg)` | Red message to stderr |
+| `$.confirm(msg)` | Yellow prompt `[y/N]`, returns `boolean` |
+| `$.prompt(msg)` | Cyan prompt, returns the answer |
+| `$.root` | Project root — callable: `$.root('src')`, or string: `` `${$.root}` `` |
+| `$.user` | User CWD — callable: `$.user('test')`, or string: `` `${$.user}` `` |
+| `$.cd(path)` | Change working directory for subsequent `run`/`silent` calls |
+
+`$.root` and `$.user` are `PathHelper` objects — they work as both functions and strings via `Symbol.toPrimitive`.
+
+#### `CommandOutput`
+
+Returned by `$.silent`:
+
+| Property | Type |
+|---|---|
+| `.code` | `number` |
+| `.output` | `string \| null` (combined stdout+stderr) |
+| `.stdout` | `string \| null` |
+| `.stderr` | `string \| null` |
+| `.succeeded` | `boolean` |
+| `.failed` | `boolean` |
+| `.throw()` | Throws if failed, returns `this` if succeeded |
+
+### Groups
+
+Organize commands under a prefix:
+
+```js
+import { group } from 'zet-execute';
+
+const db = group('db', 'Database');
+db.register('migrate ...', 'Run migrations').run`docker compose exec app migrate ...`;
+db.register('seed', 'Seed database').run`docker compose exec app db-seed`;
+```
+
+```sh
+x db migrate --fresh
+x db seed
+```
+
+The names `init` and `cli` are reserved and cannot be used as group prefixes or command names.
+
+### Splitting Config Files
+
+Use standard ES module imports to split your config across multiple files:
+
+```js
+// x.config.mjs
+import { register } from 'zet-execute';
+import './x/docker.mjs';
+import './x/deploy.mjs';
+
+register('hello', 'Say hello').run`echo hi`;
+```
+
+```js
+// x/docker.mjs
+import { register, template } from 'zet-execute';
+
+const compose = template((service) => ['docker', 'compose', 'exec', '-it', service]);
+register('shell', 'Open shell').run`${compose('app')} bash`;
+```
+
+Templates and groups defined in one file are available to all files — they share the same module singleton. Export a template from a shared file and import it wherever needed:
+
+```js
+// x/shared.mjs
+import { template } from 'zet-execute';
+export const compose = template((service) => ['docker', 'compose', 'exec', '-it', service]);
+```
+
+```js
+// x/docker.mjs
+import { register } from 'zet-execute';
+import { compose } from './shared.mjs';
+
+register('shell', 'Open shell').run`${compose('app')} bash`;
+register('logs', 'View logs').run`docker compose logs -f`;
+```
+
+### Config Paths
+
+```js
+import { setAiPublishPath, setIdePublishPath, autoPublishIde } from 'zet-execute';
+
+setAiPublishPath('docs/');                             // zet-execute.md -> docs/zet-execute.md
+setAiPublishPath('.claude/skills/project/SKILL.md');   // exact file path
+setIdePublishPath('.types/');                          // .d.ts -> .types/.x/index.d.ts
+autoPublishIde();                                      // auto-regenerate .x/index.d.ts on every run
+```
+
+## Built-in Commands
+
+### `x init`
+
+Creates `x.config.mjs` in the current directory with a starter command.
+
+### `x cli publish ai`
+
+Generates `zet-execute.md` — an AI agent reference for your project's commands. By default writes to the project root. Configure with `setAiPublishPath()`.
+
+### `x cli publish ide`
+
+Generates TypeScript declarations for IDE autocompletion. By default writes to `.x/` (with `.gitignore`). Configure with `setIdePublishPath()`.
+
+### `x cli init-completion <bash|zsh>`
+
+Outputs a shell completion script. Add to your shell profile:
+
+```sh
+# bash
+eval "$(x cli init-completion bash)"
+
+# zsh
+eval "$(x cli init-completion zsh)"
+```
+
+Common shell profile locations:
+- **bash**: `~/.bashrc` or `~/.bash_profile`
+- **zsh**: `~/.zshrc`
+
+### Auto-generated Help
+
+```sh
+x --help           # global help
+x <command> --help  # command-specific help
+```
+
+### Auto-generated Types
+
+When `autoPublishIde()` is called in your config, `x` regenerates `.x/index.d.ts` with TypeScript declarations for IDE support on every run. This happens silently and never breaks normal operation. You can also generate types on demand with `x cli publish ide`.
+
+## Full Example
+
+```js
+import { register, group, template, setAiPublishPath } from 'zet-execute';
+
+setAiPublishPath('docs/');
+
+const compose = template((service) => ['docker', 'compose', 'exec', '-it', service]);
+
+// Groups
+const db = group('db', 'Database');
+db.register('migrate ...', 'Run migrations')
+  .run`${compose('app')} db-migrate ...`;
+db.register('seed', 'Seed database')
+  .run`${compose('app')} db-seed`;
+
+// Root commands
+register('up', 'Start all containers')
+  .run`docker compose up -d`;
+
+register('down', 'Stop all containers')
+  .run`docker compose down`;
+
+register('deploy {env} {--Force}', 'Deploy to environment')
+  .callback(async ($) => {
+    const env = $.arg('env');
+    if ($.option('--force')) {
+      $.warn('Force deploy — skipping checks');
+    } else if (!await $.confirm(`Deploy to ${env}?`)) {
+      return;
+    }
+    $.info(`Deploying to ${env}...`);
+    await $.mustRun`deploy.sh ${env}`;
+  });
+```
+
+## How It Works
+
+1. `x` binary traverses up from CWD to find `x.config.mjs`
+2. Sets up a module resolution hook so the config can `import { register } from 'zet-execute'`
+3. Imports the config (side effects register commands), then runs the matched command
+4. Commands run from the project root — use `$.root` and `$.user` in callbacks to resolve paths, or `.userCwd()` to run from the user's directory
+
+## Test
+
+```sh
+npm test
+```

package/bin/x.mjs

@@ -0,0 +1,154 @@
+#!/usr/bin/env node
+
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { spawn } from "node:child_process";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const CONFIG_NAME = "x.config.mjs";
+
+const cliArgs = process.argv.slice(2);
+
+if (cliArgs[0] === "--version" || cliArgs[0] === "-v") {
+  const pkg = JSON.parse(readFileSync(join(dirname(fileURLToPath(import.meta.url)), "..", "package.json"), "utf8"));
+  process.stdout.write(pkg.version + "\n");
+  process.exit(0);
+}
+
+if (cliArgs[0] === "init") {
+  const configFile = join(process.cwd(), "x.config.mjs");
+  if (existsSync(configFile)) {
+    process.stderr.write("x is already initialized in this directory\n");
+    process.exit(1);
+  }
+  writeFileSync(
+    configFile,
+    `import { register } from 'zet-execute';
+
+register('hello', 'Say hello')
+  .callback(($) => {
+    $.info('Hello from ZET Execute!');
+  });
+`
+  );
+  process.stdout.write("Created x.config.mjs\n");
+  process.exit(0);
+}
+
+
+if (cliArgs[0] === "cli" && cliArgs[1] === "init-completion") {
+  const shell = cliArgs[2];
+  if (shell === "bash") {
+    process.stdout.write(`_x_completions() {
+  local cur=\${COMP_WORDS[COMP_CWORD]}
+  local completions
+  if [ $COMP_CWORD -eq 1 ]; then
+    completions=$(x --completions 2>/dev/null)
+  elif [ $COMP_CWORD -eq 2 ]; then
+    completions=$(x --completions "\${COMP_WORDS[1]}" 2>/dev/null)
+  elif [ $COMP_CWORD -eq 3 ]; then
+    completions=$(x --completions "\${COMP_WORDS[1]}" "\${COMP_WORDS[2]}" 2>/dev/null)
+  fi
+  COMPREPLY=( $(compgen -W "$completions" -- "$cur") )
+}
+complete -F _x_completions x
+`);
+    process.exit(0);
+  } else if (shell === "zsh") {
+    process.stdout.write(`#compdef x
+_x() {
+  local -a commands
+  if (( CURRENT == 2 )); then
+    commands=(\${(f)"$(x --completions 2>/dev/null)"})
+    _describe 'command' commands
+  elif (( CURRENT == 3 )); then
+    commands=(\${(f)"$(x --completions \${words[2]} 2>/dev/null)"})
+    _describe 'subcommand' commands
+  elif (( CURRENT == 4 )); then
+    commands=(\${(f)"$(x --completions \${words[2]} \${words[3]} 2>/dev/null)"})
+    _describe 'subcommand' commands
+  fi
+}
+_x "$@"
+`);
+    process.exit(0);
+  } else {
+    process.stderr.write("Usage: x cli init-completion <bash|zsh>\n");
+    process.exit(1);
+  }
+}
+
+
+function findConfig(startDir) {
+  let dir = startDir;
+  while (true) {
+    const candidate = join(dir, CONFIG_NAME);
+    if (existsSync(candidate)) return candidate;
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+
+const configPath = findConfig(process.cwd());
+
+if (!configPath) {
+  process.stderr.write(
+    "x: cannot find x.config.mjs in the current or any parent directory\n"
+  );
+  process.exit(1);
+}
+
+// Register a module resolution hook so configs can `import { register } from 'zet-execute'`
+const pkgRoot = dirname(dirname(fileURLToPath(import.meta.url)));
+const [major, minor] = process.versions.node.split(".").map(Number);
+
+const supported = (major === 18 && minor >= 19) || (major === 20 && minor >= 6) || major > 20;
+if (!supported) {
+  const y = !process.env.NO_COLOR && process.stderr.isTTY ? "\x1b[1;33m" : "";
+  const r = y ? "\x1b[0m" : "";
+  process.stderr.write(
+    `${y}x: Node.js ${process.versions.node} is not supported. Requires ^18.19 or >=20.6.${r}\n`
+  );
+}
+
+const nodeArgs = [];
+
+if (major > 20 || (major === 20 && minor >= 6) || (major === 18 && minor >= 19)) {
+  nodeArgs.push(
+    "--import",
+    pathToFileURL(join(pkgRoot, "dist", "register.js")).href
+  );
+} else {
+  nodeArgs.push(
+    "--loader",
+    pathToFileURL(join(pkgRoot, "dist", "loader.js")).href
+  );
+}
+
+const runnerPath = join(pkgRoot, "dist", "runner.js");
+const projectRoot = dirname(configPath);
+
+const child = spawn(
+  process.execPath,
+  [...nodeArgs, runnerPath, configPath, ...process.argv.slice(2)],
+  {
+    stdio: "inherit",
+    env: {
+      ...process.env,
+      X_ROOT_DIR: projectRoot,
+    },
+  }
+);
+
+process.on("SIGTERM", () => child.kill("SIGTERM"));
+process.on("SIGINT", () => child.kill("SIGINT"));
+
+child.on("close", (code, signal) => {
+  if (signal) {
+    process.kill(process.pid, signal);
+  } else {
+    process.exit(code ?? 1);
+  }
+});

package/dist/context.d.ts

@@ -0,0 +1,40 @@
+import { CommandOutput } from "./shared.js";
+export declare const REST_SYMBOL: unique symbol;
+export declare function buildRunParts(strings: TemplateStringsArray, values: unknown[]): (string | symbol)[];
+export declare function expandRestSymbol(parts: (string | symbol)[], restArgs: string[]): string[];
+export declare function spawnCommand(parts: string[], options: {
+    stdio: "inherit" | "pipe";
+    cwd?: string;
+}): Promise<CommandOutput>;
+export interface PathHelper {
+    (sub?: string): string;
+    [Symbol.toPrimitive](): string;
+    toString(): string;
+}
+export declare function createPathHelper(basePath: string): PathHelper;
+export declare class ExecutionContext {
+    private _args;
+    private _options;
+    private _restArgs;
+    private _rootDir;
+    private _userDir;
+    private _cwd;
+    private _rootHelper;
+    private _userHelper;
+    constructor(args: Record<string, string>, options: Record<string, string | true>, restArgs: string[], rootDir: string, userDir: string, initialCwd: string);
+    arg(name: string): string | null;
+    option(name: string): string | true | null;
+    run(stringsOrParts: TemplateStringsArray | unknown, ...values: unknown[]): Promise<CommandOutput>;
+    mustRun(stringsOrParts: TemplateStringsArray | unknown, ...values: unknown[]): Promise<CommandOutput>;
+    silent(stringsOrParts: TemplateStringsArray | unknown, ...values: unknown[]): Promise<CommandOutput>;
+    mustSilent(stringsOrParts: TemplateStringsArray | unknown, ...values: unknown[]): Promise<CommandOutput>;
+    info(msg: string): void;
+    warn(msg: string): void;
+    error(msg: string): void;
+    confirm(msg: string): Promise<boolean>;
+    prompt(msg: string): Promise<string>;
+    get root(): PathHelper;
+    get user(): PathHelper;
+    cd(path: string): void;
+}
+//# sourceMappingURL=context.d.ts.map

package/dist/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../src/context.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,aAAa,EAAgC,MAAM,aAAa,CAAC;AAG1E,eAAO,MAAM,WAAW,EAAE,OAAO,MAAuB,CAAC;AAGzD,wBAAgB,aAAa,CAAC,OAAO,EAAE,oBAAoB,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CA4BnG;AAGD,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAUzF;AAGD,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE;IAAE,KAAK,EAAE,SAAS,GAAG,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC,aAAa,CAAC,CA6C1H;AAGD,MAAM,WAAW,UAAU;IACzB,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACvB,CAAC,MAAM,CAAC,WAAW,CAAC,IAAI,MAAM,CAAC;IAC/B,QAAQ,IAAI,MAAM,CAAC;CACpB;AAED,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,UAAU,CAK7D;AAGD,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,KAAK,CAAyB;IACtC,OAAO,CAAC,QAAQ,CAAgC;IAChD,OAAO,CAAC,SAAS,CAAW;IAC5B,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,IAAI,CAAS;IACrB,OAAO,CAAC,WAAW,CAAa;IAChC,OAAO,CAAC,WAAW,CAAa;gBAG9B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC5B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC,EACtC,QAAQ,EAAE,MAAM,EAAE,EAClB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM;IAYpB,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAIhC,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,IAAI;IAI1C,GAAG,CAAC,cAAc,EAAE,oBAAoB,GAAG,OAAO,EAAE,GAAG,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,aAAa,CAAC;IAW3F,OAAO,CAAC,cAAc,EAAE,oBAAoB,GAAG,OAAO,EAAE,GAAG,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,aAAa,CAAC;IAK3G,MAAM,CAAC,cAAc,EAAE,oBAAoB,GAAG,OAAO,EAAE,GAAG,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,aAAa,CAAC;IAW9F,UAAU,CAAC,cAAc,EAAE,oBAAoB,GAAG,OAAO,EAAE,GAAG,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,aAAa,CAAC;IAK9G,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAIvB,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAIvB,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAIlB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAetC,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAc1C,IAAI,IAAI,IAAI,UAAU,CAErB;IAED,IAAI,IAAI,IAAI,UAAU,CAErB;IAED,EAAE,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;CAGvB"}