@akanjs/cli 0.9.60-canary.8 → 1.0.0

package/esm/src/guidelines/scalarDictionary/scalarDictionary.generate.json

@@ -2,6 +2,11 @@
   "title": "Scalar Dictionary",
   "description": "How to create and maintain scalar.dictionary.ts files in Akan.js",
   "scans": [
+    {
+      "type": "source",
+      "description": "scalarDictionary builder function implementation",
+      "path": "pkgs/@akanjs/dictionary/src/scalarDictionary.ts"
+    },
     {
       "type": "source",
       "description": "Translation types and interfaces",
@@ -9,7 +14,7 @@
     },
     {
       "type": "source",
-      "description": "ModelDictionary type definition",
+      "description": "Dictionary exports and types",
       "path": "pkgs/@akanjs/dictionary/src/index.ts"
     },
     {
@@ -23,16 +28,9 @@
       "type": "example",
       "description": "Scalar dictionaries with enum translations",
       "path": "{apps,libs}/**/lib/__scalar/*/*.dictionary.ts",
-      "query": "/enum-.*:/",
+      "query": "/\\.enum</",
       "sample": 3
     },
-    {
-      "type": "example",
-      "description": "Scalar dictionaries with section separators",
-      "path": "{apps,libs}/**/lib/__scalar/*/*.dictionary.ts",
-      "query": "/={10,}/",
-      "sample": 2
-    },
     {
       "type": "example",
       "description": "Complete scalar dictionary with field and enum translations",
@@ -42,9 +40,9 @@
     },
     {
       "type": "example",
-      "description": "Best practice examples with organized structure",
+      "description": "Scalar dictionaries with multiple enums",
       "path": "{apps,libs}/**/lib/__scalar/*/*.dictionary.ts",
-      "query": "/\\*\\s+=+\\s+Model\\s+=+\\s+\\*/",
+      "query": "/\\.enum<.*\\.enum</",
       "sample": 2
     }
   ],
@@ -52,31 +50,33 @@
     "filePath": "./scalarDictionary.instruction.md",
     "contents": [
       "Purpose of scalar dictionary files",
-      "Structure and naming conventions",
-      "Required model metadata translations",
-      "Field translation patterns",
-      "Enum translation patterns",
-      "Custom translation patterns",
-      "Section organization with comment separators",
-      "Type safety with satisfies ModelDictionary",
-      "Validation rules and checklist",
+      "File structure and naming conventions",
+      "Required imports from @akanjs/dictionary",
+      "scalarDictionary() builder pattern",
+      "Builder methods: .of(), .model<T>(), .enum<T>()",
+      "Translation format with t() function and .desc() method",
+      "Type imports from constant file using import type",
+      "Enum name matching with enumOf() name",
+      "Type safety through generic parameters",
       "Common mistakes and fixes",
-      "Best practices for organization",
-      "Full example with all translation types"
+      "Best practices for translations",
+      "Implementation checklist",
+      "Full examples with multiple enums"
     ],
     "rules": [
-      "Do not remove or change comment separator lines using asterisks and equals signs (e.g., /* ==================== Model ==================== */)",
-      "Always add field descriptions immediately after the field translations using the desc- prefix",
-      "Always add enum descriptions immediately after enum translations using the enumdesc- prefix",
+      "Import scalarDictionary from '@akanjs/dictionary'",
+      "Import types from constant file using 'import type' syntax",
+      "Initialize with language order array: scalarDictionary(['en', 'ko'])",
+      "Use .of() method to define scalar name and description",
+      "Use .model<Type>() method with generic to define field translations",
+      "Use .enum<Type>('enumName', ...) method to define enum translations",
+      "The enum name string in .enum() must exactly match the first argument of enumOf() in constant file",
+      "Always chain .desc() after t() to provide descriptions: t([...]).desc([...])",
       "Use exactly two string elements in translation arrays: [English, Korean]",
-      "Always include modelName and modelDesc as the first translations in the file",
-      "Keep field translations grouped together, followed by enum translations",
-      "Scalar dictionaries should only contain model field and enum translations, not query filters or API arguments",
-      "Use the satisfies ModelDictionary<YourType> syntax to ensure type safety",
-      "Always use camelCase for field names, exactly matching the constant file",
-      "Follow the exact format enum-fieldName-enumValue for enum translations",
-      "Group translations by sections with comment separators for better readability",
-      "Use proper naming: myScalarDictionary for the exported constant (matching the model name)"
+      "Export as 'dictionary': export const dictionary = scalarDictionary(...)...",
+      "Use type generics (.model<Type>, .enum<Type>) for TypeScript validation",
+      "Provide meaningful descriptions that explain purpose, not just repeat labels",
+      "Match language order consistently across all dictionaries in the project"
     ]
   },
   "page": "/[lang]/akanjs/(docs)/docs/scalar/dictionary/page.tsx"

