@elaraai/create-e3 1.0.18 → 1.0.19

package/dist/index.js

@@ -43,6 +43,18 @@ 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 isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function mergeInto(target, source) {
+  for (const [k, v] of Object.entries(source)) {
+    const existing = target[k];
+    if (isPlainObject(existing) && isPlainObject(v))
+      mergeInto(existing, v);
+    else
+      target[k] = v;
+  }
+}
 function transformPackageJson(raw, names, version, manifest, enabled) {
   const pkg = JSON.parse(raw);
   pkg.name = `@elaraai/${names.projectName}`;
@@ -70,6 +82,10 @@ function transformPackageJson(raw, names, version, manifest, enabled) {
       else
         delete scripts?.[name];
     }
+    for (const [feature, spec] of Object.entries(manifest.features)) {
+      if (enabled(feature) && spec.packageJson)
+        mergeInto(pkg, spec.packageJson);
+    }
   }
   const pin = `^${version}`;
   for (const field of ["dependencies", "devDependencies", "peerDependencies"]) {
@@ -114,7 +130,12 @@ function scaffold(options) {
     throw new Error(`Template directory not found: ${templateDir}`);
   }
   const manifest = loadManifest(templateDir);
-  const enabled = (feature) => options.features?.[feature] ?? manifest?.features[feature]?.default ?? true;
+  const enabled = (feature) => {
+    const spec = manifest?.features[feature];
+    if (spec?.allOf)
+      return spec.allOf.every(enabled);
+    return options.features?.[feature] ?? spec?.default ?? true;
+  };
   const skip = /* @__PURE__ */ new Set();
   const renames = {};
   if (manifest) {
@@ -129,6 +150,17 @@ function scaffold(options) {
           skip.add(f);
       }
     }
+    const variants = manifest.indexVariants ?? [];
+    if (variants.length > 0) {
+      const dest = (variants.find((v) => v.when.length === 0) ?? variants[variants.length - 1]).source;
+      const winner = variants.find((v) => v.when.every(enabled)) ?? variants[variants.length - 1];
+      for (const v of variants) {
+        if (v.source !== winner.source)
+          skip.add(v.source);
+      }
+      if (winner.source !== dest)
+        renames[winner.source] = dest;
+    }
   }
   const names = deriveNames(name, cwd);
   const inPlace = name === ".";
