@akanjs/cli 0.9.55 → 0.9.57

package/cjs/index.js

@@ -228,7 +228,7 @@ var Logger = class _Logger {
     const contentMsg = this.#colorize(content, logLevel);
     const timeDiffMsg = clc.yellow(`+${now.diff(_Logger.#startAt, "ms")}ms`);
     if (typeof window === "undefined")
-      process[writeStreamType].write(
+      process[writeStreamType]?.write(
         `${processMsg} ${timestampMsg} ${logLevelMsg} ${contextMsg} ${contentMsg} ${timeDiffMsg}
 `
       );
@@ -2008,10 +2008,10 @@ var Executor = class _Executor {
     this.logger.verbose(`Remove file ${readPath}`);
     return this;
   }
-  removeDir(dirPath) {
+  async removeDir(dirPath) {
     const readPath = this.getPath(dirPath);
     if (import_fs4.default.existsSync(readPath))
-      import_fs4.default.rmSync(readPath, { recursive: true });
+      await import_fs4.default.promises.rm(readPath, { recursive: true });
     this.logger.verbose(`Remove directory ${readPath}`);
     return this;
   }
@@ -2059,7 +2059,8 @@ var Executor = class _Executor {
     const dest = this.getPath(destPath);
     if (!import_fs4.default.existsSync(src))
       return;
-    if (!import_fs4.default.existsSync(dest))
+    const isDirectory = import_fs4.default.statSync(src).isDirectory();
+    if (!import_fs4.default.existsSync(dest) && isDirectory)
       await import_promises.default.mkdir(dest, { recursive: true });
     await import_promises.default.cp(src, dest, { recursive: true });
   }
@@ -2614,32 +2615,23 @@ var AppExecutor = class _AppExecutor extends SysExecutor {
     return this.#akanConfig;
   }
   async syncAssets(libDeps) {
-    const projectPublicLibPath = `${this.cwdPath}/public/libs`;
-    const projectAssetsLibPath = `${this.cwdPath}/assets/libs`;
+    const projectPublicPath = `${this.cwdPath}/public`;
+    const projectAssetsPath = `${this.cwdPath}/assets`;
+    const projectPublicLibPath = `${projectPublicPath}/libs`;
+    const projectAssetsLibPath = `${projectAssetsPath}/libs`;
+    await Promise.all([this.removeDir(projectPublicLibPath), this.removeDir(projectAssetsLibPath)]);
+    const targetPublicDeps = libDeps.filter((dep) => this.exists(`${this.workspace.workspaceRoot}/libs/${dep}/public`));
+    const targetAssetsDeps = libDeps.filter((dep) => this.exists(`${this.workspace.workspaceRoot}/libs/${dep}/assets`));
     await Promise.all([
-      import_fs4.default.existsSync(projectPublicLibPath) && import_promises.default.rm(projectPublicLibPath, { recursive: true }),
-      import_fs4.default.existsSync(projectAssetsLibPath) && import_promises.default.rm(projectAssetsLibPath, { recursive: true })
-    ]);
-    const targetPublicDeps = libDeps.filter(
-      (dep) => import_fs4.default.existsSync(`${this.workspace.workspaceRoot}/libs/${dep}/public`)
-    );
-    const targetAssetsDeps = libDeps.filter(
-      (dep) => import_fs4.default.existsSync(`${this.workspace.workspaceRoot}/libs/${dep}/assets`)
-    );
-    await Promise.all([
-      ...targetPublicDeps.map((dep) => import_promises.default.mkdir(`${projectPublicLibPath}/${dep}`, { recursive: true })),
-      ...targetAssetsDeps.map((dep) => import_promises.default.mkdir(`${projectAssetsLibPath}/${dep}`, { recursive: true }))
+      ...targetPublicDeps.map((dep) => this.mkdir(`${projectPublicLibPath}/${dep}`)),
+      ...targetAssetsDeps.map((dep) => this.mkdir(`${projectAssetsLibPath}/${dep}`))
     ]);
     await Promise.all([
       ...targetPublicDeps.map(
-        (dep) => import_promises.default.cp(`${this.workspace.workspaceRoot}/libs/${dep}/public`, `${projectPublicLibPath}/${dep}`, {
-          recursive: true
-        })
+        (dep) => this.cp(`${this.workspace.workspaceRoot}/libs/${dep}/public`, `${projectPublicLibPath}/${dep}`)
       ),
       ...targetAssetsDeps.map(
-        (dep) => import_promises.default.cp(`${this.workspace.workspaceRoot}/libs/${dep}/assets`, `${projectAssetsLibPath}/${dep}`, {
-          recursive: true
-        })
+        (dep) => this.cp(`${this.workspace.workspaceRoot}/libs/${dep}/assets`, `${projectAssetsLibPath}/${dep}`)
       )
     ]);
   }
@@ -5942,8 +5934,8 @@ var requestUnit = ({
 var ModuleRunner = class {
   async createModule(workspace, sysType, sysName, moduleName, description) {
   }
-  removeModule(module2) {
-    module2.sys.removeDir(`lib/${module2.name}`);
+  async removeModule(module2) {
+    await module2.sys.removeDir(`lib/${module2.name}`);
   }
   async createComponentTemplate(module2, type) {
     await module2.sys.applyTemplate({
@@ -6080,8 +6072,8 @@ var ModuleScript = class {
     await this.createTemplate(executor);
     sys3.log(`Module ${name} created in ${sys3.type}s/${sys3.name}/lib/${name}`);
   }
-  removeModule(mod) {
-    this.#runner.removeModule(mod);
+  async removeModule(mod) {
+    await this.#runner.removeModule(mod);
   }
   async createService(workspace, name) {
   }
@@ -6159,8 +6151,8 @@ var ModuleCommand = class {
     const name = lowerlize(moduleName.replace(/ /g, ""));
     await this.moduleScript.createModuleTemplate(sys3, name, { page });
   }
-  removeModule(module2) {
-    this.moduleScript.removeModule(module2);
+  async removeModule(module2) {
+    await this.moduleScript.removeModule(module2);
   }
   async createView(module2) {
     await this.moduleScript.createView(module2);
@@ -6960,8 +6952,8 @@ var ScalarScript = class {
     const { session, scalarNames } = await this.#runner.createScalarConstant(sys3, scalarName);
     await this.#runner.updateScalarDictionaries(sys3, scalarNames, { session });
   }
-  removeScalar(sys3, scalarName) {
-    sys3.removeDir(`lib/__scalar/${scalarName}`);
+  async removeScalar(sys3, scalarName) {
+    await sys3.removeDir(`lib/__scalar/${scalarName}`);
   }
 };
 
@@ -6971,8 +6963,8 @@ var ScalarCommand = class {
   async createScalar(sys3, scalarName) {
     await this.scalarScript.createScalar(sys3, lowerlize(scalarName.replace(/ /g, "")));
   }
-  removeScalar(sys3, scalarName) {
-    this.scalarScript.removeScalar(sys3, scalarName);
+  async removeScalar(sys3, scalarName) {
+    await this.scalarScript.removeScalar(sys3, scalarName);
   }
 };
 __decorateClass([

package/cjs/src/guidelines/databaseModule/databaseModule.instruction.md

@@ -207,7 +207,7 @@ import * as cnst from "../cnst";
 import type * as db from "../db";
 
 export class UserSignal extends DbSignal(cnst.userCnst, cnst.Srvs, {
-  guards: { get: Query.Public, cru: Mutation.Admin },
+  guards: { root: Admin, get: Query.Public, cru: Mutation.Admin },
 }) {
   @Mutation.Public(() => cnst.util.AccessToken)
   async signin(
@@ -578,30 +578,36 @@ export const Layout = () => (
 ## Best Practices
 
 1. **Naming Conventions**
+
    - Use PascalCase for classes and components (e.g., `UserService`, `User.Unit.tsx`)
    - Use camelCase for files (e.g., `user.service.ts`, `user.document.ts`)
 
 2. **Security**
+
    - Use `@Field.Secret` for sensitive data like passwords
    - Apply proper permission guards to queries and mutations (`@Query.Admin`, `@Mutation.Public`)
    - Validate input data using the `validate` option in `@Field.Prop`
 
 3. **Code Organization**
+
    - Keep business logic in service files
    - Use signals for API calls only, not for business logic
    - Define reusable utility methods in document models
 
 4. **Performance**
+
    - Use dataloader pattern (`@Loader.ByField`) for efficient database access
    - Create proper indexes in the middleware
    - Use projections to limit returned fields when appropriate
 
 5. **Testing**
+
    - Create signal tests for each API endpoint
    - Mock services for unit testing signals
    - Use integration tests for testing complex workflows
 
 6. **UI Components**
+
    - Follow the separation between Template, Unit, View, and Zone components
    - Make components reusable across different parts of the application
    - Use dictionary files for all UI text to support internationalization

package/cjs/src/guidelines/modelSignal/modelSignal.instruction.md

@@ -27,7 +27,7 @@ import * as cnst from "../cnst";
 import type * as db from "../db";
 
 export class ModelNameSignal extends DbSignal(cnst.modelNameCnst, cnst.Srvs, {
-  guards: { get: Query.Public, cru: Mutation.User },
+  guards: { root: Admin, get: Query.Public, cru: Mutation.User },
 }) {
   // Signal methods here...
 }
@@ -259,7 +259,7 @@ DbSignal creates standard operations that you don't need to implement:
 
 ```typescript
 export class BoardSignal extends DbSignal(cnst.boardCnst, cnst.Srvs, {
-  guards: { get: Query.Public, cru: Mutation.Admin },
+  guards: { root: Admin, get: Query.Public, cru: Mutation.Admin },
 }) {
   // Custom methods beyond CRUD go here
 }
@@ -378,7 +378,7 @@ async getProjectDetails(
 
 ```typescript
 export class ProductSignal extends DbSignal(cnst.productCnst, cnst.Srvs, {
-  guards: { get: Query.Public, cru: Mutation.Admin },
+  guards: { root: Admin, get: Query.Public, cru: Mutation.Admin },
 }) {
   // Custom methods beyond auto-generated CRUD
   @Query.Public(() => [cnst.Product])

package/cjs/src/guidelines/modelTemplate/modelTemplate.instruction.md

@@ -49,7 +49,7 @@ export const General = ({ id }: { id?: string }) => {
   return (
     <div className="grid grid-cols-1 gap-4">
       <Field.Text
-        label={l.field("model", "fieldName")}
+        label={l("model.fieldName")}
         value={form.fieldName}
         onChange={(v) => st.do.setFieldNameOn[Model](v)}
       />
@@ -139,7 +139,7 @@ useEffect(() => {
 
 ```tsx
 <Field.List
-  label={l.field("map", "spawnPositions")}
+  label={l("map.spawnPositions")}
   value={form.spawnPositions}
   onAdd={() => st.do.addSpawnPosition(defaultPosition)}
   renderItem={(position, idx) => (
@@ -201,12 +201,12 @@ useEffect(() => {
 const { l } = usePage();
 
 // Basic field
-<Field.Text label={l.field("model", "name")} />
+<Field.Text label={l("model.name")} />
 
 // With description
 <Field.Text
-  label={l.field("model", "email")}
-  desc={l.desc("model", "email")}
+  label={l("model.email")}
+  desc={l("model.email.desc")}
 />
 
 // Dynamic content

package/cjs/src/guidelines/sharedUiUsage/sharedUiUsage.generate.json

@@ -85,13 +85,6 @@
       "path": "{apps,libs}/*/lib/*/*.{Template,Unit,View,Zone}.tsx",
       "filterText": "sliceName",
       "sample": 5
-    },
-    {
-      "type": "example",
-      "description": "Internationalization usage examples",
-      "path": "{apps,libs}/*/lib/*/*.{Template,Unit,View}.tsx",
-      "filterText": "l.field",
-      "sample": 3
     }
   ],
   "update": {

package/cjs/src/guidelines/sharedUiUsage/sharedUiUsage.instruction.md

@@ -64,8 +64,8 @@ const MyComponent = () => {
   return (
     <>
       <Field.Text
-        label={l.field("myModel", "title")}
-        desc={l.desc("myModel", "title")}
+        label={l("myModel.title")}
+        desc={l("myModel.title.desc")}
         value={formState.title}
         onChange={(value) => st.do.setTitleOnMyModel(value)}
         nullable={false}
@@ -73,8 +73,8 @@ const MyComponent = () => {
       />
 
       <Field.Number
-        label={l.field("myModel", "amount")}
-        desc={l.desc("myModel", "amount")}
+        label={l("myModel.amount")}
+        desc={l("myModel.amount.desc")}
         value={formState.amount}
         onChange={(value) => st.do.setAmountOnMyModel(value)}
         min={0}
@@ -83,8 +83,8 @@ const MyComponent = () => {
       />
 
       <Field.ToggleSelect
-        label={l.field("myModel", "status")}
-        desc={l.desc("myModel", "status")}
+        label={l("myModel.status")}
+        desc={l("myModel.status.desc")}
         value={formState.status}
         items={cnst.Status}
         onChange={(status) => st.do.setStatusOnMyModel(status)}
@@ -266,7 +266,7 @@ Components automatically integrate with the internationalization system:
 ```tsx
 const { l } = usePage();
 
-<Field.Text label={l.field("user", "name")} desc={l.desc("user", "name")} placeholder={l("user.namePlaceholder")} />;
+<Field.Text label={l("user.name")} desc={l("user.name.desc")} placeholder={l("user.namePlaceholder")} />;
 ```
 
 ### State Management Integration

package/cjs/src/templates/__scalar/__model__/__model__.constant.js

@@ -26,7 +26,6 @@ function getContent(scanInfo, dict) {
   return `
 import { via } from "@akanjs/constant";
 
-
 export class ${dict.Model} extends via((field) => ({
   field: field(String),
 })) {}

package/cjs/src/templates/__scalar/__model__/__model__.dictionary.js

@@ -28,7 +28,7 @@ import { ModelDictionary } from "@akanjs/dictionary";
 
 import type { ${dict.Model} } from "./${dict.model}.constant";
 
-export const modelDictionary = {
+export const dictionary = {
   modelName: ["${dict.Model}", "${dict.Model}"],
   modelDesc: ["${dict.Model}", "${dict.Model}"],
 
@@ -40,7 +40,5 @@ export const modelDictionary = {
   // * ==================== Etc ==================== * //
   // * ==================== Etc ==================== * //
 } satisfies ModelDictionary<${dict.Model}>;
-
-export const ${dict.model}Dictionary = modelDictionary;
 `;
 }

package/cjs/src/templates/app/instrumentation.js

@@ -0,0 +1,32 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// pkgs/@akanjs/cli/src/templates/app/instrumentation.ts
+var instrumentation_exports = {};
+__export(instrumentation_exports, {
+  default: () => getContent
+});
+module.exports = __toCommonJS(instrumentation_exports);
+function getContent(scanInfo, dict) {
+  return `
+import { registerClient } from "./client";
+
+export const register = async () => {
+  await registerClient();
+};`;
+}

package/cjs/src/templates/app/lib/___appName__/__appName__.dictionary.js

@@ -25,12 +25,8 @@ module.exports = __toCommonJS(appName_dictionary_exports);
 function getContent(scanInfo, dict) {
   return `
 import type { SignalDictionary } from "@akanjs/dictionary";
-import type { ${dict.AppName}Signal } from "./${dict.appName}.signal";
+import type { ${dict.AppName}Endpoint } from "./${dict.appName}.signal";
 
-const dictionary = {} as const;
-
-export const signalDictionary = {} satisfies SignalDictionary<${dict.AppName}Signal>;
-
-export const ${dict.appName}Dictionary = { ...dictionary, ...signalDictionary };
+export const dictionary = {} satisfies SignalDictionary<${dict.AppName}Endpoint>;
   `;
 }

package/cjs/src/templates/app/lib/___appName__/__appName__.signal.js

@@ -24,10 +24,12 @@ __export(appName_signal_exports, {
 module.exports = __toCommonJS(appName_signal_exports);
 function getContent(scanInfo, dict) {
   return `
-import { signal } from "@akanjs/signal";
+import { endpoint, internal } from "@akanjs/signal";
 
-import * as cnst from "../cnst";
+import * as srv from "../srv";
 
-export class ${dict.AppName}Signal extends signal("${dict.AppName}" as const, cnst.Srvs) {}
+export class ${dict.AppName}Internal extends internal(srv.${dict.appName}, () => ({})) {}
+
+export class ${dict.AppName}Endpoint extends endpoint(srv.${dict.appName}, () => ({})) {}
   `;
 }

package/cjs/src/templates/app/lib/option.js

@@ -24,7 +24,7 @@ __export(option_exports, {
 module.exports = __toCommonJS(option_exports);
 function getContent(scanInfo, dict = {}) {
   return `
-import { useGlobals } from "@akanjs/server";
+import { Middleware, useGlobals } from "@akanjs/server";
 
 import type { LibOptions } from "./__lib/lib.service";
 
@@ -38,5 +38,10 @@ export const registerGlobalModule = (options: ModulesOptions) => {
     useAsyncs: {},
   });
 };
+
+export const registerGlobalMiddlewares = (options: ModulesOptions) => {
+  return [] as Middleware[];
+};
+
   `;
 }

package/cjs/src/templates/app/main.js

@@ -27,12 +27,12 @@ function getContent(scanInfo, dict) {
 import { createNestApp } from "@akanjs/server";
 
 import { env } from "./env/env.server";
-import { registerModules } from "./server";
+import { registerModules, registerMiddlewares } from "./server";
 
 const bootstrap = async () => {
   const serverMode = process.env.SERVER_MODE as "federation" | "batch" | "all" | null;
   if (!serverMode) throw new Error("SERVER_MODE environment variable is not defined");
-  await createNestApp({ registerModules, serverMode, env });
+  await createNestApp({ registerModules, registerMiddlewares, serverMode, env });
 };
 void bootstrap();
   `;

package/cjs/src/templates/lib/__lib/lib.dictionary.js

@@ -42,8 +42,7 @@ ${libs.map((lib) => `import { dict as ${lib} } from "@${lib}/server";`).join("\n
 
 ${Object.entries(extendedModels).map(([modelName, extendedModels2]) => {
     return `export const ${modelName} = {
-  models: Object.assign({}, ${extendedModels2.map((libName) => `${libName}.${modelName}.modelDictionary`).join(", ")}),
-  signals: Object.assign({}, ${extendedModels2.map((libName) => `${libName}.${modelName}.signalDictionary`).join(", ")}),
+  dictionaries: [${extendedModels2.map((libName) => `${libName}.${modelName}.dictionary`).join(", ")}] as const,
 };`;
   }).join("\n")}
 

package/cjs/src/templates/lib/dict.js

@@ -22,6 +22,7 @@ __export(dict_exports, {
   default: () => getContent
 });
 module.exports = __toCommonJS(dict_exports);
+var capitalize = (str) => str.charAt(0).toUpperCase() + str.slice(1);
 function getContent(scanInfo, dict = {}) {
   if (!scanInfo)
     return null;
@@ -29,7 +30,7 @@ function getContent(scanInfo, dict = {}) {
   const scalarModules = scanInfo.getScalarModules();
   const serviceModules = scanInfo.getServiceModules();
   return `
-import { makeDictionary, makeTrans } from "@akanjs/dictionary";
+import { makeDictionary, makeTrans, registerScalarTrans, registerServiceTrans, registerModelTrans } from "@akanjs/dictionary";
 
 import { allLibs } from "./__lib/lib.dictionary";
 ${databaseModules.map((module2) => `import * as ${module2} from "./${module2}/${module2}.dictionary";`).join("\n")}
@@ -40,14 +41,29 @@ ${databaseModules.map((module2) => `export * as ${module2} from "./${module2}/${
 ${serviceModules.map((module2) => `export * as ${module2} from "./_${module2}/${module2}.dictionary";`).join("\n")}
 ${scalarModules.map((module2) => `export * as ${module2} from "./__scalar/${module2}/${module2}.dictionary";`).join("\n")}
 
+${databaseModules.map((module2) => `import type * as ${module2}Cnst from "./${module2}/${module2}.constant";`).join("\n")}
+${scalarModules.map((module2) => `import type * as ${module2}Cnst from "./__scalar/${module2}/${module2}.constant";`).join("\n")}
+
+${databaseModules.map((module2) => `import type * as ${module2}Doc from "./${module2}/${module2}.document";`).join("\n")}
+
+${databaseModules.map((module2) => `import type * as ${module2}Sig from "./${module2}/${module2}.signal";`).join("\n")}
+${serviceModules.map((module2) => `import type * as ${module2}Sig from "./_${module2}/${module2}.signal";`).join("\n")}
+
 export const dictionary = makeDictionary(...allLibs, {
   ${[
-    ...databaseModules.map((module2) => `${module2}: { ...${module2}.modelDictionary, ...${module2}.signalDictionary }`),
-    ...scalarModules.map((module2) => `${module2}: ${module2}.dictionary`),
-    ...serviceModules.map((module2) => `${module2}: ${module2}.dictionary`)
+    ...databaseModules.map((module2) => {
+      const Module = capitalize(module2);
+      return `${module2}: registerModelTrans<"${module2}", ${module2}Cnst.${Module}, ${module2}Cnst.${Module}Insight, ${module2}Doc.${Module}Filter, ${module2}Sig.${Module}Slice, ${module2}Sig.${Module}Endpoint, typeof ${module2}.dictionary>(${module2}.dictionary)`;
+    }),
+    ...scalarModules.map(
+      (module2) => `${module2}: registerScalarTrans<"${module2}", ${module2}Cnst.${capitalize(module2)}, typeof ${module2}.dictionary>(${module2}.dictionary)`
+    ),
+    ...serviceModules.map(
+      (module2) => `${module2}: registerServiceTrans<"${module2}", ${module2}Sig.${capitalize(module2)}Endpoint, typeof ${module2}.dictionary>(${module2}.dictionary)`
+    )
   ].join(",\n  ")}
-} as const);
+});
  
-export const { Revert, translate, msg } = makeTrans(dictionary);
+export const { Revert, translate, msg, __Dict_Key__, __Error_Key__ } = makeTrans(dictionary);
 `;
 }

package/cjs/src/templates/lib/sig.js

@@ -30,7 +30,7 @@ function getContent(scanInfo, dict = {}) {
   const scalarConstantModules = [...scanInfo.scalar.entries()].filter(([_, files]) => files.has("constant")).map(([module2]) => module2);
   const serviceModules = [...scanInfo.service.entries()].filter(([_, files]) => files.has("signal")).map(([module2]) => module2);
   return `
-import { fetchOf, gqlOf, makeFetch, mergeSignals, signalInfo } from "@akanjs/signal";
+import { fetchOf, gqlOf, makeFetch, mergeSignals, serverSignalOf, signalInfo } from "@akanjs/signal";
 
 import { root, libFetches } from "./__lib/lib.signal";
 import * as cnst from "./cnst";
@@ -46,9 +46,12 @@ ${[...scanInfo.database.entries()].filter(([_, files]) => files.has("signal")).m
     ([module2]) => `export class ${capitalize(module2)}Signal extends mergeSignals(${module2}Sig.${capitalize(module2)}Endpoint, ${module2}Sig.${capitalize(module2)}Internal, ${module2}Sig.${capitalize(module2)}Slice) {}`
   ).join("\n")}
 ${[...scanInfo.service.entries()].filter(([_, files]) => files.has("signal")).map(
-    ([module2]) => `export const ${capitalize(module2)}Signal = mergeSignals(${module2}Sig.${capitalize(module2)}Endpoint, ${module2}Sig.${capitalize(module2)}Internal);`
+    ([module2]) => `export class ${capitalize(module2)}Signal extends mergeSignals(${module2}Sig.${capitalize(module2)}Endpoint, ${module2}Sig.${capitalize(module2)}Internal) {}`
   ).join("\n")}
 
+${[...scanInfo.database.entries()].filter(([_, files]) => files.has("signal")).map(([module2]) => `export class ${capitalize(module2)} extends serverSignalOf(${capitalize(module2)}Signal) {}`).join("\n")}
+${[...scanInfo.service.entries()].filter(([_, files]) => files.has("signal")).map(([module2]) => `export class ${capitalize(module2)} extends serverSignalOf(${capitalize(module2)}Signal) {}`).join("\n")}
+
 const signals = signalInfo.registerSignals(
 ${[...databaseModules, ...serviceModules].map((module2) => `  ${capitalize(module2)}Signal,`).join("\n")}
 );

package/cjs/src/templates/lib/useClient.js

@@ -25,13 +25,14 @@ module.exports = __toCommonJS(useClient_exports);
 function getContent(scanInfo, dict = {}) {
   return `
 import { makePageProto } from "@akanjs/client";
-import type * as signal from "./sig";
-import * as cnst from "./cnst";
 
-import type { dictionary } from "./dict";
+import * as cnst from "./cnst";
+import type { __Dict_Key__, __Error_Key__ } from "./dict";
+import type * as signal from "./sig";
 
 export const { msg, Revert, usePage, sig, fetch, registerClient } = makePageProto<
-  typeof dictionary,
+  typeof __Dict_Key__,
+  typeof __Error_Key__,
   typeof signal.fetch,
   typeof signal
 >(cnst);

package/cjs/src/templates/libRoot/lib/option.js

@@ -24,7 +24,7 @@ __export(option_exports, {
 module.exports = __toCommonJS(option_exports);
 function getContent(scanInfo, dict = {}) {
   return `
-import { useGlobals } from "@akanjs/server";
+import { Middleware, useGlobals } from "@akanjs/server";
 
 import type { LibOptions } from "./__lib/lib.service";
 
@@ -38,5 +38,9 @@ export const registerGlobalModule = (options: ModulesOptions) => {
     useAsyncs: {},
   });
 };
+
+export const registerGlobalMiddlewares = (options: ModulesOptions) => {
+  return [] as Middleware[];
+};
   `;
 }

package/cjs/src/templates/module/__Model__.Template.js

@@ -40,8 +40,8 @@ export const General = ({ className }: ${dict.Model}EditProps) => {
   return (
     <Layout.Template className={className}>
       <Field.Text
-        label={l.field("${dict.model}", "id")}
-        desc={l.desc("${dict.model}", "id")}
+        label={l("${dict.model}.id")}
+        desc={l("${dict.model}.id.desc")}
         value={${dict.model}Form.id}
         onChange={st.do.setIdOn${dict.Model}}
       />

package/cjs/src/templates/module/__Model__.Util.js

@@ -28,12 +28,19 @@ function getContent(scanInfo, dict) {
     content: `
 "use client";
 import { Model } from "@akanjs/ui";
+import { usePage } from "@${dict.sysName}/client";
+import { BiTrash } from "react-icons/bi";
 
 interface RemoveProps {
   ${dict.model}Id: string;
 }
 export const Remove = ({ ${dict.model}Id }: RemoveProps) => {
-  return <Model.Remove modelId={${dict.model}Id} sliceName="${dict.model}" />;
+  const { l } = usePage();
+  return (
+    <Model.Remove modelId={${dict.model}Id} sliceName="${dict.model}">
+      <BiTrash /> {l("base.remove")}
+    </Model.Remove>
+  );
 };
 `
   };

package/cjs/src/templates/module/__model__.constant.js

@@ -24,21 +24,16 @@ __export(model_constant_exports, {
 module.exports = __toCommonJS(model_constant_exports);
 function getContent(scanInfo, dict) {
   return `
-import { enumOf, Int } from "@akanjs/base";
+import { Int } from "@akanjs/base";
 import { via } from "@akanjs/constant";
 
-export const ${dict.Model}Status = enumOf(["active"] as const);
-export type ${dict.Model}Status = enumOf<typeof ${dict.Model}Status>;
-
 export class ${dict.Model}Input extends via((field) => ({
   field: field(String).optional(),
 })) {}
 
-export class ${dict.Model}Object extends via(${dict.Model}Input, (field) => ({
-  status: field(${dict.Model}Status, { default: "active" }),
-})) {}
+export class ${dict.Model}Object extends via(${dict.Model}Input, (field) => ({})) {}
 
-export class Light${dict.Model} extends via(${dict.Model}Object, ["status"] as const, (resolve) => ({})) {}
+export class Light${dict.Model} extends via(${dict.Model}Object, [] as const, (resolve) => ({})) {}
 
 export class ${dict.Model} extends via(${dict.Model}Object, Light${dict.Model}, (resolve) => ({})) {}