package/esm/src/guidelines/scalarDictionary/scalarDictionary.instruction.md

@@ -4,7 +4,7 @@
 
 Scalar dictionary files in Akan.js provide internationalization (i18n) support by:
 
-- Defining translations for model names, fields, and enum values
+- Defining translations for scalar names, fields, and enum values
 - Supporting multiple languages (primarily English and Korean)
 - Enabling consistent terminology across the application
 - Providing field descriptions for documentation and tooltips
@@ -18,330 +18,256 @@ Scalar dictionary files in Akan.js provide internationalization (i18n) support b
 ```
 {app,lib}/
 └── */lib/__scalar/
-    └── <scalarName>/               // camelCase directory
-        ├── <scalarName>.constant.ts  // model definition
-        └── <scalarName>.dictionary.ts // translations
+    └── <scalarName>/                  # camelCase directory
+        ├── <scalarName>.constant.ts   # scalar definition
+        └── <scalarName>.dictionary.ts # translations
 ```
 
-### Basic Structure
+### Key Benefits
 
-```typescript
-import { ModelDictionary } from "@akanjs/dictionary";
-import type { YourModel } from "./your-model.constant";
-
-const modelDictionary = {
-  // Required model metadata
-  modelName: ["Model Name", "모델 이름"],
-  modelDesc: ["Model description", "모델 설명"],
-
-  // Field translations with descriptions
-  fieldName: ["Field Label", "필드 라벨"],
-  "desc-fieldName": ["Field description", "필드 설명"],
-
-  // Enum translations with descriptions
-  "enum-status-active": ["Active", "활성"],
-  "enumdesc-status-active": ["Active status", "활성 상태"],
-} satisfies ModelDictionary<YourModel>;
-
-export const yourModelDictionary = modelDictionary;
-```
+- End-to-end type safety
+- Fluent builder pattern
+- Automatic validation via generics
+- Multi-language support
 
 ## Required Imports
 
 ```typescript
-import { ModelDictionary } from "@akanjs/dictionary";
-import type { YourModel } from "./your-model.constant";
-```
-
-## Translation Patterns
+import { scalarDictionary } from "@akanjs/dictionary";
 
-### 1. Model Metadata (Required)
-
-Every scalar dictionary must include these two translations at the beginning:
-
-```typescript
-modelName: ["User", "사용자"],         // Short display name
-modelDesc: ["User account", "사용자 계정"], // Longer description
+// Import types using "import type" for cleaner code
+import type { YourScalar, YourEnum } from "./yourScalar.constant";
 ```
 
-### 2. Field Translations
+## Scalar Dictionary Builder
 
-Each field from the constant file must have both a label and description:
+The `scalarDictionary()` function creates a type-safe dictionary using a fluent builder pattern.
 
