@akanjs/cli 0.9.55 → 0.9.57

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

@@ -1,4 +1,5 @@
 // pkgs/@akanjs/cli/src/templates/lib/dict.ts
+var capitalize = (str) => str.charAt(0).toUpperCase() + str.slice(1);
 function getContent(scanInfo, dict = {}) {
   if (!scanInfo)
     return null;
@@ -6,7 +7,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((module) => `import * as ${module} from "./${module}/${module}.dictionary";`).join("\n")}
@@ -17,15 +18,30 @@ ${databaseModules.map((module) => `export * as ${module} from "./${module}/${mod
 ${serviceModules.map((module) => `export * as ${module} from "./_${module}/${module}.dictionary";`).join("\n")}
 ${scalarModules.map((module) => `export * as ${module} from "./__scalar/${module}/${module}.dictionary";`).join("\n")}
 
+${databaseModules.map((module) => `import type * as ${module}Cnst from "./${module}/${module}.constant";`).join("\n")}
+${scalarModules.map((module) => `import type * as ${module}Cnst from "./__scalar/${module}/${module}.constant";`).join("\n")}
+
+${databaseModules.map((module) => `import type * as ${module}Doc from "./${module}/${module}.document";`).join("\n")}
+
+${databaseModules.map((module) => `import type * as ${module}Sig from "./${module}/${module}.signal";`).join("\n")}
+${serviceModules.map((module) => `import type * as ${module}Sig from "./_${module}/${module}.signal";`).join("\n")}
+
 export const dictionary = makeDictionary(...allLibs, {
   ${[
-    ...databaseModules.map((module) => `${module}: { ...${module}.modelDictionary, ...${module}.signalDictionary }`),
-    ...scalarModules.map((module) => `${module}: ${module}.dictionary`),
-    ...serviceModules.map((module) => `${module}: ${module}.dictionary`)
+    ...databaseModules.map((module) => {
+      const Module = capitalize(module);
+      return `${module}: registerModelTrans<"${module}", ${module}Cnst.${Module}, ${module}Cnst.${Module}Insight, ${module}Doc.${Module}Filter, ${module}Sig.${Module}Slice, ${module}Sig.${Module}Endpoint, typeof ${module}.dictionary>(${module}.dictionary)`;
+    }),
+    ...scalarModules.map(
+      (module) => `${module}: registerScalarTrans<"${module}", ${module}Cnst.${capitalize(module)}, typeof ${module}.dictionary>(${module}.dictionary)`
+    ),
+    ...serviceModules.map(
+      (module) => `${module}: registerServiceTrans<"${module}", ${module}Sig.${capitalize(module)}Endpoint, typeof ${module}.dictionary>(${module}.dictionary)`
+    )
   ].join(",\n  ")}
-} as const);
+});
  
-export const { Revert, translate, msg } = makeTrans(dictionary);
+export const { Revert, translate, msg, __Dict_Key__, __Error_Key__ } = makeTrans(dictionary);
 `;
 }
 export {

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

@@ -7,7 +7,7 @@ function getContent(scanInfo, dict = {}) {
   const scalarConstantModules = [...scanInfo.scalar.entries()].filter(([_, files]) => files.has("constant")).map(([module]) => module);
   const serviceModules = [...scanInfo.service.entries()].filter(([_, files]) => files.has("signal")).map(([module]) => module);
   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";
@@ -23,9 +23,12 @@ ${[...scanInfo.database.entries()].filter(([_, files]) => files.has("signal")).m
     ([module]) => `export class ${capitalize(module)}Signal extends mergeSignals(${module}Sig.${capitalize(module)}Endpoint, ${module}Sig.${capitalize(module)}Internal, ${module}Sig.${capitalize(module)}Slice) {}`
   ).join("\n")}
 ${[...scanInfo.service.entries()].filter(([_, files]) => files.has("signal")).map(
-    ([module]) => `export const ${capitalize(module)}Signal = mergeSignals(${module}Sig.${capitalize(module)}Endpoint, ${module}Sig.${capitalize(module)}Internal);`
+    ([module]) => `export class ${capitalize(module)}Signal extends mergeSignals(${module}Sig.${capitalize(module)}Endpoint, ${module}Sig.${capitalize(module)}Internal) {}`
   ).join("\n")}
 
+${[...scanInfo.database.entries()].filter(([_, files]) => files.has("signal")).map(([module]) => `export class ${capitalize(module)} extends serverSignalOf(${capitalize(module)}Signal) {}`).join("\n")}
+${[...scanInfo.service.entries()].filter(([_, files]) => files.has("signal")).map(([module]) => `export class ${capitalize(module)} extends serverSignalOf(${capitalize(module)}Signal) {}`).join("\n")}
+
 const signals = signalInfo.registerSignals(
 ${[...databaseModules, ...serviceModules].map((module) => `  ${capitalize(module)}Signal,`).join("\n")}
 );

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

@@ -2,13 +2,14 @@
 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/esm/src/templates/libRoot/lib/option.js

@@ -1,7 +1,7 @@
 // pkgs/@akanjs/cli/src/templates/libRoot/lib/option.ts
 function getContent(scanInfo, dict = {}) {
   return `
-import { useGlobals } from "@akanjs/server";
+import { Middleware, useGlobals } from "@akanjs/server";
 
 import type { LibOptions } from "./__lib/lib.service";
 
@@ -15,6 +15,10 @@ export const registerGlobalModule = (options: ModulesOptions) => {
     useAsyncs: {},
   });
 };
+
+export const registerGlobalMiddlewares = (options: ModulesOptions) => {
+  return [] as Middleware[];
+};
   `;
 }
 export {

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

@@ -17,8 +17,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/esm/src/templates/module/__Model__.Util.js

@@ -5,12 +5,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/esm/src/templates/module/__model__.constant.js

@@ -1,21 +1,16 @@
 // pkgs/@akanjs/cli/src/templates/module/__model__.constant.ts
 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) => ({})) {}
 

package/esm/src/templates/module/__model__.dictionary.js

@@ -1,67 +1,27 @@
 // pkgs/@akanjs/cli/src/templates/module/__model__.dictionary.ts
 function getContent(scanInfo, dict) {
   return `
-import { baseTrans, getBaseSignalTrans, ModelDictionary, SignalDictionary } from "@akanjs/dictionary";
-
-import type { ${dict.Model}, ${dict.Model}Filter, ${dict.Model}Insight, ${dict.Model}Summary } from "./${dict.model}.constant";
-import type { ${dict.Model}Signal } from "./${dict.model}.signal";
-
-export const modelDictionary = {
-  ...baseTrans,
-  modelName: ["${dict.Model}", "${dict.Model}"],
-  modelDesc: [
-    "${dict.Model} description",
-    "${dict.Model} \uC124\uBA85",
-  ],
-
-  // * ==================== Model ==================== * //
-  field: ["Field", "\uD544\uB4DC"],
-  "desc-field": ["Field", "\uD544\uB4DC"],
-  // * ==================== Model ==================== * //
-
-  // * ==================== Insight ==================== * //
-  count: ["Count", "\uAC1C\uC218"],
-  "desc-count": ["${dict.Model} count in current query settting", "\uD604\uC7AC \uCFFC\uB9AC \uC124\uC815\uC5D0 \uB9DE\uB294 \uBC30\uB108 \uC218"],
-  // * ==================== Insight ==================== * //
-
-  // * ==================== Filter ==================== * //
-  "qry-inStatus": ["In Status", "\uC0C1\uD0DC"],
-  "qrydesc-inStatus": ["Filter by status", "\uC0C1\uD0DC\uBCC4 \uD544\uD130\uB9C1"],
-  "qarg-inStatus-status": ["Status", "\uC0C1\uD0DC"],
-  "qargdesc-inStatus-status": ["Filter by status", "\uC0C1\uD0DC\uBCC4 \uD544\uD130\uB9C1"],
-  // * ==================== Filter ==================== * //
-
-  // * ==================== Etc ==================== * //
-  "enum-status-active": ["Active", "\uD65C\uC131"],
-  "enumdesc-status-active": ["Active status", "\uD65C\uC131 \uC0C1\uD0DC"],
-  // * ==================== Etc ==================== * //
-} satisfies ModelDictionary<${dict.Model}, ${dict.Model}Insight, ${dict.Model}Filter>;
-
-export const signalDictionary = {
-  ...getBaseSignalTrans("${dict.model}" as const),
-  // * ==================== Endpoint ==================== * //
-  "api-${dict.model}ListInPublic": ["${dict.Model} List In Public", "\uACF5\uAC1C\uB41C ${dict.Model} \uB9AC\uC2A4\uD2B8"],
-  "apidesc-${dict.model}ListInPublic": ["Get a list of public ${dict.model}", "\uACF5\uAC1C\uB41C ${dict.Model}\uC758 \uB9AC\uC2A4\uD2B8\uB97C \uAC00\uC838\uC635\uB2C8\uB2E4"],
-  "arg-${dict.model}ListInPublic-statuses": ["Statuses", "\uC0C1\uD0DC"],
-  "argdesc-${dict.model}ListInPublic-statuses": ["Statuses to filter", "\uD544\uD130\uB9C1\uD560 \uC0C1\uD0DC"],
-  "arg-${dict.model}ListInPublic-skip": ["Skip", "\uAC74\uB108\uB6F0\uAE30"],
-  "argdesc-${dict.model}ListInPublic-skip": ["Number of items to skip", "\uAC74\uB108\uB6F8 \uC544\uC774\uD15C \uC218"],
-  "arg-${dict.model}ListInPublic-limit": ["Limit", "\uC81C\uD55C"],
-  "argdesc-${dict.model}ListInPublic-limit": ["Maximum number of items to return", "\uBC18\uD658\uD560 \uCD5C\uB300 \uC544\uC774\uD15C \uC218"],
-  "arg-${dict.model}ListInPublic-sort": ["Sort", "\uC815\uB82C"],
-  "argdesc-${dict.model}ListInPublic-sort": ["Sort order of the items", "\uC544\uC774\uD15C\uC758 \uC815\uB82C \uC21C\uC11C"],
-
-  "api-${dict.model}InsightInPublic": ["${dict.Model} Insight In Public", "\uACF5\uAC1C\uB41C ${dict.Model} \uC778\uC0AC\uC774\uD2B8"],
-  "apidesc-${dict.model}InsightInPublic": [
-    "Get insight data for public ${dict.model}",
-    "\uACF5\uAC1C\uB41C ${dict.Model}\uC5D0 \uB300\uD55C \uC778\uC0AC\uC774\uD2B8 \uB370\uC774\uD130\uB97C \uAC00\uC838\uC635\uB2C8\uB2E4",
-  ],
-  "arg-${dict.model}InsightInPublic-statuses": ["Statuses", "\uC0C1\uD0DC"],
-  "argdesc-${dict.model}InsightInPublic-statuses": ["Statuses to filter", "\uD544\uD130\uB9C1\uD560 \uC0C1\uD0DC"],
-  // * ==================== Endpoint ==================== * //
-} satisfies SignalDictionary<${dict.Model}Signal, ${dict.Model}>;
-
-export const ${dict.model}Dictionary = { ...modelDictionary, ...signalDictionary };
+import { modelDictionary } from "@akanjs/dictionary";
+
+import type { ${dict.Model}, ${dict.Model}Insight } from "./${dict.model}.constant";
+import type { ${dict.Model}Filter } from "./${dict.model}.document";
+import type { ${dict.Model}Endpoint, ${dict.Model}Slice } from "./${dict.model}.signal";
+
+export const dictionary = modelDictionary(["en", "ko"])
+  .of((t) =>
+    t(["${dict.Model}", "${dict.Model}"]).desc(["${dict.Model} description", "${dict.Model} \uC124\uBA85"])
+  )
+  .model<${dict.Model}>((t) => ({
+    field: t(["Field", "\uD544\uB4DC"]).desc(["Field description", "\uD544\uB4DC \uC124\uBA85"]),
+  }))
+  .insight<${dict.Model}Insight>((t) => ({}))
+  .query<${dict.Model}Filter>((fn) => ({}))
+  .slice<${dict.Model}Slice>((fn) => ({
+    inPublic: fn(["${dict.Model} In Public", "${dict.Model} \uACF5\uAC1C"]).arg((t) => ({})),
+  }))
+  .endpoint<${dict.Model}Endpoint>((fn) => ({}))
+  .error({})
+  .translate({});
 `;
 }
 export {

package/esm/src/templates/module/__model__.document.js

@@ -1,13 +1,18 @@
 // pkgs/@akanjs/cli/src/templates/module/__model__.document.ts
 function getContent(scanInfo, dict) {
   return `
-import { beyond, by, into, type SchemaOf } from "@akanjs/document";
+import { beyond, by, from, into, type SchemaOf } from "@akanjs/document";
 
 import * as cnst from "../cnst";
 
+export class ${dict.Model}Filter extends from(cnst.${dict.Model}, (filter) => ({
+  query: {},
+  sort: {},
+})) {}
+
 export class ${dict.Model} extends by(cnst.${dict.Model}) {}
 
-export class ${dict.Model}Model extends into(${dict.Model}, cnst.${dict.model}) {}
+export class ${dict.Model}Model extends into(${dict.Model}, ${dict.Model}Filter, cnst.${dict.model}) {}
 
 export class ${dict.Model}Middleware extends beyond(${dict.Model}Model, ${dict.Model}) {
   onSchema(schema: SchemaOf<${dict.Model}Model, ${dict.Model}>) {

package/esm/src/templates/module/__model__.signal.js

@@ -1,37 +1,23 @@
 // pkgs/@akanjs/cli/src/templates/module/__model__.signal.ts
 function getContent(scanInfo, dict) {
   return `
-import { Int } from "@akanjs/base";
-import type { SortOf } from "@akanjs/document";
-import { Arg, signal, Mutation, Query, resolve } from "@akanjs/signal";
+import { Public } from "@akanjs/nest";
+import { endpoint, internal, slice } from "@akanjs/signal";
+import { Admin } from "@shared/nest";
 
 import * as cnst from "../cnst";
+import * as srv from "../srv";
 
-export class ${dict.Model}Signal extends signal(cnst.${dict.model}, cnst.Srvs, {
-  guards: { get: "Public", cru: "Public },
-}) {
-  // * /////////////////////////////////////
-  // * Public Slice
-  @Query.Public(() => [cnst.${dict.Model}])
-  async ${dict.model}ListInPublic(
-    @Arg.Query("statuses", () => [String], { nullable: true }) statuses: cnst.${dict.Model}Status[] | null,
-    @Arg.Query("skip", () => Int, { nullable: true }) skip: number | null,
-    @Arg.Query("limit", () => Int, { nullable: true }) limit: number | null,
-    @Arg.Query("sort", () => String, { nullable: true }) sort: SortOf<cnst.${dict.Model}Filter> | null
-  ) {
-    const ${dict.models} = await this.${dict.model}Service.listByStatuses(statuses, { skip, limit, sort });
-    return resolve<cnst.${dict.Model}[]>(${dict.models});
-  }
-  @Query.Public(() => cnst.${dict.Model}Insight)
-  async ${dict.model}InsightInPublic(
-    @Arg.Query("statuses", () => [String], { nullable: true }) statuses: cnst.${dict.Model}Status[] | null
-  ) {
-    const ${dict.model}Insight = await this.${dict.model}Service.insightByStatuses(statuses);
-    return resolve<cnst.${dict.Model}Insight>(${dict.model}Insight);
-  }
-  // * Public Slice
-  // * /////////////////////////////////////
-}
+export class ${dict.Model}Internal extends internal(srv.${dict.model}, () => ({})) {}
+
+export class ${dict.Model}Slice extends slice(srv.${dict.model}, { guards: { root: Admin, get: Public, cru: Public } }, (init) => ({
+  inPublic: init()
+    .exec(function () {
+      return this.${dict.model}Service.queryAny();
+    }),
+})) {}
+
+export class ${dict.Model}Endpoint extends endpoint(srv.${dict.model}, () => ({})) {}
 `;
 }
 export {

package/esm/src/templates/module/__model__.store.js

@@ -3,8 +3,7 @@ function getContent(scanInfo, dict) {
   return `
 import { store } from "@akanjs/store";
 
-import * as cnst from "../cnst";
-import { fetch, sig } from "../useClient";
+import { sig } from "../useClient";
 
 export class ${dict.Model}Store extends store(sig.${dict.model}, {
   // state

package/esm/src/templates/server.js

@@ -8,15 +8,15 @@ function getContent(scanInfo, dict = {}) {
   const serviceModules = [...scanInfo.service.entries()].filter(([_, files]) => files.has("service"));
   const scalarModules = [...scanInfo.scalar.entries()];
   return `
-import { databaseModuleOf, scalarModulesOf, serviceModuleOf, type Module } from "@akanjs/server";
-${libs.map((lib) => `import { registerModules as register${capitalize(lib)}Modules } from "@${lib}/server";`).join("\n")}
+import { databaseModuleOf, scalarModulesOf, serviceModuleOf, type Module, type Middleware } from "@akanjs/server";
+${libs.map((lib) => `import { registerModules as register${capitalize(lib)}Modules, registerMiddlewares as register${capitalize(lib)}Middlewares } from "@${lib}/server";`).join("\n")}
   
 import * as cnst from "./lib/cnst";
 import * as db from "./lib/db";
 import * as srv from "./lib/srv";
 import { allSrvs } from "./lib/srv";
 import * as sig from "./lib/sig";
-import { type ModulesOptions, registerGlobalModule } from "./lib/option";
+import { type ModulesOptions, registerGlobalModule, registerGlobalMiddlewares } from "./lib/option";
 
 // database modules
 ${databaseModules.map(([model]) => {
@@ -44,6 +44,14 @@ ${databaseModules.map(([model]) => `    register${capitalize(model)}Module(),`).
   return modules;
 };
 
+export const registerMiddlewares = (options: ModulesOptions, isChild?: boolean) => {
+  const middlewares = [
+${libs.map((lib) => `    ...(!isChild ? register${capitalize(lib)}Middlewares(options, true) : []),`).join("\n")}
+    ...registerGlobalMiddlewares(options),
+  ] as Middleware[];
+  return middlewares;
+};
+
 export { env } from "./env/env.server.testing";
 export * as db from "./lib/db";
 export * as srv from "./lib/srv";

package/esm/src/templates/workspaceRoot/.gitignore.template

@@ -11,10 +11,12 @@ apps/*/data
 /releases
 apps/*/scripts
 **/.env
+**/env.client.local.ts
 **/env.client.debug.ts
 **/env.client.develop.ts
 **/env.client.main.ts
 **/env.client.testing.ts
+**/env.server.local.ts
 **/env.server.debug.ts
 **/env.server.develop.ts
 **/env.server.main.ts

package/package.json

@@ -2,7 +2,7 @@
   "type": "module",
   "sourceType": "module",
   "name": "@akanjs/cli",
-  "version": "0.9.55",
+  "version": "0.9.57",
   "bin": {
     "akan": "esm/index.js"
   },

package/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/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/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/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/src/module/module.command.d.ts

@@ -3,7 +3,7 @@ import { ModuleScript } from "./module.script";
 export declare class ModuleCommand {
     moduleScript: ModuleScript;
     createModule(moduleName: string, sys: Sys, page: boolean): Promise<void>;
-    removeModule(module: Module): void;
+    removeModule(module: Module): Promise<void>;
     createView(module: Module): Promise<void>;
     createUnit(module: Module): Promise<void>;
     createTemplate(module: Module): Promise<void>;

package/src/module/module.runner.d.ts

@@ -1,7 +1,7 @@
 import { type Module, Workspace } from "@akanjs/devkit";
 export declare class ModuleRunner {
     createModule(workspace: Workspace, sysType: "app" | "lib", sysName: string, moduleName: string, description: string): Promise<void>;
-    removeModule(module: Module): void;
+    removeModule(module: Module): Promise<void>;
     createComponentTemplate(module: Module, type: "unit" | "view" | "template" | "zone" | "util"): Promise<{
         component: {
             filename: string;

package/src/module/module.script.d.ts

@@ -8,7 +8,7 @@ export declare class ModuleScript {
     }): Promise<void>;
     createModule(sys: Sys, name: string, description?: string, schemaDescription?: string): Promise<void>;
     createModule_(sys: Sys, name: string, description: string, schemaDescription: string): Promise<void>;
-    removeModule(mod: Module): void;
+    removeModule(mod: Module): Promise<void>;
     createService(workspace: Workspace, name: string): Promise<void>;
     createTest(workspace: Workspace, name: string): Promise<void>;
     createTemplate(mod: Module): Promise<void>;

package/src/scalar/scalar.command.d.ts

@@ -3,5 +3,5 @@ import { ScalarScript } from "./scalar.script";
 export declare class ScalarCommand {
     scalarScript: ScalarScript;
     createScalar(sys: Sys, scalarName: string): Promise<void>;
-    removeScalar(sys: Sys, scalarName: string): void;
+    removeScalar(sys: Sys, scalarName: string): Promise<void>;
 }

package/src/scalar/scalar.script.d.ts

@@ -2,5 +2,5 @@ import { type Sys } from "@akanjs/devkit";
 export declare class ScalarScript {
     #private;
     createScalar(sys: Sys, scalarName: string): Promise<void>;
-    removeScalar(sys: Sys, scalarName: string): void;
+    removeScalar(sys: Sys, scalarName: string): Promise<void>;
 }

package/src/templates/app/instrumentation.d.ts

@@ -0,0 +1,6 @@
+import type { AppInfo, LibInfo } from "@akanjs/devkit";
+interface Dict {
+    appName: string;
+}
+export default function getContent(scanInfo: AppInfo | LibInfo | null, dict: Dict): string;
+export {};