@@ -219,12 +251,15 @@ async function resolveFeatures(templateDir, args) {
     return {};
   const manifest = JSON.parse(readFileSync2(manifestPath, "utf8"));
   const features = {};
-  for (const [key, spec] of Object.entries(manifest.features))
+  for (const [key, spec] of Object.entries(manifest.features)) {
+    if (spec.allOf)
+      continue;
     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);
+  const selectionFlags = ["--tests", "--no-tests", "--ui", "--no-ui", "--platform", "--no-platform", "--eslint", "--no-eslint"].some((f) => args.includes(f)) || Boolean(runnersFlag);
   if (args.includes("--tests"))
     features["tests"] = true;
   if (args.includes("--no-tests"))
@@ -233,6 +268,10 @@ async function resolveFeatures(templateDir, args) {
     features["ui"] = true;
   if (args.includes("--no-ui"))
     features["ui"] = false;
+  if (args.includes("--platform"))
+    features["platform"] = true;
+  if (args.includes("--no-platform"))
+    features["platform"] = false;
   if (args.includes("--eslint"))
     features["eslint"] = true;
   if (args.includes("--no-eslint"))
@@ -264,6 +303,9 @@ async function resolveFeatures(templateDir, args) {
       for (const key of runnerKeys)
         features[key] = picks.has(runnerName(key));
     }
+    if ("platform" in manifest.features) {
+      features["platform"] = await askYesNo(rl, "Include a project-owned platform module (custom TS-East functions, plus Python when east-py is on)?", features["platform"]);
+    }
     if ("eslint" in manifest.features) {
       features["eslint"] = await askYesNo(rl, "Include ESLint with the East lint rules?", features["eslint"]);
     }
@@ -292,6 +334,7 @@ function printHelp(kind) {
   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("  --platform | --no-platform   include a project-owned platform module (TS-East; +Python when east-py is on) (default: no)");
     console.log("  --runners=east-node,east-c,east-py   East runtimes to include (default: all)");
   }
   console.log("");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elaraai/create-e3",
-  "version": "1.0.18",
+  "version": "1.0.19",
   "description": "Scaffold a new e3 project (BSL-1.1, Node + Python, durable execution): npm create @elaraai/e3",
   "type": "module",
   "bin": {

package/templates/e3/README.md

@@ -40,5 +40,9 @@ npm run lint      # lint sources
 npm run clean     # remove build output, dependencies, and the local repo
 ```
 
-If you scaffolded with UI, `src/surface.tsx` holds a decision surface — a `ui()` task an operator
+If you scaffolded with UI, `src/ui/index.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.
+
+If you scaffolded with `--platform`, `src/platform/` holds project-owned TS-East platform functions
+(exported via `./platform`) and `platform_module/` holds the Python ones — replace the generated
+`example` functions with your own native code, called from tasks like any East function.

package/templates/e3/gitignore

@@ -3,5 +3,7 @@ dist/
 *.tsbuildinfo
 .venv/
 __pycache__/
+*.egg-info/
+.pytest_cache/
 .repos/
 uv.lock

package/templates/e3/platform_module/__init__.py

@@ -0,0 +1,16 @@
+"""Project-owned Python platform functions, aggregated for the east-py runner.
+
+`east-py run -p platform_module` imports this package and reads the top-level
+``platform`` list below. This mirrors how the first-party east-py-std /
+east-py-datascience packages are built: each submodule ends with
+``<name>_impl = platform_functions(__name__)``, and this file spreads them all
+into ``platform``.
+
+To add a function: create a module beside this file (e.g. ``pricing.py``) ending
+with ``pricing_impl = platform_functions(__name__)``, then add an import and
+spread it into ``platform`` below.
+"""
+
+from .example import example_impl
+
+platform = [*example_impl]

package/templates/e3/platform_module/example.py

@@ -0,0 +1,31 @@
+"""An example project-owned Python platform function — replace it with your own.
+
+Platform functions let East call NATIVE Python (numpy, pandas, scikit-learn, …)
+that East itself can't express. The ``@platform_function`` is bound to East by
+its dotted ``"<project>.<fn>"`` name, which the TypeScript declaration in
+``src/platform_module.ts`` mirrors exactly — keep the two in lockstep. Add
+native dependencies to ``pyproject.toml`` and import them inside the body.
+
+This module ends by collecting its functions into ``example_impl`` (the
+canonical east-py idiom — ``platform_functions`` keys the registry on each
+function's ``__module__``), which ``__init__.py`` spreads into the package's
+top-level ``platform`` list.
+"""
+
+from east.runtime.platform import platform_function, platform_functions
+from east.types.types import ArrayType, FloatType
+
+
+@platform_function(
+    inputs=[ArrayType(FloatType)],
+    output=FloatType,
+    name="__PROJECT_NAME__.example_python",
+)
+def example_python(values):
+    """Example: the mean of a list of floats. Replace with your own logic."""
+    values = list(values)
+    return sum(values) / len(values) if values else 0.0
+
+
+# The platform functions defined in THIS module, in definition order.
+example_impl = platform_functions(__name__)

package/templates/e3/pyproject.platform.toml

@@ -0,0 +1,28 @@
+[project]
+name = "__PROJECT_NAME__"
+description = "__DISPLAY_NAME__"
+requires-python = ">=3.11"
+version = "0.1.0"
+dependencies = [
+  "elaraai-east-py",
+  "elaraai-east-py-std",
+  "elaraai-east-py-io",
+  "elaraai-east-py-datascience",
+  "elaraai-east-py-cli",
+  "pytest",
+  "pytest-subtests",
+]
+
+# Packaging block — without it `uv sync` would not install this project's own
+# code, so `east-py run -p platform_module` could not import it. Matches the
+# repo's pure-Python packages (east-py-std/io/cli). This variant of
+# pyproject.toml ships only with the `--platform` scaffold feature (which
+# requires the east-py runner); the plain pyproject.toml has no build-system, so
+# `uv sync` installs dependencies without trying to build a package that isn't
+# there.
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+packages = ["platform_module"]

package/templates/e3/src/index.platform.py.ts

@@ -0,0 +1,58 @@
+import e3 from "@elaraai/e3";
+import { East, ArrayType, FloatType, IntegerType } from "@elaraai/east";
+
+import { examplePython } from "./platform_module.js";
+import { exampleNode } from "./platform/index.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);
+
+// An example project-owned PYTHON platform function on the east-py runtime.
+// `{ custom: "platform_module" }` loads the project's own package, resolved from
+// <project>/.venv after `uv sync`. Replace `example_python`
+// (platform_module/example.py) with your own.
+export const exampleValuesInput = e3.input("example_values", ArrayType(FloatType), [1.0, 2.0, 3.0, 4.0, 5.0]);
+
+export const examplePythonFn = East.function(
+  [ArrayType(FloatType)],
+  FloatType,
+  ($, values) => {
+    $.return(examplePython(values));
+  },
+);
+
+export const examplePythonTask = e3.task("example_python", [exampleValuesInput], examplePythonFn, {
+  runner: { runtime: "east-py", platforms: [{ custom: "platform_module" }, "east-py-std"] },
+});
+
+// An example project-owned TS-East platform function on the east-node runtime.
+// `{ custom: "@elaraai/__PROJECT_NAME__" }` loads this package's own `./platform`
+// export. Replace `exampleNode` (src/platform/example.ts) with your own.
+export const exampleFactorInput = e3.input("example_factor", FloatType, 1.5);
+
+export const exampleNodeFn = East.function(
+  [IntegerType, FloatType],
+  IntegerType,
+  ($, value, factor) => {
+    $.return(exampleNode(value, factor));
+  },
+);
+
+export const exampleNodeTask = e3.task("example_node", [reorderQty.output, exampleFactorInput], exampleNodeFn, {
+  runner: { runtime: "east-node", platforms: [{ custom: "@elaraai/__PROJECT_NAME__" }] },
+});
+
+export default e3.package("__PROJECT_NAME__", "1.0.0", reorderQty, examplePythonTask, exampleNodeTask);

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

@@ -0,0 +1,39 @@
+import e3 from "@elaraai/e3";
+import { East, FloatType, IntegerType } from "@elaraai/east";
+
+import { exampleNode } from "./platform/index.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);
+
+// An example project-owned TS-East platform function on the east-node runtime.
+// `{ custom: "@elaraai/__PROJECT_NAME__" }` loads this package's own `./platform`
+// export. Replace `exampleNode` (src/platform/example.ts) with your own.
+export const exampleFactorInput = e3.input("example_factor", FloatType, 1.5);
+
+export const exampleNodeFn = East.function(
+  [IntegerType, FloatType],
+  IntegerType,
+  ($, value, factor) => {
+    $.return(exampleNode(value, factor));
+  },
+);
+
+export const exampleNodeTask = e3.task("example_node", [reorderQty.output, exampleFactorInput], exampleNodeFn, {
+  runner: { runtime: "east-node", platforms: [{ custom: "@elaraai/__PROJECT_NAME__" }] },
+});
+
+export default e3.package("__PROJECT_NAME__", "1.0.0", reorderQty, exampleNodeTask);

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

@@ -0,0 +1,59 @@
+import e3 from "@elaraai/e3";
+import { East, ArrayType, FloatType, IntegerType } from "@elaraai/east";
+
+import { surface } from "./ui/index.js";
+import { examplePython } from "./platform_module.js";
+import { exampleNode } from "./platform/index.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);
+
+// An example project-owned PYTHON platform function on the east-py runtime.
+// `{ custom: "platform_module" }` loads the project's own package, resolved from
+// <project>/.venv after `uv sync`. Replace `example_python`
+// (platform_module/example.py) with your own.
+export const exampleValuesInput = e3.input("example_values", ArrayType(FloatType), [1.0, 2.0, 3.0, 4.0, 5.0]);
+
+export const examplePythonFn = East.function(
+  [ArrayType(FloatType)],
+  FloatType,
+  ($, values) => {
+    $.return(examplePython(values));
+  },
+);
+
+export const examplePythonTask = e3.task("example_python", [exampleValuesInput], examplePythonFn, {
+  runner: { runtime: "east-py", platforms: [{ custom: "platform_module" }, "east-py-std"] },
+});
+
+// An example project-owned TS-East platform function on the east-node runtime.
+// `{ custom: "@elaraai/__PROJECT_NAME__" }` loads this package's own `./platform`
+// export. Replace `exampleNode` (src/platform/example.ts) with your own.
+export const exampleFactorInput = e3.input("example_factor", FloatType, 1.5);
+
+export const exampleNodeFn = East.function(
+  [IntegerType, FloatType],
+  IntegerType,
+  ($, value, factor) => {
+    $.return(exampleNode(value, factor));
+  },
+);
+
+export const exampleNodeTask = e3.task("example_node", [reorderQty.output, exampleFactorInput], exampleNodeFn, {
+  runner: { runtime: "east-node", platforms: [{ custom: "@elaraai/__PROJECT_NAME__" }] },
+});
+
+export default e3.package("__PROJECT_NAME__", "1.0.0", reorderQty, examplePythonTask, exampleNodeTask, surface);

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

@@ -0,0 +1,40 @@
+import e3 from "@elaraai/e3";
+import { East, FloatType, IntegerType } from "@elaraai/east";
+
+import { surface } from "./ui/index.js";
+import { exampleNode } from "./platform/index.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);
+
+// An example project-owned TS-East platform function on the east-node runtime.
+// `{ custom: "@elaraai/__PROJECT_NAME__" }` loads this package's own `./platform`
+// export. Replace `exampleNode` (src/platform/example.ts) with your own.
+export const exampleFactorInput = e3.input("example_factor", FloatType, 1.5);
+
+export const exampleNodeFn = East.function(
+  [IntegerType, FloatType],
+  IntegerType,
+  ($, value, factor) => {
+    $.return(exampleNode(value, factor));
+  },
+);
+
+export const exampleNodeTask = e3.task("example_node", [reorderQty.output, exampleFactorInput], exampleNodeFn, {
+  runner: { runtime: "east-node", platforms: [{ custom: "@elaraai/__PROJECT_NAME__" }] },
+});
+
+export default e3.package("__PROJECT_NAME__", "1.0.0", reorderQty, exampleNodeTask, surface);

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

@@ -1,7 +1,7 @@
 import e3 from "@elaraai/e3";
 import { East, IntegerType } from "@elaraai/east";
 
-import { surface } from "./surface.js";
+import { surface } from "./ui/index.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.

package/templates/e3/src/platform/example.ts

@@ -0,0 +1,16 @@
+import { East, IntegerType, FloatType } from "@elaraai/east";
+
+// An example project-owned TS-East platform function — replace it with your own.
+// Platform functions let East call native TS/Node code East can't express. The
+// declaration (`exampleNode`) is what East code calls in a task; the
+// implementation runs on the east-node runtime. To add another, create a sibling
+// file in this folder and wire it into ./index.ts.
+export const exampleNode = East.platform(
+  "__PROJECT_NAME__.example_node",
+  [IntegerType, FloatType],
+  IntegerType,
+);
+
+export const exampleNodeImpl = exampleNode.implement(
+  (value: bigint, factor: number): bigint => BigInt(Math.ceil(Number(value) * factor)),
+);

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

@@ -0,0 +1,14 @@
+// Barrel for the project's TS-East platform functions (run on the east-node
+// runtime). This module IS the package's `./platform` subpath export — its
+// default export is the PlatformFunction[] that east-node-cli loads.
+//
+// To add a function: create a sibling file (e.g. ./discount.ts) exporting its
+// declaration + `<name>Impl`, then add one re-export line and one array entry
+// below.
+import { exampleNodeImpl } from "./example.js";
+
+// Re-export each declaration so e3 tasks (src/index.ts) can call them.
+export { exampleNode } from "./example.js";
+
+// The PlatformFunction[] the east-node runner loads via `./platform`.
+export default [exampleNodeImpl];

package/templates/e3/src/platform_module.ts

@@ -0,0 +1,13 @@
+import { East, ArrayType, FloatType } from "@elaraai/east";
+
+// Type-safe declaration mirroring `platform_module/example.py`'s
+// `example_python` — same dotted "<project>.<fn>" name, same signature.
+// Hand-written (no codegen): keep it in lockstep with the Python
+// @platform_function. East code calls this; the impl runs on the east-py
+// runtime, resolved from the project's own `.venv` (see the `example_python`
+// task in the index).
+export const examplePython = East.platform(
+  "__PROJECT_NAME__.example_python",
+  [ArrayType(FloatType)],
+  FloatType,
+);

package/templates/e3/src/{surface.tsx → ui/index.tsx}

@@ -4,7 +4,9 @@ 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.
+// the tasks and inputs with Data.bind, then add the Observe / Decide controls.
+// To add another surface, define it beside this file and register it in the
+// package (src/index.ts).
 export const surface = ui(
   "surface",
   [],

package/templates/e3/template.json

@@ -7,11 +7,31 @@
     },
     "ui": {
       "default": false,
-      "files": ["src/surface.tsx", "src/index.ui.ts"],
-      "disable": ["src/index.ts"],
-      "rename": { "src/index.ui.ts": "src/index.ts" },
+      "files": ["src/ui/index.tsx"],
       "dependencies": ["@elaraai/east-ui", "@elaraai/e3-ui"]
     },
+    "platform": {
+      "default": false,
+      "files": ["src/platform/index.ts", "src/platform/example.ts"],
+      "packageJson": {
+        "exports": {
+          ".": "./dist/index.js",
+          "./platform": "./dist/platform/index.js",
+          "./package.json": "./package.json"
+        }
+      }
+    },
+    "platform-py": {
+      "allOf": ["platform", "runner:east-py"],
+      "files": [
+        "platform_module/__init__.py",
+        "platform_module/example.py",
+        "src/platform_module.ts",
+        "pyproject.platform.toml"
+      ],
+      "disable": ["pyproject.toml"],
+      "rename": { "pyproject.platform.toml": "pyproject.toml" }
+    },
     "runner:east-node": {
       "default": true,
       "devDependencies": ["@elaraai/east-node-cli"]
@@ -42,6 +62,14 @@
       "devDependencies": ["@elaraai/tsserver-plugin-east"]
     }
   },
+  "indexVariants": [
+    { "when": ["ui", "platform", "runner:east-py"], "source": "src/index.ui.platform.py.ts" },
+    { "when": ["ui", "platform"], "source": "src/index.ui.platform.ts" },
+    { "when": ["ui"], "source": "src/index.ui.ts" },
+    { "when": ["platform", "runner:east-py"], "source": "src/index.platform.py.ts" },
+    { "when": ["platform"], "source": "src/index.platform.ts" },
+    { "when": [], "source": "src/index.ts" }
+  ],
   "scriptVariants": {
     "test": [
       { "when": ["tests", "runner:east-py"], "value": "npm run build && npm run test:export && npm run test:py" },
@@ -50,6 +78,10 @@
     "setup": [
       { "when": ["runner:east-py"], "value": "npm install && uv sync" },
       { "when": [], "value": "npm install" }
+    ],
+    "start": [
+      { "when": ["platform"], "value": "npm run build && npm run deploy && e3 dataflow run .repos __WORKSPACE_NAME__" },
+      { "when": [], "value": "npm run deploy && e3 dataflow run .repos __WORKSPACE_NAME__" }
     ]
   }
 }

package/templates/e3/tests/test_unit.py

@@ -21,6 +21,13 @@ try:
 except ImportError:
     io_platform = []
 
+# A project-owned platform module (scaffolded by `--platform`). Absent unless
+# that feature is on, so this import is best-effort.
+try:
+    from platform_module import platform as project_platform
+except ImportError:
+    project_platform = []
+
 TEST_IR_DIR = Path("dist/test-ir")
 
 
@@ -65,6 +72,8 @@ def run_one(ir_file: Path) -> tuple[int, int]:
         pf for pf in std_platform if pf["name"] not in test_names
     ] + [
         pf for pf in io_platform if pf["name"] not in test_names
+    ] + [
+        pf for pf in project_platform if pf["name"] not in test_names
     ] + [
         PlatformFunction(name="describe", inputs=[StringType, FunctionType([], NullType)], output=NullType, type="sync", fn=describe_impl),
         PlatformFunction(name="test", inputs=[StringType, FunctionType([], NullType)], output=NullType, type="sync", fn=test_impl),