-```typescript
-// Field label
-username: ["Username", "사용자명"],
+### Builder Methods
 
-// Field description (must follow immediately after the field)
-"desc-username": ["User's login name", "로그인에 사용하는 이름"],
-```
+| Method                       | Description                      | Example                                                                    |
+| ---------------------------- | -------------------------------- | -------------------------------------------------------------------------- |
+| `.of((t) => ...)`            | Define scalar name & description | `.of((t) => t(["Scalar Name", "스칼라 이름"]).desc(["Desc", "설명"]))`     |
+| `.model<T>((t) => ...)`      | Define field translations        | `.model<YourScalar>((t) => ({ fieldName: t(["Label", "레이블"]) }))`       |
+| `.enum<T>(name, (t) => ...)` | Define enum value translations   | `.enum<YourEnum>("enumName", (t) => ({ value1: t(["Label", "레이블"]) }))` |
 
-### 3. Enum Value Translations
+## Translation Format
 
-Each enum value must have both a label and description:
+Each translation uses the `t()` function with an array of values. The array order matches the language order defined in `scalarDictionary()`.
 
 ```typescript
-// Enum value label
-"enum-status-active": ["Active", "활성"],
+// Language order: ["en", "ko"]
+// Index 0 = English, Index 1 = Korean
 
-// Enum value description (must follow immediately)
-"enumdesc-status-active": ["Account is active", "계정이 활성화됨"],
+t(["English Label", "한국어 레이블"]).desc(["English description", "한국어 설명"]);
 ```
 
-### 4. Custom Translations (Optional)
-
-Additional translations specific to this model but not tied to fields:
+### Translation Methods
 
-```typescript
-userProfileTitle: ["User Profile", "사용자 프로필"],
-```
+| Method         | Purpose                | Example                                  |
+| -------------- | ---------------------- | ---------------------------------------- |
+| `t([...])`     | Define the label/name  | `t(["Status", "상태"])`                  |
+| `.desc([...])` | Define the description | `.desc(["Current status", "현재 상태"])` |
 
-## Section Organization
+> **Note**: Both label and description are required for complete internationalization support.
 
-Use comment separators to organize your translations:
+## Basic Structure
 
 ```typescript
-// * ==================== Model ==================== * //
-username: ["Username", "사용자명"],
-"desc-username": ["User's login name", "로그인에 사용하는 이름"],
-// * ==================== Model ==================== * //
-
-// * ==================== Enums ==================== * //
-"enum-status-active": ["Active", "활성"],
-"enumdesc-status-active": ["Account is active", "계정이 활성화됨"],
-// * ==================== Enums ==================== * //
-
-// * ==================== Custom ==================== * //
-userProfileTitle: ["User Profile", "사용자 프로필"],
-// * ==================== Custom ==================== * //
+import { scalarDictionary } from "@akanjs/dictionary";
+import type { YourScalar, YourEnum } from "./yourScalar.constant";
+
+export const dictionary = scalarDictionary(["en", "ko"])
+  .of((t) => t(["Scalar Name", "스칼라 이름"]).desc(["Scalar description", "스칼라 설명"]))
+  .model<YourScalar>((t) => ({
+    fieldName: t(["Field Label", "필드 레이블"]).desc(["Field description", "필드 설명"]),
+  }))
+  .enum<YourEnum>("enumName", (t) => ({
+    value1: t(["Value Label", "값 레이블"]).desc(["Value description", "값 설명"]),
+  }));
 ```
 
-## Type Safety
-
-Always use the `satisfies` operator with `ModelDictionary<YourModel>` to ensure:
-
-1. All required fields from the model are translated
-2. Field names match exactly
-3. Typescript will catch typos and missing fields
+## Complete Example
 
 ```typescript
-} satisfies ModelDictionary<YourModel>; // Type safety check
+// File: libs/payment/lib/__scalar/price/price.dictionary.ts
+import { scalarDictionary } from "@akanjs/dictionary";
+import type { Currency, Price } from "./price.constant";
+
+export const dictionary = scalarDictionary(["en", "ko"])
+  .of((t) => t(["Price", "가격"]).desc(["Price information", "가격 정보"]))
+  .model<Price>((t) => ({
+    amount: t(["Amount", "금액"]).desc(["Price amount", "가격 금액"]),
+    currency: t(["Currency", "통화"]).desc(["Currency type", "통화 유형"]),
+  }))
+  .enum<Currency>("currency", (t) => ({
+    usd: t(["USD", "달러"]).desc(["US Dollar", "미국 달러"]),
+    krw: t(["KRW", "원"]).desc(["Korean Won", "한국 원"]),
+    eur: t(["EUR", "유로"]).desc(["Euro", "유로"]),
+  }));
 ```
 
