@elaraai/create-e3 1.0.3 → 1.0.5

package/bin/create-e3.mjs

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Licensed under AGPL-3.0-or-later. See LICENSE for details.
+ *
+ * Static bin shim — exists in fresh checkout so pnpm install can create
+ * the bin symlink BEFORE the package is built. Dynamic-imports the
+ * built CLI entrypoint; argv flows through via process.argv.
+ */
+await import('../dist/index.js');

package/dist/index.js

@@ -39,15 +39,38 @@ var DOTFILE_RENAMES = {
   gitignore: ".gitignore",
   npmrc: ".npmrc"
 };
+var MANIFEST_FILE = "template.json";
 function substituteTokens(content, names) {
   return content.replaceAll("__PROJECT_NAME__", names.projectName).replaceAll("__DISPLAY_NAME__", names.displayName).replaceAll("__WORKSPACE_NAME__", names.workspaceName);
 }
-function transformPackageJson(raw, names, version) {
+function transformPackageJson(raw, names, version, manifest, enabled) {
   const pkg = JSON.parse(raw);
   pkg.name = `@elaraai/${names.projectName}`;
   pkg.description = names.displayName;
   pkg.version = "0.0.1";
   delete pkg.private;
+  if (manifest) {
+    const deps = pkg.dependencies;
+    const devDeps = pkg.devDependencies;
+    const scripts = pkg.scripts;
+    for (const [feature, spec] of Object.entries(manifest.features)) {
+      if (enabled(feature))
+        continue;
+      for (const d of spec.dependencies ?? [])
+        delete deps?.[d];
+      for (const d of spec.devDependencies ?? [])
+        delete devDeps?.[d];
+      for (const s of spec.scripts ?? [])
+        delete scripts?.[s];
+    }
+    for (const [name, variants] of Object.entries(manifest.scriptVariants ?? {})) {
+      const match = variants.find((v) => v.when.every(enabled));
+      if (match)
+        scripts[name] = match.value;
+      else
+        delete scripts?.[name];
+    }
+  }
   const pin = `^${version}`;
   for (const field of ["dependencies", "devDependencies", "peerDependencies"]) {
     const deps = pkg[field];
@@ -77,6 +100,12 @@ function extOf(path) {
   const dot = base.lastIndexOf(".");
   return dot <= 0 ? "" : base.slice(dot);
 }
+function loadManifest(templateDir) {
+  const path = join(templateDir, MANIFEST_FILE);
+  if (!existsSync(path))
+    return null;
+  return JSON.parse(readFileSync(path, "utf8"));
+}
 function scaffold(options) {
   const { kind, name, templateDir, version } = options;
   const cwd = options.cwd ?? process.cwd();
@@ -84,6 +113,23 @@ function scaffold(options) {
   if (!existsSync(templateDir)) {
     throw new Error(`Template directory not found: ${templateDir}`);
   }
+  const manifest = loadManifest(templateDir);
+  const enabled = (feature) => options.features?.[feature] ?? manifest?.features[feature]?.default ?? true;
+  const skip = /* @__PURE__ */ new Set();
+  const renames = {};
+  if (manifest) {
+    for (const [feature, spec] of Object.entries(manifest.features)) {
+      if (enabled(feature)) {
+        for (const f of spec.disable ?? [])
+          skip.add(f);
+        for (const [src, dest] of Object.entries(spec.rename ?? {}))
+          renames[src] = dest;
+      } else {
+        for (const f of spec.files ?? [])
+          skip.add(f);
+      }
+    }
+  }
   const names = deriveNames(name, cwd);
   const inPlace = name === ".";
   const projectDir = inPlace ? cwd : join(cwd, names.projectName);
@@ -92,17 +138,21 @@ function scaffold(options) {
   }
   mkdirSync(projectDir, { recursive: true });
   for (const srcPath of walk(templateDir)) {
-    const rel = relative(templateDir, srcPath);
-    const segments = rel.split(/[/\\]/);
+    const rel = relative(templateDir, srcPath).replaceAll("\\", "/");
+    if (rel === MANIFEST_FILE)
+      continue;
+    if (skip.has(rel))
+      continue;
+    const destRel = renames[rel] ?? rel;
+    const segments = destRel.split("/");
     const last = segments[segments.length - 1];
     segments[segments.length - 1] = DOTFILE_RENAMES[last] ?? last;
-    const destRel = segments.join("/");
-    const destPath = join(projectDir, destRel);
+    const destPath = join(projectDir, segments.join("/"));
     mkdirSync(join(destPath, ".."), { recursive: true });
     const baseName = segments[segments.length - 1];
     if (baseName === "package.json") {
-      const manifest = transformPackageJson(readFileSync(srcPath, "utf8"), names, version);
-      writeFileSync(destPath, substituteTokens(manifest, names));
+      const transformed = transformPackageJson(readFileSync(srcPath, "utf8"), names, version, manifest, enabled);
+      writeFileSync(destPath, substituteTokens(transformed, names));
     } else if (TEXT_REPLACE_EXT.has(extOf(srcPath)) || baseName.startsWith(".")) {
       writeFileSync(destPath, substituteTokens(readFileSync(srcPath, "utf8"), names));
     } else {
@@ -111,7 +161,7 @@ function scaffold(options) {
   }
   log(`Created ${names.projectName} (${kind}) at ${projectDir}`);
   if (options.install) {
-    runInstall(kind, projectDir, log);
+    runInstall(kind, projectDir, enabled, log);
   }
   return { ...names, projectDir, inPlace };
 }
@@ -119,14 +169,14 @@ function hasCommand(cmd) {
   const probe = process.platform === "win32" ? "where" : "which";
   return spawnSync(probe, [cmd], { stdio: "ignore" }).status === 0;
 }
-function runInstall(kind, projectDir, log) {
+function runInstall(kind, projectDir, enabled, log) {
   log("Installing Node dependencies (npm install)...");
   const npm = spawnSync("npm", ["install"], { cwd: projectDir, stdio: "inherit", shell: process.platform === "win32" });
   if (npm.status !== 0) {
     log("npm install failed \u2014 fix the issue and re-run `npm install`.");
     return;
   }
-  if (kind === "e3") {
+  if (kind === "e3" && enabled("runner:east-py")) {
     if (hasCommand("uv")) {
       log("Installing Python dependencies (uv sync)...");
       const uv = spawnSync("uv", ["sync"], { cwd: projectDir, stdio: "inherit", shell: process.platform === "win32" });
@@ -139,15 +189,15 @@ function runInstall(kind, projectDir, log) {
 }
 
 // ../scaffold-core/dist/cli.js
-import { readFileSync as readFileSync2 } from "node:fs";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
 import { dirname, join as join2 } from "node:path";
+import { createInterface } from "node:readline/promises";
 import { fileURLToPath } from "node:url";
-function runCreateCli(kind, moduleUrl) {
+async function runCreateCli(kind, moduleUrl) {
   const pkgRoot = join2(dirname(fileURLToPath(moduleUrl)), "..");
   const args = process.argv.slice(2);
   if (args.includes("--help") || args.includes("-h")) {
-    console.log(`Usage: npm create @elaraai/${kind} <project-name> [-- --install|--no-install]`);
-    console.log(`       create-${kind} <project-name|.> [--install|--no-install]`);
+    printHelp(kind);
     return;
   }
   const version = JSON.parse(readFileSync2(join2(pkgRoot, "package.json"), "utf8")).version;
@@ -155,22 +205,111 @@ function runCreateCli(kind, moduleUrl) {
   const name = args.find((a) => !a.startsWith("-")) ?? ".";
   const install = args.includes("--install") ? true : args.includes("--no-install") ? false : Boolean(process.stdout.isTTY);
   try {
-    const result = scaffold({ kind, name, templateDir, version, install });
-    printNextSteps(kind, result.projectName, result.inPlace, install);
+    const features = await resolveFeatures(templateDir, args);
+    const result = scaffold({ kind, name, templateDir, version, install, features });
+    printNextSteps(kind, result.projectName, result.inPlace, install, features);
   } catch (err) {
     console.error(`error: ${err instanceof Error ? err.message : String(err)}`);
     process.exit(1);
   }
 }
-function printNextSteps(kind, projectName, inPlace, installed) {
+async function resolveFeatures(templateDir, args) {
+  const manifestPath = join2(templateDir, "template.json");
+  if (!existsSync2(manifestPath))
+    return {};
+  const manifest = JSON.parse(readFileSync2(manifestPath, "utf8"));
+  const features = {};
+  for (const [key, spec] of Object.entries(manifest.features))
+    features[key] = spec.default ?? true;
+  const runnerKeys = Object.keys(manifest.features).filter((k) => k.startsWith("runner:"));
+  const runnerName = (key) => key.slice("runner:".length);
+  const runnersFlag = args.find((a) => a.startsWith("--runners="));
+  const selectionFlags = ["--tests", "--no-tests", "--ui", "--no-ui", "--eslint", "--no-eslint"].some((f) => args.includes(f)) || Boolean(runnersFlag);
+  if (args.includes("--tests"))
+    features["tests"] = true;
+  if (args.includes("--no-tests"))
+    features["tests"] = false;
+  if (args.includes("--ui"))
+    features["ui"] = true;
+  if (args.includes("--no-ui"))
+    features["ui"] = false;
+  if (args.includes("--eslint"))
+    features["eslint"] = true;
+  if (args.includes("--no-eslint"))
+    features["eslint"] = false;
+  if (args.includes("--editor-diagnostics"))
+    features["editor-diagnostics"] = true;
+  if (args.includes("--no-editor-diagnostics"))
+    features["editor-diagnostics"] = false;
+  if (runnersFlag) {
+    const chosen = new Set(runnersFlag.slice("--runners=".length).split(",").map((s) => s.trim()).filter(Boolean));
+    for (const key of runnerKeys)
+      features[key] = chosen.has(runnerName(key));
+  }
+  const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY) && !selectionFlags;
+  if (!interactive)
+    return features;
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    if ("tests" in manifest.features) {
+      features["tests"] = await askYesNo(rl, "Include tests?", features["tests"]);
+    }
+    if ("ui" in manifest.features) {
+      features["ui"] = await askYesNo(rl, "Include UI components (east-ui + e3-ui)?", features["ui"]);
+    }
+    if (runnerKeys.length > 0) {
+      const defaults = runnerKeys.filter((k) => features[k]).map(runnerName);
+      const answer = (await rl.question(`Runners to include (comma-separated) [${defaults.join(",")}]: `)).trim();
+      const picks = new Set(answer ? answer.split(",").map((s) => s.trim()).filter(Boolean) : defaults);
+      for (const key of runnerKeys)
+        features[key] = picks.has(runnerName(key));
+    }
+    if ("eslint" in manifest.features) {
+      features["eslint"] = await askYesNo(rl, "Include ESLint with the East lint rules?", features["eslint"]);
+    }
+    if ("editor-diagnostics" in manifest.features) {
+      features["editor-diagnostics"] = await askYesNo(rl, "Include East editor diagnostics (TypeScript language service plugin)?", features["editor-diagnostics"]);
+    }
+  } finally {
+    rl.close();
+  }
+  return features;
+}
+async function askYesNo(rl, question, def) {
+  const answer = (await rl.question(`${question} [${def ? "Y/n" : "y/N"}] `)).trim().toLowerCase();
+  if (answer === "")
+    return def;
+  return answer.startsWith("y");
+}
+function printHelp(kind) {
+  console.log(`Usage: npm create @elaraai/${kind} <project-name> [-- <options>]`);
+  console.log(`       create-${kind} <project-name|.> [options]`);
+  console.log("");
+  console.log("Options:");
+  console.log("  --install | --no-install     install dependencies after scaffolding (default: TTY)");
+  console.log("  --eslint | --no-eslint       include ESLint with the East lint rules (default: yes)");
+  console.log("  --editor-diagnostics | --no-editor-diagnostics   include the East tsserver plugin for editor squiggles (default: yes)");
+  if (kind === "e3") {
+    console.log("  --tests | --no-tests         include test files (default: yes)");
+    console.log("  --ui | --no-ui               include east-ui + e3-ui UI components (default: no)");
+    console.log("  --runners=east-node,east-c,east-py   East runtimes to include (default: all)");
+  }
+  console.log("");
+  console.log("Run interactively (a TTY with no feature flags) to be prompted for these.");
+}
+function printNextSteps(kind, projectName, inPlace, installed, features) {
   console.log("");
   console.log("Next steps:");
   if (!inPlace)
     console.log(`  cd ${projectName}`);
-  if (!installed)
-    console.log(kind === "e3" ? "  npm run setup" : "  npm install");
+  if (!installed) {
+    if (kind === "e3")
+      console.log(features["runner:east-py"] === false ? "  npm install" : "  npm run setup");
+    else
+      console.log("  npm install");
+  }
   console.log(kind === "e3" ? "  npm run start" : "  npm run test");
 }
 
 // src/index.ts
-runCreateCli("e3", import.meta.url);
+await runCreateCli("e3", import.meta.url);

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@elaraai/create-e3",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "Scaffold a new e3 project (BSL-1.1, Node + Python, durable execution): npm create @elaraai/e3",
   "type": "module",
   "bin": {
-    "create-e3": "./dist/index.js"
+    "create-e3": "./bin/create-e3.mjs"
   },
   "files": [
+    "bin",
     "dist",
     "templates"
   ],

package/templates/e3/README.md

@@ -1,26 +1,44 @@
 # __DISPLAY_NAME__
 
-e3 project (BSL-1.1) — Node + Python, durable dataflow execution.
+An e3 project (BSL-1.1) — typed East logic, durable dataflow execution.
+
+East turns inputs and logic into **decisions**. This starter ships one: `reorder_qty`
+in `src/index.ts` recommends how many units to reorder to bring stock (`on_hand`) up to
+its target (`reorder_to`), never negative. Edit it, add inputs and tasks, and grow the
+package from there.
 
 ## Setup
 
 ```bash
-npm run setup     # npm install + uv sync (Node and Python deps)
+npm run setup     # install dependencies (npm install, plus `uv sync` if you kept the Python runner)
+```
+
+## Run
+
+```bash
+npm run start     # deploy from ./src/index.ts, then run the dataflow once
+npm run watch     # re-deploy and re-run on every save
+npm run deploy    # create the repo (if needed) and deploy without running
 ```
 
-## Commands
+The package is the default export of `src/index.ts`; the e3 CLI deploys it straight from source.
+
+## Test
 
 ```bash
 npm run build     # compile TypeScript
-npm run test      # build, export IR, run TS + Python tests
-npm run test:ts   # TypeScript tests only
-npm run test:py   # Python tests only (needs IR exported first)
-npm run deploy    # create repo (if needed) + deploy from ./src/index.ts
-npm run start     # deploy, then run the dataflow once
-npm run watch     # auto-deploy + run on every save
+npm run test      # build, export the IR, and run the tests
+```
+
+`npm run test` is present if you scaffolded with tests. With the Python (east-py) runner it also
+runs the exported IR through the Python runtime; without it, tests run on Node only.
+
+## Other
+
+```bash
 npm run lint      # lint sources
-npm run clean     # remove build output, venv, repo, dependencies
+npm run clean     # remove build output, dependencies, and the local repo
 ```
 
-The package is defined in `src/index.ts` as the default export; `npm run
-deploy`/`start`/`watch` deploy it straight from source via the e3 CLI.
+If you scaffolded with UI, `src/surface.tsx` holds a decision surface — a `ui()` task an operator
+uses to observe and act on the recommendation, registered in the package next to the decision.

package/templates/e3/eslint.config.js

@@ -1,15 +1,23 @@
 import tseslint from "@typescript-eslint/eslint-plugin";
 import tsparser from "@typescript-eslint/parser";
+import east from "@elaraai/eslint-plugin-east";
 
 export default [
   { ignores: ["dist/", "node_modules/", ".venv/"] },
   {
-    files: ["src/**/*.ts"],
+    files: ["src/**/*.ts", "src/**/*.tsx"],
     languageOptions: {
       parser: tsparser,
-      parserOptions: { ecmaVersion: "latest", sourceType: "module" },
+      // Type-aware linting: the East rules read the TypeScript program, so the
+      // parser must build it (`projectService` discovers the nearest tsconfig).
+      parserOptions: {
+        projectService: true,
+        tsconfigRootDir: import.meta.dirname,
+      },
     },
-    plugins: { "@typescript-eslint": tseslint },
-    rules: {},
+    plugins: { "@typescript-eslint": tseslint, east },
+    // One rule runs the whole East idiom diagnostic set (prefer some()/none, no
+    // hand-rolled variants, prefer the <Tag> over Tag.Root(...), etc.).
+    rules: { "east/east-rules": "warn" },
   },
 ];

package/templates/e3/package.json

@@ -23,15 +23,21 @@
     "@elaraai/east-node-io": "workspace:*",
     "@elaraai/east-py-datascience": "workspace:*",
     "@elaraai/e3": "workspace:*",
-    "@elaraai/e3-types": "workspace:*"
+    "@elaraai/e3-types": "workspace:*",
+    "@elaraai/east-ui": "workspace:*",
+    "@elaraai/e3-ui": "workspace:*"
   },
   "devDependencies": {
     "@elaraai/e3-cli": "workspace:*",
+    "@elaraai/east-node-cli": "workspace:*",
+    "@elaraai/east-c-cli": "workspace:*",
     "@types/node": "^22",
     "typescript": "^5",
     "eslint": "^9",
     "@typescript-eslint/eslint-plugin": "^8",
     "@typescript-eslint/parser": "^8",
+    "@elaraai/eslint-plugin-east": "workspace:*",
+    "@elaraai/tsserver-plugin-east": "workspace:*",
     "cross-env": "^7",
     "rimraf": "^6"
   },

package/templates/e3/pyproject.toml

@@ -5,9 +5,8 @@ requires-python = ">=3.11"
 version = "0.1.0"
 dependencies = [
   "elaraai-east-py",
-  # Uncomment once these are published to PyPI:
-  # "elaraai-east-py-std",
-  # "elaraai-east-py-io",
+  "elaraai-east-py-std",
+  "elaraai-east-py-io",
   "elaraai-east-py-datascience",
   "elaraai-east-py-cli",
   "pytest",

package/templates/e3/src/index.spec.ts

@@ -1,15 +1,15 @@
 import { East } from "@elaraai/east";
 import { describeEast, Assert } from "@elaraai/east-node-std";
-import { greetFn } from "./index.js";
+import { reorderFn } from "./index.js";
 
 describeEast("__DISPLAY_NAME__", (test) => {
-  test("greet returns greeting message", ($) => {
-    const result = $.let(greetFn("World"));
-    $(Assert.equal(result, East.value("Hello, World!")));
+  test("reorders up to the target when below it", ($) => {
+    const qty = $.let(reorderFn(12n, 50n));
+    $(Assert.equal(qty, East.value(38n)));
   });
 
-  test("greet with custom name", ($) => {
-    const result = $.let(greetFn("East"));
-    $(Assert.equal(result, East.value("Hello, East!")));
+  test("never recommends a negative reorder", ($) => {
+    const qty = $.let(reorderFn(80n, 50n));
+    $(Assert.equal(qty, East.value(0n)));
   });
 }, { exportOnly: true });

package/templates/e3/src/index.ts

@@ -1,14 +1,20 @@
 import e3 from "@elaraai/e3";
-import { East, StringType } from "@elaraai/east";
+import { East, IntegerType } from "@elaraai/east";
 
-export const nameInput = e3.input("name", StringType, "World!");
+// In East a decision is a typed task over inputs. This one recommends how many
+// units to reorder to bring stock up to its target level — never negative.
+export const onHandInput = e3.input("on_hand", IntegerType, 12n);
+export const targetInput = e3.input("reorder_to", IntegerType, 50n);
 
-export const greetFn = East.function(
-  [StringType],
-  StringType,
-  ($, name) => East.str`Hello, ${name}!`,
+export const reorderFn = East.function(
+  [IntegerType, IntegerType],
+  IntegerType,
+  ($, onHand, target) => {
+    const gap = $.let(target.subtract(onHand));
+    $.return(East.greater(gap, 0n).ifElse(() => gap, () => 0n));
+  },
 );
 
-export const greet = e3.task("greet", [nameInput], greetFn);
+export const reorderQty = e3.task("reorder_qty", [onHandInput, targetInput], reorderFn);
 
-export default e3.package("__PROJECT_NAME__", "1.0.0", greet);
+export default e3.package("__PROJECT_NAME__", "1.0.0", reorderQty);

package/templates/e3/src/index.ui.ts

@@ -0,0 +1,22 @@
+import e3 from "@elaraai/e3";
+import { East, IntegerType } from "@elaraai/east";
+
+import { surface } from "./surface.js";
+
+// In East a decision is a typed task over inputs. This one recommends how many
+// units to reorder to bring stock up to its target level — never negative.
+export const onHandInput = e3.input("on_hand", IntegerType, 12n);
+export const targetInput = e3.input("reorder_to", IntegerType, 50n);
+
+export const reorderFn = East.function(
+  [IntegerType, IntegerType],
+  IntegerType,
+  ($, onHand, target) => {
+    const gap = $.let(target.subtract(onHand));
+    $.return(East.greater(gap, 0n).ifElse(() => gap, () => 0n));
+  },
+);
+
+export const reorderQty = e3.task("reorder_qty", [onHandInput, targetInput], reorderFn);
+
+export default e3.package("__PROJECT_NAME__", "1.0.0", reorderQty, surface);

package/templates/e3/src/surface.tsx

@@ -0,0 +1,16 @@
+import { East } from "@elaraai/east";
+import { ui } from "@elaraai/e3-ui";
+import { Box, Text, UIComponentType } from "@elaraai/east-ui";
+
+// A decision surface for an operator to observe and act on the recommendation.
+// east-ui / e3-ui JSX authoring is still being finalised — build this out: bind
+// reorderQty and the inputs with Data.bind, then add the Observe / Decide controls.
+export const surface = ui(
+  "surface",
+  [],
+  East.function([], UIComponentType, (_$) => (
+    <Box padding="6">
+      <Text textStyle="heading-md">__DISPLAY_NAME__</Text>
+    </Box>
+  )),
+);

package/templates/e3/template.json

@@ -0,0 +1,55 @@
+{
+  "features": {
+    "tests": {
+      "default": true,
+      "files": ["src/index.spec.ts", "tests/test_unit.py"],
+      "scripts": ["test:ts", "test:export", "test:py"]
+    },
+    "ui": {
+      "default": false,
+      "files": ["src/surface.tsx", "src/index.ui.ts"],
+      "disable": ["src/index.ts"],
+      "rename": { "src/index.ui.ts": "src/index.ts" },
+      "dependencies": ["@elaraai/east-ui", "@elaraai/e3-ui"]
+    },
+    "runner:east-node": {
+      "default": true,
+      "devDependencies": ["@elaraai/east-node-cli"]
+    },
+    "runner:east-c": {
+      "default": true,
+      "devDependencies": ["@elaraai/east-c-cli"]
+    },
+    "runner:east-py": {
+      "default": true,
+      "files": ["pyproject.toml", ".python-version", "tests/test_unit.py"],
+      "scripts": ["test:py"],
+      "dependencies": ["@elaraai/east-py-datascience"]
+    },
+    "eslint": {
+      "default": true,
+      "files": ["eslint.config.js"],
+      "scripts": ["lint"],
+      "devDependencies": [
+        "eslint",
+        "@typescript-eslint/eslint-plugin",
+        "@typescript-eslint/parser",
+        "@elaraai/eslint-plugin-east"
+      ]
+    },
+    "editor-diagnostics": {
+      "default": true,
+      "devDependencies": ["@elaraai/tsserver-plugin-east"]
+    }
+  },
+  "scriptVariants": {
+    "test": [
+      { "when": ["tests", "runner:east-py"], "value": "npm run build && npm run test:export && npm run test:py" },
+      { "when": ["tests"], "value": "npm run build && npm run test:export" }
+    ],
+    "setup": [
+      { "when": ["runner:east-py"], "value": "npm install && uv sync" },
+      { "when": [], "value": "npm install" }
+    ]
+  }
+}

package/templates/e3/tsconfig.json

@@ -2,6 +2,7 @@
   "exclude": ["dist"],
   "compilerOptions": {
     "outDir": "./dist",
+    "rootDir": "./src",
     "module": "nodenext",
     "target": "esnext",
     "lib": ["esnext", "es2024"],
@@ -13,12 +14,14 @@
     "exactOptionalPropertyTypes": true,
     "strict": true,
     "jsx": "react-jsx",
+    "jsxImportSource": "@elaraai/east-ui",
     "verbatimModuleSyntax": true,
     "isolatedModules": true,
     "noUncheckedSideEffectImports": true,
     "moduleDetection": "force",
     "skipLibCheck": true,
     "noErrorTruncation": true,
-    "incremental": true
+    "incremental": true,
+    "plugins": [{ "name": "@elaraai/tsserver-plugin-east" }]
   }
 }