@codeandmoney/jargal 0.0.0-rc.2 → 0.0.0-rc.5

package/actions/pipe.ts

@@ -0,0 +1,7 @@
+// import type { Action } from "../types.ts";
+
+// export function pipe(): Action {
+//   return function execute(_params) {
+//     throw new Error("Action is not implemented");
+//   };
+// }

package/actions/render-template.ts

@@ -1,15 +1,15 @@
 import type { Action, Context } from "../types.ts";
 
 export function renderTemplate({
-  fullpath,
+  templatePath,
   template,
   getData,
-  write,
+  save,
 }: {
   template: string;
-  fullpath: string;
+  templatePath: string;
   getData?: (ctx: Context) => Record<string, unknown>;
-  write?: Action<{ content?: string; destination?: string }>;
+  save?: Action<{ templateContent?: string; destination?: string }>;
 }): Action {
   if (!template) {
     return () => undefined;
@@ -20,17 +20,10 @@ export function renderTemplate({
 
     const renderedTemplate = params.renderer.renderString({ template, data });
 
-    const renderedPath = params.renderer.renderString({
-      template: fullpath,
-      data,
-    });
+    const renderedPath = params.renderer.renderString({ template: templatePath, data });
 
-    if (write) {
-      return write({
-        ...params,
-        content: renderedTemplate,
-        destination: renderedPath,
-      });
+    if (save) {
+      return save({ ...params, context: { ...params.context, templateContent: renderedTemplate, destination: renderedPath } });
     }
   };
 }

package/actions/run/run.ts

@@ -0,0 +1,20 @@
+import type { BaseIssue, BaseAction, Config, InferIssue, InferOutput } from "../../types/index.ts";
+
+/**
+ * Parses an unknown input based on a schema.
+ *
+ * @param action The action to be used.
+ * @param input The input to be parsed.
+ * @param config The run configuration.
+ *
+ * @returns The parsed input.
+ */
+export function run<const Action extends BaseAction<unknown, unknown>>(action: Action, input: unknown): InferOutput<Action> {
+  const context = action["~run"]({ value: input }, {});
+
+  if (context.issues) {
+    throw new Error("msg");
+  }
+
+  return context.value;
+}

package/actions/validate-answers.ts

@@ -6,7 +6,7 @@ const primitiveSchema = v.union([v.pipe(v.string(), v.minLength(1)), v.boolean()
 
 const defaultSchema = v.record(v.string(), v.union([primitiveSchema, v.array(primitiveSchema)]));
 
-export function validateAnswers<Schema extends v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>>(schema?: Schema): Action {
+export function validateAnswers<Schema extends v.BaseAction<unknown, unknown, v.BaseIssue<unknown>>>(schema?: Schema): Action {
   return function execute(params) {
     v.assert(schema ?? defaultSchema, params.context.answers);
   };

package/actions/write/write.ts

@@ -0,0 +1,69 @@
+import type { BaseIssue, BaseAction, ErrorMessage, Context, OutputContext, BaseContext } from "../../types/index.ts";
+// import { _addIssue, _getStandardProps } from "../../utils/index.ts";
+
+/**
+ * Write issue interface.
+ */
+export interface WriteIssue extends BaseIssue<unknown> {
+  /**
+   * The issue kind.
+   */
+  readonly kind: "action";
+  /**
+   * The issue type.
+   */
+  readonly type: "string";
+}
+
+/**
+ * Write schema interface.
+ */
+export interface WriteAction<Config extends Record<string, any> | undefined, Output extends Record<string, any>> extends BaseAction<Config, Output> {
+  readonly config: Config;
+
+  /**
+   * The expected property.
+   */
+  readonly expects: "string";
+}
+
+export type WriteActionConfig = {
+  destination?: string;
+  templateContent?: string;
+  mode?: "force" | "skip-if-exists";
+};
+
+// /**
+//  * Creates a string schema.
+//  *
+//  * @param config The error config.
+//  *
+//  * @returns A string schema.
+//  */
+
+export function write<Ctx extends Record<string, any>>(config?: WriteActionConfig): WriteAction<WriteActionConfig, Ctx>;
+export function write<Ctx extends undefined = undefined>(config: WriteActionConfig): WriteAction<WriteActionConfig, {}>;
+export function write<Ctx extends undefined | Record<string, any> = undefined>(
+  config?: WriteActionConfig,
+): WriteAction<WriteActionConfig, Ctx extends undefined ? {} : Ctx> {
+  return {
+    kind: "action",
+    expects: "string",
+
+    config: config ?? {},
+    "~run"(context, config) {
+      context.renderer;
+
+      if (typeof context.value === "string") {
+        // @ts-expect-error
+        context.typed = true;
+      } else {
+        // _addIssue(this, "type", context, config);
+      }
+      // @ts-expect-error
+      return context as OutputContext<string, WriteIssue>;
+    },
+  };
+}
+
+//  hooks?: ActionHooks;

package/actions/write.ts

@@ -6,38 +6,42 @@ import { dirname } from "node:path";
 
 export type WriteActionConfig = {
   destination?: string;
-  content?: string;
+  templateContent?: string;
   mode?: "force" | "skip-if-exists";
 };
 
-export function write({ destination, content, mode }: WriteActionConfig): Action<{ content?: string; destination?: string }> {
-  return async function execute({ content: content_, destination: destination_ }) {
-    const dest = destination || destination_;
-    const cntn = content || content_;
+export function write({
+  destination: writeDestination,
+  templateContent: writeContent,
+  mode,
+}: WriteActionConfig): Action<{ templateContent?: string; destination?: string }> {
+  return async function execute({ context: { templateContent: executeContent, destination: executeDestination } }) {
+    const destination = executeDestination || writeDestination;
+    const templateContent = executeContent || writeContent;
 
-    assert(dest, "must provide `dest`");
-    assert(cntn, "must provide `cntn`");
+    assert(destination, "must provide `destination`");
+    assert(templateContent, "must provide `templateContent`");
 
-    await mkdir(dirname(dest), { recursive: true });
+    await mkdir(dirname(destination), { recursive: true });
 
-    let doesExist = await fileExists(dest);
+    let doesExist = await fileExists(destination);
 
     if (doesExist && mode === "force") {
-      await rm(dest, { recursive: true });
+      await rm(destination, { recursive: true, force: true });
       doesExist = false;
     }
 
     if (doesExist && mode !== "skip-if-exists") {
-      throw `File already exists\n -> ${dest}`;
+      throw `File already exists\n -> ${destination}`;
     }
 
     if (doesExist && mode === "skip-if-exists") {
-      console.info(`[SKIPPED] ${dest} (exists)`);
+      console.info(`[SKIPPED] ${destination} (exists)`);
       return;
     }
 
-    await writeFile(dest, new TextEncoder().encode(cntn));
-  } satisfies Action<{ content?: string; destination?: string }>;
+    await writeFile(destination, new TextEncoder().encode(templateContent));
+  } satisfies Action<{ templateContent?: string; destination?: string }>;
 }
 
 function fileExists(destination: string) {

package/bun.lock

@@ -0,0 +1,68 @@
+{
+  "lockfileVersion": 1,
+  "workspaces": {
+    "": {
+      "name": "@codeandmoney/jargal",
+      "dependencies": {
+        "change-case": "^5.4.4",
+        "enquirer": "^2.4.1",
+        "es-toolkit": "^1.40.0",
+        "handlebars": "^4.7.8",
+        "title-case": "^4.3.2",
+        "valibot": "^1.1.0",
+      },
+      "devDependencies": {
+        "@types/bun": "^1.3.0",
+        "@types/node": "^24.7.2",
+      },
+      "peerDependencies": {
+        "typescript": "^5",
+      },
+    },
+  },
+  "packages": {
+    "@types/bun": ["@types/bun@1.3.0", "", { "dependencies": { "bun-types": "1.3.0" } }, "sha512-+lAGCYjXjip2qY375xX/scJeVRmZ5cY0wyHYyCYxNcdEXrQ4AOe3gACgd4iQ8ksOslJtW4VNxBJ8llUwc3a6AA=="],
+
+    "@types/node": ["@types/node@24.7.2", "", { "dependencies": { "undici-types": "~7.14.0" } }, "sha512-/NbVmcGTP+lj5oa4yiYxxeBjRivKQ5Ns1eSZeB99ExsEQ6rX5XYU1Zy/gGxY/ilqtD4Etx9mKyrPxZRetiahhA=="],
+
+    "@types/react": ["@types/react@19.2.2", "", { "dependencies": { "csstype": "^3.0.2" } }, "sha512-6mDvHUFSjyT2B2yeNx2nUgMxh9LtOWvkhIU3uePn2I2oyNymUAX1NIsdgviM4CH+JSrp2D2hsMvJOkxY+0wNRA=="],
+
+    "ansi-colors": ["ansi-colors@4.1.3", "", {}, "sha512-/6w/C21Pm1A7aZitlI5Ni/2J6FFQN8i1Cvz3kHABAAbw93v/NlvKdVOqz7CCWz/3iv/JplRSEEZ83XION15ovw=="],
+
+    "ansi-regex": ["ansi-regex@5.0.1", "", {}, "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ=="],
+
+    "bun-types": ["bun-types@1.3.0", "", { "dependencies": { "@types/node": "*" }, "peerDependencies": { "@types/react": "^19" } }, "sha512-u8X0thhx+yJ0KmkxuEo9HAtdfgCBaM/aI9K90VQcQioAmkVp3SG3FkwWGibUFz3WdXAdcsqOcbU40lK7tbHdkQ=="],
+
+    "change-case": ["change-case@5.4.4", "", {}, "sha512-HRQyTk2/YPEkt9TnUPbOpr64Uw3KOicFWPVBb+xiHvd6eBx/qPr9xqfBFDT8P2vWsvvz4jbEkfDe71W3VyNu2w=="],
+
+    "csstype": ["csstype@3.1.3", "", {}, "sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw=="],
+
+    "enquirer": ["enquirer@2.4.1", "", { "dependencies": { "ansi-colors": "^4.1.1", "strip-ansi": "^6.0.1" } }, "sha512-rRqJg/6gd538VHvR3PSrdRBb/1Vy2YfzHqzvbhGIQpDRKIa4FgV/54b5Q1xYSxOOwKvjXweS26E0Q+nAMwp2pQ=="],
+
+    "es-toolkit": ["es-toolkit@1.40.0", "", {}, "sha512-8o6w0KFmU0CiIl0/Q/BCEOabF2IJaELM1T2PWj6e8KqzHv1gdx+7JtFnDwOx1kJH/isJ5NwlDG1nCr1HrRF94Q=="],
+
+    "handlebars": ["handlebars@4.7.8", "", { "dependencies": { "minimist": "^1.2.5", "neo-async": "^2.6.2", "source-map": "^0.6.1", "wordwrap": "^1.0.0" }, "optionalDependencies": { "uglify-js": "^3.1.4" }, "bin": { "handlebars": "bin/handlebars" } }, "sha512-vafaFqs8MZkRrSX7sFVUdo3ap/eNiLnb4IakshzvP56X5Nr1iGKAIqdX6tMlm6HcNRIkr6AxO5jFEoJzzpT8aQ=="],
+
+    "minimist": ["minimist@1.2.8", "", {}, "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA=="],
+
+    "neo-async": ["neo-async@2.6.2", "", {}, "sha512-Yd3UES5mWCSqR+qNT93S3UoYUkqAZ9lLg8a7g9rimsWmYGK8cVToA4/sF3RrshdyV3sAGMXVUmpMYOw+dLpOuw=="],
+
+    "source-map": ["source-map@0.6.1", "", {}, "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g=="],
+
+    "strip-ansi": ["strip-ansi@6.0.1", "", { "dependencies": { "ansi-regex": "^5.0.1" } }, "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A=="],
+
+    "title-case": ["title-case@4.3.2", "", {}, "sha512-I/nkcBo73mO42Idfv08jhInV61IMb61OdIFxk+B4Gu1oBjWBPOLmhZdsli+oJCVaD+86pYQA93cJfFt224ZFAA=="],
+
+    "typescript": ["typescript@5.9.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw=="],
+
+    "uglify-js": ["uglify-js@3.19.3", "", { "bin": { "uglifyjs": "bin/uglifyjs" } }, "sha512-v3Xu+yuwBXisp6QYTcH4UbH+xYJXqnq2m/LtQVWKWzYc1iehYnLixoQDN9FH6/j9/oybfd6W9Ghwkl8+UMKTKQ=="],
+
+    "undici-types": ["undici-types@7.14.0", "", {}, "sha512-QQiYxHuyZ9gQUIrmPo3IA+hUl4KYk8uSA7cHrcKd/l3p1OTpZcM0Tbp9x7FAtXdAYhlasd60ncPpgu6ihG6TOA=="],
+
+    "valibot": ["valibot@1.1.0", "", { "peerDependencies": { "typescript": ">=5" }, "optionalPeers": ["typescript"] }, "sha512-Nk8lX30Qhu+9txPYTwM0cFlWLdPFsFr6LblzqIySfbZph9+BFsAHsNvHOymEviUepeIW6KFHzpX8TKhbptBXXw=="],
+
+    "wordwrap": ["wordwrap@1.0.0", "", {}, "sha512-gvVzJFlPycKc5dZN4yPkP8w7Dc37BtP1yczEneOb4uq34pXZcvrtRTmWV8W+Ume+XCxKgbjM+nevkyFPMybd4Q=="],
+
+    "bun-types/@types/node": ["@types/node@24.7.0", "", { "dependencies": { "undici-types": "~7.14.0" } }, "sha512-IbKooQVqUBrlzWTi79E8Fw78l8k1RNtlDDNWsFZs7XonuQSJ8oNYfEeclhprUldXISRMLzBpILuKgPlIxm+/Yw=="],
+  }
+}

package/jargal.ts

@@ -0,0 +1,139 @@
+import { merge, toMerged } from "es-toolkit";
+import { Renderer } from "./renderer";
+import { write } from "./actions/jargal-write";
+import { resolve, dirname, join } from "path";
+import { mkdir } from "fs/promises";
+import { writeFile } from "fs/promises";
+
+import { templates, type TemplatesMap } from "./actions/jargal-templates";
+import { context } from "./actions/jargal-context";
+
+export { templates, context };
+
+export type RenderEntry = { control: "user"; data: any; pathTemplate: string; contentTemplate: string } | { control?: "auto"; data: any; destination: string };
+
+export class Jargal<const in out Context> {
+  #context = {
+    templates: { default: {} },
+    renderData: [] as { baseSavePath: string; data: any }[],
+    renderedContent: [] as { savePath: string; content: string }[],
+  } as Context;
+
+  #renderer: Renderer;
+
+  get context() {
+    return this.#context;
+  }
+
+  constructor() {
+    this.#renderer = new Renderer();
+  }
+
+  setContext<Setter extends (...args: any) => any>(setter: Setter): Jargal<ReturnType<Setter> & Context>;
+  setContext<const Setter extends Record<string, any>>(setter: Setter): Jargal<Setter & Context>;
+  setContext(setter: any) {
+    if (typeof setter === "function") {
+      const context = setter(this.#context);
+      this.#context = toMerged(this.#context as any, context);
+      return this as any;
+    }
+
+    this.#context = toMerged(this.#context as any, setter);
+    return this as any;
+  }
+
+  async render(params?: {
+    composeRenderData?: (ctx: Context) => RenderEntry[] | Promise<RenderEntry[]>;
+    scope?: Context extends { templates: { [key: string]: any } } ? keyof Context["templates"] : "default";
+  }): Promise<Jargal<Context & { renderedContent: { savePath: string; content: string }[] }>> {
+    const composeData: (ctx: Context) => RenderEntry[] | Promise<RenderEntry[]> =
+      params?.composeRenderData ??
+      // @ts-expect-error
+      ((ctx: Context) => ctx.renderData);
+
+    // @ts-expect-error
+    const templatesToRender = this.#context.templates[params?.scope ?? "default"] as TemplatesMap;
+
+    const composedData = await composeData(this.#context);
+
+    for (const renderEntry of composedData) {
+      if (!renderEntry.control || renderEntry.control === "auto") {
+        for (const [filename, template] of Object.entries(templatesToRender)) {
+          // @ts-expect-error
+          this.#context.renderedContent.push({
+            savePath: this.#renderer.renderString({ template: join(renderEntry.destination, template.savePath), data: renderEntry.data }),
+            content: this.#renderer.renderString({ template: template.templateContent, data: renderEntry.data }),
+          });
+        }
+
+        continue;
+      }
+
+      if (renderEntry.control === "user") {
+        // @ts-expect-error
+        this.#context.renderedContent.push({
+          savePath: this.#renderer.renderString({ template: renderEntry.pathTemplate, data: renderEntry.data }),
+          content: this.#renderer.renderString({ template: renderEntry.contentTemplate, data: renderEntry.data }),
+        });
+
+        continue;
+      }
+    }
+
+    //     const entryContentTemplate = renderEntry.contentTemplate;
+
+    // let renderedContent: string | undefined = undefined;
+    // let renderedPath: string | undefined = undefined;
+
+    // if (renderEntry.contentTemplate) {
+    //   const templateToRender =
+    //     // @ts-expect-error
+    //     (this.#context.templates[params?.scope ?? "default"] as TemplatesMap)[renderEntry.contentTemplate]?.templateContent || renderEntry.contentTemplate;
+
+    //   renderedContent = this.#renderer.renderString({ template: templateToRender, data: renderEntry.data });
+    //   continue;
+    // }
+
+    // if (renderEntry.pathTemplate) {
+    //   renderedPath = this.#renderer.renderString({ template: renderEntry.pathTemplate, data: renderEntry.data });
+    //   continue;
+    // }
+
+    // for (const [filename, template] of Object.entries(templatesToRender)) {
+    //   // console.log({ renderEntry, template });
+
+    //   // @ts-expect-error
+    //   this.#context.renderedContent.push({
+    //     savePath:
+    //       renderedPath ||
+    //       this.#renderer.renderString({
+    //         template: renderEntry.baseSavePath ?? (renderEntry?.fullSavePath ? renderEntry?.fullSavePath : join(renderEntry.baseSavePath, template.savePath)),
+    //         data: renderEntry.data,
+    //       }),
+    //     content:
+    //       renderedContent || this.#renderer.renderString({ template: renderEntry?.contentTemplate ?? template.templateContent, data: renderEntry.data }),
+    //   });
+    // }
+
+    return this as any;
+  }
+
+  async write(write?: (params: { savePath: string; content: string }) => void | Promise<void>): Promise<void> {
+    if (typeof write === "function") {
+      // @ts-expect-error
+      for (const renderConfig of this.#context.renderedContent as { savePath: string; content: string }[]) {
+        // console.log({ renderConfig })
+        await write(renderConfig);
+      }
+
+      return;
+    }
+
+    // console.log({ renderedContent: this.#context.renderedContent})
+    // @ts-expect-error
+    for (const renderConfig of this.#context.renderedContent as { savePath: string; content: string }[]) {
+      await mkdir(dirname(renderConfig.savePath), { recursive: true });
+      await writeFile(renderConfig.savePath, new TextEncoder().encode(renderConfig.content), {});
+    }
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codeandmoney/jargal",
-  "version": "0.0.0-rc.2",
+  "version": "0.0.0-rc.5",
   "description": "Renderer",
   "license": "MIT",
   "author": "Code & Money Team",
@@ -12,7 +12,8 @@
     }
   ],
   "exports": {
-    ".": "./exports.ts",
+    "./old": "./exports.ts",
+    ".": "./jargal.ts",
     "./types": "./types.ts",
     "./actions": "./actions/exports.ts"
   },

package/renderer.ts

@@ -31,10 +31,10 @@ export class Renderer {
     return this;
   }
 
-  public readonly partials: Partials = readonly(this.#partials);
-  public readonly helpers: Helpers = readonly(this.#helpers);
+  private readonly partials: Partials = readonly(this.#partials);
+  private readonly helpers: Helpers = readonly(this.#helpers);
 
-  public get<T extends SetterScope>(scope: T, name: string): GetReturnType<T> {
+  private get<T extends SetterScope>(scope: T, name: string): GetReturnType<T> {
     const target = get(this.#mapping, scope);
 
     if (!target) {
@@ -44,7 +44,7 @@ export class Renderer {
     return get(target, name);
   }
 
-  public list<T extends `${SetterScope}s`, O extends boolean = false>(
+  private list<T extends `${SetterScope}s`, O extends boolean = false>(
     scope: T,
     options?: { full?: O },
   ): O extends true ? MappingScope[T extends `${infer S}s` ? S : T][] : string[] {

package/runner.ts

@@ -60,8 +60,6 @@ async function execRecursive(executed: Action | Action[], { context, renderer }:
     return await executeAction({ action: executed, context, renderer });
   }
 
-  // assert(!executed);
-
   return undefined;
 }
 
@@ -79,7 +77,7 @@ const ConfigSchema = v.object({
 });
 
 export async function run(runConfig: Config): Promise<void> {
-  const config = v.parse(ConfigSchema, runConfig);
+  const config = v.run(ConfigSchema, runConfig);
 
   if (config.generators.length === 1) {
     const generator = config.generators[0];
@@ -87,14 +85,14 @@ export async function run(runConfig: Config): Promise<void> {
     assert(generator);
 
     return await runGenerator({
-      context: { errors: [], answers: {}, context: {} },
+      context: { errors: [], answers: {} },
       renderer: new Renderer(),
       generator,
     });
   }
 
   return await runGenerator({
-    context: { errors: [], answers: {}, context: {} },
+    context: { errors: [], answers: {} },
     renderer: new Renderer(),
     generator: { name: "select", actions: [selectGenerator(config)] },
   });

package/types.ts

@@ -4,11 +4,10 @@ export interface Config {
   generators: GeneratorConfig[];
 }
 
-export interface Context extends Record<string, unknown> {
+export type Context<Ctx extends object = {}> = Ctx & {
   answers: Record<string, string | boolean | (string | boolean)[]>;
   errors: Error[];
-  context: Record<string, any>;
-}
+};
 
 export type DeepReadonly<T> = {
   readonly [Key in keyof T]: T[Key] extends any[] ? T[Key] : T[Key] extends object ? DeepReadonly<T[Key]> : T[Key];
@@ -21,31 +20,31 @@ export interface GeneratorParams {
   hooks?: ActionHooks;
 }
 
-export interface ActionParams {
-  context: Context;
+export interface ActionParams<Ctx extends object = {}> {
+  context: Context<Ctx>;
   renderer: Renderer;
   hooks?: ActionHooks;
 }
 
-export interface ExecuteActionParams {
-  context: Context;
+export interface ExecuteActionParams<Ctx extends object = {}> {
+  context: Context<Ctx>;
   renderer: Renderer;
   action: Action;
 }
 
+export type ContextAction<Ctx extends object = {}> = (params: DeepReadonly<ExecuteActionParams<Ctx>>) => Partial<Context<Ctx>> | Promise<Partial<Context<Ctx>>>;
+
 export interface GeneratorConfig {
   name: string;
-  // TODO: implement commented out interface
-  description?: string; // | (( params: unknown ) => string)
-  // TODO: implement commented out interface
-  actions: Action[]; // | Promise<Action[]>  | (( params: unknown ) => Action[] | Promise<Action[]>)
+  description?: string;
+  actions: Action[];
 }
 
 export type HelperFn = (str: string) => string;
 
 export interface TextHelpers extends Record<string, HelperFn> {}
 
-export type Action<T extends object = {}> = (params: ActionParams & T) => void | Action | Action[] | Promise<void | Action | Action[]>;
+export type Action<Ctx extends object = {}> = (params: ActionParams<Ctx>) => void | Action | Action[] | Promise<void | Action | Action[]>;
 
 export interface ActionHooksFailures {
   path: string;
@@ -90,5 +89,3 @@ export type GetReturnType<T extends SetterScope> = Mapping[T];
 
 export interface Partials extends Record<string, string> {}
 export interface Helpers extends Record<string, any> {}
-
-export type ContextAction = (context: DeepReadonly<Context>) => Partial<Context> | Promise<Partial<Context>>;