-## Validation Rules and Checklist
-
-### Required Elements
-
-- [ ] Import `ModelDictionary` from `@akanjs/dictionary`
-- [ ] Import the model type from the constant file
-- [ ] Include `modelName` and `modelDesc` translations
-- [ ] Translate all fields from the model
-- [ ] Add descriptions for all fields with `desc-` prefix
-- [ ] Translate all enum values with `enum-field-value` pattern
-- [ ] Add descriptions for all enum values with `enumdesc-` prefix
-- [ ] Use `satisfies ModelDictionary<YourModel>` for type checking
-- [ ] Export with the correct naming convention
-
-### Translation Arrays
-
-- [ ] Each translation is a tuple with exactly two elements
-- [ ] First element is English translation
-- [ ] Second element is Korean translation
-- [ ] No trailing punctuation in translations
-- [ ] First letter capitalized in English
-
-### Organization
+## Enum Name Matching
 
-- [ ] Group fields with their descriptions
-- [ ] Group enum values with their descriptions
-- [ ] Use standard comment separators
-- [ ] Place model metadata first, then fields, then enums
+The first argument to `.enum()` must match the name used in `enumOf()` from the constant file. This ensures proper type checking and runtime resolution.
 
-## Common Mistakes and Fixes
+### Example
 
-### 1. Missing Field Description
+**constant.ts**:
 
 ```typescript
-// ❌ Wrong (missing description)
-username: ["Username", "사용자명"],
-
-// ✅ Correct
-username: ["Username", "사용자명"],
-"desc-username": ["User's login name", "로그인에 사용하는 이름"],
+export class Currency extends enumOf("currency", ["usd", "krw", "eur"]) {}
 ```
 
-### 2. Incorrect Enum Naming Pattern
+**dictionary.ts**:
 
 ```typescript
-// ❌ Wrong (incorrect format)
-"enum_status_active": ["Active", "활성"],
-// or
-"enumStatus-active": ["Active", "활성"],
-
-// ✅ Correct
-"enum-status-active": ["Active", "활성"],
-"enumdesc-status-active": ["Account is active", "계정이 활성화됨"],
+// Must match: "currency"
+.enum<Currency>("currency", (t) => ({
+  usd: t(["USD", "달러"]).desc(["US Dollar", "미국 달러"]),
+  krw: t(["KRW", "원"]).desc(["Korean Won", "한국 원"]),
+  eur: t(["EUR", "유로"]).desc(["Euro", "유로"]),
+}))
 ```
 
-### 3. Missing Model Metadata
-
-```typescript
-// ❌ Wrong (missing required metadata)
-const modelDictionary = {
-  username: ["Username", "사용자명"],
-  // ...
+> **Important**: The enum name string must exactly match the first argument of `enumOf()`. For example, `enumOf("journey", [...])` requires `.enum<Journey>("journey", ...)`.
 
-// ✅ Correct
-const modelDictionary = {
-  modelName: ["User", "사용자"],
-  modelDesc: ["User account", "사용자 계정"],
-  username: ["Username", "사용자명"],
-  // ...
-```
+## Type Imports
 
-### 4. Incorrect Translation Array Format
+Always import types from the constant file to ensure type safety. The generic parameters enforce that all fields and enum values have translations.
 
 ```typescript
-// ❌ Wrong (single string, not a tuple)
-username: "Username",
-// or
-username: ["Username"],
-
-// ✅ Correct
-username: ["Username", "사용자명"],
+import { scalarDictionary } from "@akanjs/dictionary";
+
+// Import types using "import type" for cleaner code
+import type { EncourageInfo, Inquiry, Journey } from "./encourageInfo.constant";
+
+export const dictionary = scalarDictionary(["en", "ko"])
+  .of((t) => t(["Encourage Info", "격려 정보"]).desc(["Encouragement information", "격려 정보"]))
+  .model<EncourageInfo>((t) => ({
+    // TypeScript ensures all fields of EncourageInfo are defined
+  }))
+  .enum<Journey>("journey", (t) => ({
+    // TypeScript ensures all values of Journey enum are defined
+  }))
+  .enum<Inquiry>("inquiry", (t) => ({
+    // TypeScript ensures all values of Inquiry enum are defined
+  }));
 ```
 
-### 5. Missing Type Safety
+### Type Safety Benefits
 
-```typescript
-// ❌ Wrong (no type checking)
-export const userDictionary = modelDictionary;
+- **`import type`**: Use `import type` for type-only imports. This ensures no runtime code is included.
+- **`.model<Type>`**: Provides autocomplete for field names and validates that all fields are translated.
+- **`.enum<Type>`**: Provides autocomplete for enum values and validates that all values are translated.
 
-// ✅ Correct
-const modelDictionary = {
-  // ...
-} satisfies ModelDictionary<User>;
+## Common Mistakes and Fixes
 
-export const userDictionary = modelDictionary;
-```
+| Issue             | Wrong ❌                         | Correct ✅                                      |
+| ----------------- | -------------------------------- | ----------------------------------------------- |
+| Missing .desc()   | `t(["Label", "레이블"])`         | `t(["Label", "레이블"]).desc(["Desc", "설명"])` |
+| Wrong enum name   | `.enum<Journey>("Journey", ...)` | `.enum<Journey>("journey", ...)`                |
+| Missing export    | `const dictionary = ...`         | `export const dictionary = ...`                 |
+| Wrong array order | `t(["한국어", "English"])`       | `t(["English", "한국어"])`                      |
+| Missing field     | (TypeScript error)               | All fields defined                              |
 
 ## Best Practices
 
-### 1. Order Translations Logically
+### 1. Always Use Type Generics
 
-```typescript
-// First: model metadata
-modelName: ["User", "사용자"],
-modelDesc: ["User account", "사용자 계정"],
+Use `.model<Type>` and `.enum<Type>` to ensure TypeScript validates all fields and values are translated.
 
-// Second: fields with descriptions
-username: ["Username", "사용자명"],
-"desc-username": ["User's login name", "로그인에 사용하는 이름"],
+### 2. Consistent Language Order
 
-// Third: enum values with descriptions
-"enum-status-active": ["Active", "활성"],
-"enumdesc-status-active": ["Account is active", "계정이 활성화됨"],
+Always use the same language order (e.g., `["en", "ko"]`) across all dictionaries in your project.
 
-// Last: custom translations
-profileHeading: ["Profile Details", "프로필 상세정보"],
-```
+### 3. Meaningful Descriptions
 
-### 2. Use Clear Comment Separators
+Provide helpful descriptions that explain the field's purpose, not just repeat the label.
 
 ```typescript
-// * ==================== Model ==================== * //
-// Fields go here
-// * ==================== Model ==================== * //
-
-// * ==================== Enums ==================== * //
-// Enum translations go here
-// * ==================== Enums ==================== * //
+// ❌ Bad - description just repeats the label
+amount: t(["Amount", "금액"]).desc(["Amount", "금액"]),
 
-// * ==================== Custom ==================== * //
-// Custom translations go here
-// * ==================== Custom ==================== * //
+// ✅ Good - description explains the purpose
+amount: t(["Amount", "금액"]).desc(["Price amount in selected currency", "선택된 통화의 가격 금액"]),
 ```
 
-### 3. Match Constant File Structure
-
-Follow the same field order as in the constant file for easier maintenance.
-
-### 4. Naming Conventions
+### 4. Export as 'dictionary'
 
-- Export name should match model name: `userDictionary` for `User` model
-- Field names must exactly match the constant file
-- Use kebab-case for prefix separators: `desc-`, `enum-`, `enumdesc-`
-
-### 5. Consistent Translation Style
-
-- First letter capitalized for English
-- No trailing punctuation
-- Keep translations concise but clear
-- Be consistent in terminology
-
-## Full Example
+Use the standard export name `dictionary` for consistency with the framework's auto-import system.
 
 ```typescript
-// File: apps/example/lib/__scalar/user/user.dictionary.ts
-import { ModelDictionary } from "@akanjs/dictionary";
-import type { User } from "./user.constant";
-
-const modelDictionary = {
-  modelName: ["User", "사용자"],
-  modelDesc: ["System user account", "시스템 사용자 계정"],
-
-  // * ==================== Model ==================== * //
-  username: ["Username", "사용자명"],
-  "desc-username": ["Unique login identifier", "고유 로그인 식별자"],
-
-  email: ["Email", "이메일"],
-  "desc-email": ["Contact email address", "연락용 이메일 주소"],
+// ✅ Correct
+export const dictionary = scalarDictionary(["en", "ko"])...
+```
 
-  displayName: ["Display Name", "표시 이름"],
-  "desc-displayName": ["Public name shown to others", "다른 사용자에게 표시되는 이름"],
+## Implementation Checklist
 
-  status: ["Status", "상태"],
-  "desc-status": ["Account status", "계정 상태"],
+### Required Elements
 
-  lastLoginAt: ["Last Login", "마지막 로그인"],
-  "desc-lastLoginAt": ["Most recent login time", "가장 최근 로그인 시간"],
-  // * ==================== Model ==================== * //
+- [ ] File location: `__scalar/<name>/<name>.dictionary.ts`
+- [ ] Import `scalarDictionary` from `@akanjs/dictionary`
+- [ ] Import types from constant file using `import type`
+- [ ] Initialize with correct language order: `["en", "ko"]`
+- [ ] Define scalar name/description with `.of()`
+- [ ] Define all field translations with `.model<Type>()`
+- [ ] Define all enum translations with `.enum<Type>(name)`
+- [ ] Ensure enum name matches `enumOf()` name
+- [ ] Include both label and description for all entries
+- [ ] Export as `dictionary`
 
-  // * ==================== Enums ==================== * //
-  "enum-status-active": ["Active", "활성"],
-  "enumdesc-status-active": ["Account is enabled and usable", "계정이 활성화되어 사용 가능함"],
+### Translation Format
 
-  "enum-status-inactive": ["Inactive", "비활성"],
-  "enumdesc-status-inactive": ["Account is temporarily disabled", "계정이 일시적으로 비활성화됨"],
+- [ ] Each translation uses `t([...]).desc([...])`
+- [ ] First element is English translation
+- [ ] Second element is Korean translation
+- [ ] No trailing punctuation in translations
+- [ ] First letter capitalized in English
 
-  "enum-status-banned": ["Banned", "차단됨"],
-  "enumdesc-status-banned": ["Account is permanently disabled", "계정이 영구적으로 비활성화됨"],
+## Full Example with Multiple Enums
 
-  "enum-status-pending": ["Pending", "대기 중"],
-  "enumdesc-status-pending": ["Account awaiting verification", "계정 인증 대기 중"],
-  // * ==================== Enums ==================== * //
+```typescript
+// File: apps/example/lib/__scalar/encourageInfo/encourageInfo.dictionary.ts
+import { scalarDictionary } from "@akanjs/dictionary";
+import type { EncourageInfo, Inquiry, Journey } from "./encourageInfo.constant";
+
+export const dictionary = scalarDictionary(["en", "ko"])
+  .of((t) => t(["Encourage Info", "격려 정보"]).desc(["User encouragement settings", "사용자 격려 설정"]))
+  .model<EncourageInfo>((t) => ({
+    journey: t(["Journey", "여정"]).desc(["User journey stage", "사용자 여정 단계"]),
+    inquiry: t(["Inquiry", "문의"]).desc(["Inquiry type", "문의 유형"]),
+    message: t(["Message", "메시지"]).desc(["Encouragement message", "격려 메시지"]),
+    showAt: t(["Show At", "표시 시간"]).desc(["When to show encouragement", "격려 표시 시점"]),
+  }))
+  .enum<Journey>("journey", (t) => ({
+    firstJoin: t(["First Join", "첫 가입"]).desc(["User just joined", "사용자가 방금 가입함"]),
+    waitPay: t(["Waiting Payment", "결제 대기"]).desc(["Awaiting payment", "결제 대기 중"]),
+    onProgress: t(["In Progress", "진행 중"]).desc(["Currently active", "현재 진행 중"]),
+    completed: t(["Completed", "완료됨"]).desc(["Journey completed", "여정 완료"]),
+  }))
+  .enum<Inquiry>("inquiry", (t) => ({
+    general: t(["General", "일반"]).desc(["General inquiry", "일반 문의"]),
+    support: t(["Support", "지원"]).desc(["Technical support", "기술 지원"]),
+    billing: t(["Billing", "청구"]).desc(["Billing inquiry", "청구 문의"]),
+  }));
+```
 
-  // * ==================== Custom ==================== * //
-  profileHeading: ["User Profile", "사용자 프로필"],
-  accountSettings: ["Account Settings", "계정 설정"],
-  loginHistory: ["Login History", "로그인 기록"],
-  // * ==================== Custom ==================== * //
-} satisfies ModelDictionary<User>;
+## Pro Tips
 
-export const userDictionary = modelDictionary;
-```
+- **TypeScript Errors**: TypeScript will show errors if you miss any fields or enum values - use this to your advantage!
+- **Usage**: The dictionary is used for UI labels, form validation messages, and API documentation
+- **Descriptions**: Keep descriptions concise but informative - they appear in tooltips and help text
+- **Consistency**: Match the field order in dictionary with the constant file for easier maintenance
 
-## Summary Checklist
+## Summary
 
-1. **Imports**: Import `ModelDictionary` and model type
-2. **Metadata**: Include `modelName` and `modelDesc`
-3. **Fields**: Translate all model fields with descriptions
-4. **Enums**: Translate all enum values with descriptions
-5. **Format**: Use proper prefix patterns (`desc-`, `enum-`, `enumdesc-`)
-6. **Arrays**: Use two-element arrays for all translations
-7. **Organization**: Group related translations with comment separators
-8. **Type Safety**: Use `satisfies ModelDictionary<YourModel>`
-9. **Export**: Name the export to match the model name
-10. **Completeness**: Ensure all fields and enums from the constant file are translated
+1. **Import**: `scalarDictionary` from `@akanjs/dictionary`, types from constant file
+2. **Initialize**: `scalarDictionary(["en", "ko"])`
+3. **Scalar Info**: `.of((t) => t([...]).desc([...]))`
+4. **Fields**: `.model<Type>((t) => ({ field: t([...]).desc([...]) }))`
+5. **Enums**: `.enum<Type>("enumName", (t) => ({ value: t([...]).desc([...]) }))`
+6. **Export**: `export const dictionary = ...`
+7. **Format**: `t(["English", "Korean"]).desc(["English desc", "Korean desc"])`
 
-Following these guidelines will ensure your scalar dictionary files are complete, consistent, and maintainable across the Akan.js framework.
+Following these guidelines ensures your scalar dictionary files are complete, type-safe, and maintainable across the Akan.js framework.