@akanjs/cli 0.9.60-canary.8 → 1.0.0

package/src/guidelines/scalarConstant/scalarConstant.instruction.md

@@ -17,330 +17,328 @@ Scalar constants in Akan.js serve as the foundation for complex data modeling by
 ```
 {app,lib}/
 └── */lib/__scalar/
-    └── <scalarName>/               // camelCase directory
-        └── <scalarName>.constant.ts  // scalar definition file
+    └── <scalarName>/                 # camelCase directory
+        └── <scalarName>.constant.ts  # scalar definition file
 ```
 
 ### Naming Standards
 
-- **Directory**: `camelCase` (e.g., `geoLocation`)
+- **Directory**: `camelCase` (e.g., `encourageInfo`, `geoLocation`)
 - **File**: `<scalarName>.constant.ts` (matches directory name)
-- **Class**: `PascalCase` matching directory name (e.g., `GeoLocation`)
-- **Model Reference**: Matches class name in `@Model.Scalar()` decorator
-- **Enum Values**: `camelCase` (e.g., `active`, `pendingApproval`)
-
-### File Structure
-
-```typescript
-// 1. Core imports
-import { Float, Int, String, Boolean, Date, type Dayjs, dayjs, enumOf } from "@akanjs/base";
-import { Field, Model } from "@akanjs/constant";
-
-// 2. Optional enum definitions (camelCase values)
-export const Status = enumOf(["active", "inactive"] as const);
-export type Status = enumOf<typeof Status>;
-
-// 3. Scalar model class (SINGLE CLASS PER FILE)
-// Must match class name
-export class ScalarName {
-  // Field definitions
-  @Field.Prop(() => FieldType, { ...options })
-  fieldName: FieldType;
-}
-```
+- **Scalar Class**: `PascalCase` (e.g., `EncourageInfo`, `GeoLocation`)
+- **Enum Class**: `PascalCase` (e.g., `Journey`, `NotiSetting`)
+- **Enum Values**: `camelCase` (e.g., `firstJoin`, `waitPay`)
 
 ## Required Imports
 
 ### Essential Framework Imports
 
 ```typescript
-import { Field, Model } from "@akanjs/constant";
+import { via } from "@akanjs/constant";
 ```
 
 ### Common Base Types
 
 ```typescript
-import { ID, Int, Float, String, Boolean, Date, type Dayjs, dayjs, enumOf, JSON, Map } from "@akanjs/base";
+import { ID, Int, Float, dayjs, enumOf } from "@akanjs/base";
 ```
 
 ### Cross-Scalar References
 
 ```typescript
-import { OtherScalar } from "../other-scalar/other-scalar.constant";
+import { OtherScalar } from "../otherScalar/otherScalar.constant";
 ```
 
-## Model Definition
+## Basic Syntax with via()
+
+The `via()` function is the foundation for defining scalars. It takes a callback that receives the `field()` function, which you use to define each field's type and options.
 
 ### Basic Structure
 
 ```typescript
-// String must match class name
-export class ScalarName {
-  // Field definitions go here
+import { via } from "@akanjs/constant";
+
+export class ScalarName extends via((field) => ({
+  fieldName: field(FieldType),
+  fieldWithOptions: field(FieldType, { ...options }),
+})) {
+  // Optional: Add instance methods here
 }
 ```
 
-### Key Rules
-
-- **One scalar model per file** - Create separate files for different scalars
-- **Class name matches directory name** in PascalCase (e.g., `PaymentInfo` for `payment-info`)
-- **Model names should be domain-specific** and descriptive
-- **No ID/timestamp fields** - Scalars are value objects, not entities
-- **`@Model.Scalar` decorator parameter must match class name** - This is critical for proper metadata registration
-
-## Field Definitions
-
-### Basic Field Types
+### Simple Example
 
 ```typescript
-@Field.Prop(() => String)
-name: string;
+import { via } from "@akanjs/constant";
 
-@Field.Prop(() => Int)
-quantity: number;
+export class RestrictInfo extends via((field) => ({
+  until: field(Date),
+  reason: field(String),
+})) {}
+```
 
-@Field.Prop(() => Float)
-percentage: number;
+### Key Patterns
 
-@Field.Prop(() => Boolean)
-isActive: boolean;
+| Pattern                    | Description                                                                      |
+| -------------------------- | -------------------------------------------------------------------------------- |
+| `via((field) => ({...}))`  | Creates a class with typed fields. The callback receives the `field()` helper.   |
+| `field(Type)`              | Defines a single field. First argument is the type (String, Number, Date, etc.). |
+| `field(Type, { options })` | Optional second argument is an options object for defaults, validation, etc.     |
 
-@Field.Prop(() => Date)
-timestamp: Dayjs;  // Always use Dayjs for dates
-```
+## Available Field Types
 
-### Field Options Reference
-
-| Option      | Type     | Description                          | Example                      |
-| ----------- | -------- | ------------------------------------ | ---------------------------- |
-| `default`   | Any      | Default field value                  | `{ default: 0 }`             |
-| `nullable`  | Boolean  | Allows null values                   | `{ nullable: true }`         |
-| `enum`      | Enum     | Restricts to enum values             | `{ enum: Status }`           |
-| `min`       | Number   | Minimum numeric value                | `{ min: 0 }`                 |
-| `max`       | Number   | Maximum numeric value                | `{ max: 100 }`               |
-| `minlength` | Number   | Minimum string length                | `{ minlength: 3 }`           |
-| `maxlength` | Number   | Maximum string length                | `{ maxlength: 255 }`         |
-| `example`   | Any      | Example value for documentation      | `{ example: [0,0] }`         |
-| `validate`  | Function | Custom validation function           | `{ validate: (v) => v > 0 }` |
-| `immutable` | Boolean  | Prevents modification after creation | `{ immutable: true }`        |
-| `select`    | Boolean  | Includes in query results by default | `{ select: false }`          |
-| `text`      | String   | Enables text search capabilities     | `{ text: "search" }`         |
-
-### Special Field Types
+### Primitive Types
 
 ```typescript
-// Hidden field (not exposed in GraphQL)
-@Field.Hidden(() => String)
-internalCode: string;
-
-// Secret field (not selected by default)
-@Field.Secret(() => String)
-apiKey: string;
-
-// Resolve field (computed at runtime)
-@Field.Resolve(() => Int)
-get total(): number {
-  return this.items.length;
-}
-```
+import { ID, Int, Float } from "@akanjs/base";
+import { via } from "@akanjs/constant";
 
-## Array Fields
+export class Example extends via((field) => ({
+  // String type
+  name: field(String),
 
-### Simple Arrays
+  // Number types
+  count: field(Int), // Integer
+  price: field(Float), // Floating point
 
-```typescript
-// String array
-@Field.Prop(() => [String])
-tags: string[];
+  // Boolean type
+  isActive: field(Boolean),
 
-// Number array with default
-@Field.Prop(() => [Int], { default: [1, 2, 3] })
-values: number[];
+  // Date type (internally uses Dayjs)
+  createdAt: field(Date),
+
+  // ID type (MongoDB ObjectId)
+  referenceId: field(ID),
+})) {}
 ```
 
-### Nested Arrays
+### Array Types
+
+Array types are defined by wrapping the type in square brackets:
 
 ```typescript
-// 2D number array
-@Field.Prop(() => [[Int]])
-matrix: number[][];
+export class Example extends via((field) => ({
+  // Array of strings
+  tags: field([String]),
 
-// 3D coordinate array
-@Field.Prop(() => [[[Float]]])
-coordinates: number[][][];
-```
+  // Array of numbers
+  scores: field([Int]),
 
-### Array of Scalars
+  // Array of other scalars
+  items: field([OtherScalar]),
 
-```typescript
-@Field.Prop(() => [OtherScalar])
-items: OtherScalar[];
+  // Nested arrays (2D matrix)
+  matrix: field([[Int]]),
+})) {}
 ```
 
-## Map Fields
+### Optional Fields
 
-```typescript
-@Field.Prop(() => Map, {
-  of: String,  // Must specify value type
-  default: new Map()
-})
-metadata: Map<string, string>;
-```
-
-## Enum Implementation (camelCase Values)
+Optional fields can be defined using the `.optional()` chain:
 
 ```typescript
-// Define enum with camelCase values (export REQUIRED)
-export const Status = enumOf(["active", "inactive", "pendingApproval"] as const);
-export type Status = enumOf<typeof Status>;  // Type export
-
-// Use in field
-@Field.Prop(() => String, {
-  enum: Status,
-  default: "active"
-})
-status: Status;
+import { ID, Int } from "@akanjs/base";
+import { via } from "@akanjs/constant";
+
+export class FileMeta extends via((field) => ({
+  fileId: field(ID).optional(), // Optional field
+  lastModifiedAt: field(Date),
+  size: field(Int),
+})) {}
 ```
 
-## Static Methods
+## Field Options Reference
 
-Scalar classes can include static methods for common operations on the scalar type:
+| Option      | Type     | Default     | Description                                      | Example                       |
+| ----------- | -------- | ----------- | ------------------------------------------------ | ----------------------------- |
+| `default`   | Any/Func | `undefined` | Default field value (static or factory function) | `{ default: 0 }`              |
+| `min`       | Number   | -           | Minimum numeric value                            | `{ min: 0 }`                  |
+| `max`       | Number   | -           | Maximum numeric value                            | `{ max: 100 }`                |
+| `minlength` | Number   | -           | Minimum string length                            | `{ minlength: 3 }`            |
+| `maxlength` | Number   | -           | Maximum string length                            | `{ maxlength: 255 }`          |
+| `validate`  | Function | -           | Custom validation function                       | `{ validate: isPhoneNumber }` |
+| `example`   | Any      | -           | Example value for documentation                  | `{ example: [0, 0] }`         |
+
+### Field Options Examples
 
 ```typescript
-export class Coordinate {
-  @Field.Prop(() => [Float], { default: [0, 0] })
-  coordinates: number[];
+import { dayjs, Int, Float } from "@akanjs/base";
+import { isPhoneNumber } from "@akanjs/common";
+import { via } from "@akanjs/constant";
 
-  // Static utility methods
-  static getDistanceKm(loc1: Coordinate, loc2: Coordinate) {
-    const [lon1, lat1] = loc1.coordinates;
-    const [lon2, lat2] = loc2.coordinates;
-    // Distance calculation logic
-    return distance;
-  }
-}
-```
+export class OrderInfo extends via((field) => ({
+  // Static default value
+  quantity: field(Int, { default: 1 }),
 
-## Validation Rules and Checklist
+  // Dynamic default using factory function
+  orderedAt: field(Date, { default: () => dayjs() }),
 
-### File-Level Validation
+  // Number range validation
+  rating: field(Float, { min: 0, max: 5 }),
 
-- [ ] Location: `__scalar/<camelCase>/<camelCase>.constant.ts`
-- [ ] Single `@Model.Scalar` class per file
-- [ ] Class name matches directory name (PascalCase)
-- [ ] All required imports present
-- [ ] The string passed to `@Model.Scalar()` must match the class name exactly
+  // String length validation
+  description: field(String, { minlength: 10, maxlength: 500 }),
 
-### Field-Level Validation
+  // Custom validation function
+  phone: field(String, { validate: isPhoneNumber }),
 
-- [ ] All fields have `@Field.Prop` decorator (or `@Field.Hidden`, `@Field.Secret`, `@Field.Resolve`)
-- [ ] Type references use arrow functions: `() => Type`
-- [ ] Array types use bracket notation: `[Type]`
-- [ ] Nullable fields use TypeScript union: `Type | null`
-- [ ] Default values match field types
-- [ ] Enums are properly defined with camelCase values and exported
-- [ ] Custom validation functions are pure and side-effect free
-- [ ] Dayjs type is used for date fields
+  // Combined options
+  price: field(Float, {
+    default: 0,
+    min: 0,
+    example: 29.99,
+  }),
+})) {}
+```
 
-### Best Practices
+### Static vs Dynamic Defaults
 
-- **Focused models**: Each scalar should represent a single concept
-- **Descriptive names**: Use clear, domain-relevant terminology
-- **Enum Values**: Always use camelCase (`active`, not `ACTIVE`)
-- **Reusability**: Create separate scalars for commonly used structures
-- **Documentation**: Add comments for complex fields
-- **Validation**: Use min/max for numbers, minlength/maxlength for text
-- **Immutability**: Mark fields as `immutable` where appropriate
-- **Default values**: Provide sensible defaults for most fields
+- Use **static values** for constants: `{ default: 0 }`, `{ default: "active" }`
+- Use **factory functions** for values computed at creation time: `{ default: () => dayjs() }`, `{ default: () => new ObjectId() }`
 
-## Common Mistakes and Fixes
+## Enum Definition with enumOf()
+
+The `enumOf()` function creates typed enum classes. Define enums before using them in your scalar fields.
 
-### Incorrect Enum Case
+### Basic Enum
 
 ```typescript
-// ❌ Wrong (uppercase values)
-export const Status = enumOf(["ACTIVE", "INACTIVE"] as const);
+import { enumOf } from "@akanjs/base";
+import { via } from "@akanjs/constant";
+
+// Simple enum definition
+export class NotiSetting extends enumOf("notiSetting", ["disagree", "fewer", "normal", "block"]) {}
 
-// ✅ Correct (camelCase values)
-export const Status = enumOf(["active", "inactive"] as const);
+// Using enum in a scalar
+export class NotiInfo extends via((field) => ({
+  setting: field(NotiSetting, { default: "normal" }),
+})) {}
 ```
 
-### Incorrect Array Syntax
+### Enum with 'as const'
+
+For better TypeScript type inference, use `as const`:
 
 ```typescript
-// ❌ Wrong
-@Field.Prop(() => Array<Int>)
-values: number[];
+import { dayjs, enumOf } from "@akanjs/base";
+import { via } from "@akanjs/constant";
+
+// Use "as const" for better type inference
+export class Status extends enumOf("status", ["pending", "active", "completed", "cancelled"] as const) {}
 
-// ✅ Correct
-@Field.Prop(() => [Int])
-values: number[];
+export class Order extends via((field) => ({
+  status: field(Status, { default: "pending" }),
+  orderedAt: field(Date, { default: () => dayjs() }),
+})) {}
 ```
 
-### Missing Nullable Type Declaration
+### Enum Key Points
 
-```typescript
-// ❌ Wrong (type mismatch)
-@Field.Prop(() => String, { nullable: true })
-description: string;
+| Point                  | Description                                                                              |
+| ---------------------- | ---------------------------------------------------------------------------------------- |
+| `enumOf(name, values)` | First argument is the enum name (used in dictionary/GraphQL). Second is the value array. |
+| camelCase Values       | Always use camelCase for enum values (e.g., `"waitPay"`, not `"WAIT_PAY"`).              |
+| `as const`             | Add `as const` to the values array for better TypeScript type inference.                 |
 
-// ✅ Correct
-@Field.Prop(() => String, { nullable: true })
-description: string | null;
-```
+## Instance Methods
 
-### Improper Enum Implementation
+You can add instance methods directly to the scalar class for computed properties and utility functions:
 
 ```typescript
-// ❌ Wrong (missing export/type)
-const Status = enumOf(["active"] as const);
-
-// ✅ Correct
-export const Status = enumOf(["active"] as const);
-export type Status = enumOf<typeof Status>;
+import { Int } from "@akanjs/base";
+import { via } from "@akanjs/constant";
+
+export class Stock extends via((field) => ({
+  total: field(Int, { default: 0, min: 0 }),
+  current: field(Int, { default: 0, min: 0 }),
+})) {
+  getPercentage() {
+    if (this.total === 0) return 0;
+    return (this.current / this.total) * 100;
+  }
+}
 ```
 
-### Multiple Models in One File
+### Method Guidelines
+
+- Instance methods have access to all fields via `this`
+- Use them for calculations based on field values
+- Methods defined in `constant.ts` are available on both server and client
+- For server-only logic, use `document.ts` instead
+
+## Static Methods
+
+Scalar classes can include static methods for common operations:
 
 ```typescript
-// ❌ Wrong (violates single-responsibility)
- class Address { ... }
- class User { ... }
+import { enumOf, Float } from "@akanjs/base";
+import { via } from "@akanjs/constant";
 
-// ✅ Correct (separate files)
-// address.constant.ts
-export class Address { ... }
+export class CoordinateType extends enumOf("coordinateType", ["Point"] as const) {}
+
+export class Coordinate extends via((field) => ({
+  type: field(CoordinateType, { default: "Point" }),
+  coordinates: field([Float], { default: [0, 0], example: [127.114367, 37.497114] }),
+  altitude: field(Float, { default: 0 }),
+})) {
+  static getDistanceKm(loc1: Coordinate, loc2: Coordinate) {
+    const [lon1, lat1] = loc1.coordinates;
+    const [lon2, lat2] = loc2.coordinates;
+    const R = 6371; // Earth's radius in kilometers
+    // Distance calculation logic...
+    return distance;
+  }
 
-// user.constant.ts
-import { Address } from "../address/address.constant";
-export class User { ... }
+  static moveMeters(loc: Coordinate, x: number, y: number): Coordinate {
+    // Calculate new position...
+    return { ...loc, coordinates: [newLon, newLat] };
+  }
+}
 ```
 
-### Incorrect Date Handling
+## Common Mistakes and Fixes
 
-```typescript
-// ❌ Wrong (uses native Date)
-@Field.Prop(() => Date)
-createdAt: Date;
+| Issue           | Wrong ❌                           | Correct ✅                                |
+| --------------- | ---------------------------------- | ----------------------------------------- |
+| Enum case       | `enumOf("status", ["ACTIVE"])`     | `enumOf("status", ["active"])`            |
+| Array syntax    | `field(Array<Int>)`                | `field([Int])`                            |
+| Dynamic default | `{ default: dayjs() }`             | `{ default: () => dayjs() }`              |
+| Missing export  | `class Status extends enumOf(...)` | `export class Status extends enumOf(...)` |
+| Optional field  | `field(ID, { nullable: true })`    | `field(ID).optional()`                    |
+
+### Important Note
 
-// ✅ Correct (uses Dayjs)
-import { type Dayjs } from "@akanjs/base";
+For Date defaults that should be computed at creation time, **always use a factory function**:
 
-@Field.Prop(() => Date)
-createdAt: Dayjs;
+```typescript
+// ❌ Wrong - creates a single fixed date at module load
+{ default: dayjs() }
+
+// ✅ Correct - creates a new date each time
+{ default: () => dayjs() }
 ```
 
-### Missing Model.Scalar Parameter
+## Implementation Checklist
 
-```typescript
-// ❌ Wrong (missing or mismatched parameter)
-@Model.Scalar()
-export class GeoLocation { ... }
+### File-Level
 
-// ✅ Correct
+- [ ] File location: `__scalar/<camelCase>/<camelCase>.constant.ts`
+- [ ] Import `via` from `@akanjs/constant`
+- [ ] Import `enumOf` from `@akanjs/base` (if using enums)
+- [ ] Export all classes (scalar and enums)
 
-export class GeoLocation { ... }
-```
+### Naming
+
+- [ ] Use PascalCase for class names
+- [ ] Use camelCase for enum values
+- [ ] Class name matches directory name in PascalCase
+
+### Field Definition
+
+- [ ] Use `[Type]` syntax for arrays
+- [ ] Use factory functions for dynamic defaults
+- [ ] Use `.optional()` for nullable fields
+- [ ] Add `as const` for large enum value arrays
 
 ## Full Examples
 
@@ -349,136 +347,96 @@ export class GeoLocation { ... }
 ```typescript
 // libs/payment/lib/__scalar/amount/amount.constant.ts
 import { Float } from "@akanjs/base";
-import { Field, Model } from "@akanjs/constant";
-
-export class Amount {
-  @Field.Prop(() => Float, { min: 0, default: 0 })
-  value: number;
+import { via } from "@akanjs/constant";
 
-  @Field.Prop(() => String, { default: "USD" })
-  currency: string;
-}
+export class Amount extends via((field) => ({
+  value: field(Float, { min: 0, default: 0 }),
+  currency: field(String, { default: "USD" }),
+})) {}
 ```
 
-### Complex Scalar Example (with camelCase enums)
+### Scalar with Enum
 
 ```typescript
-// apps/maps/lib/__scalar/geoLocation/geoLocation.constant.ts
-import { Float, type Dayjs, dayjs, enumOf } from "@akanjs/base";
-import { Field, Model } from "@akanjs/constant";
-
-// CORRECT: camelCase enum values
-export const AccuracyLevel = enumOf(["low", "medium", "high"] as const);
-export type AccuracyLevel = enumOf<typeof AccuracyLevel>;
-
-export class GeoLocation {
-  @Field.Prop(() => Float, {
-    min: -90,
-    max: 90,
-    example: 37.7749,
-  })
-  latitude: number;
-
-  @Field.Prop(() => Float, {
-    min: -180,
-    max: 180,
-    example: -122.4194,
-  })
-  longitude: number;
-
-  @Field.Prop(() => Float, {
-    nullable: true,
-    min: 0,
-    example: 12.5,
-  })
-  elevation: number | null;
-
-  @Field.Prop(() => String, {
-    enum: AccuracyLevel,
-    default: "medium",
-  })
-  accuracy: AccuracyLevel;
-
-  @Field.Prop(() => Date, {
-    default: () => dayjs(),
-    immutable: true,
-  })
-  measuredAt: Dayjs;
-}
+// apps/akasys/lib/__scalar/version/version.constant.ts
+import { dayjs, enumOf } from "@akanjs/base";
+import { via } from "@akanjs/constant";
+
+export class VersionStatus extends enumOf("versionStatus", ["active", "expired"] as const) {}
+
+export class Version extends via((field) => ({
+  source: field(File).optional(),
+  appBuild: field(File).optional(),
+  build: field(File).optional(),
+  status: field(VersionStatus, { default: "active" }),
+  at: field(Date, { default: () => dayjs() }),
+})) {}
 ```
 
-### Scalar with Nested Objects
+### Scalar with Optional Fields
 
 ```typescript
-// apps/ecommerce/lib/__scalar/product-spec/product-spec.constant.ts
-import { Int, Float } from "@akanjs/base";
-import { Field, Model } from "@akanjs/constant";
-import { Dimension } from "../dimension/dimension.constant";
-
-export class ProductSpec {
-  @Field.Prop(() => String)
-  sku: string;
-
-  @Field.Prop(() => [String], {
-    default: [],
-    example: ["red", "blue"],
-  })
-  colors: string[];
-
-  @Field.Prop(() => Dimension)
-  size: Dimension;
-
-  @Field.Prop(() => Float, { min: 0 })
-  weight: number;
-
-  @Field.Prop(() => Int, {
-    min: 0,
-    default: 0,
-  })
-  stock: number;
-}
+// apps/angelo/lib/__scalar/estimate/estimate.constant.ts
+import { Float, Int } from "@akanjs/base";
+import { via } from "@akanjs/constant";
+
+export class Estimate extends via((field) => ({
+  name: field(String),
+  value: field(Float, { min: 0, default: 0 }),
+  num: field(Int, { min: 1, default: 1 }),
+  unit: field(String).optional(),
+  note: field(String).optional(),
+})) {}
 ```
 
-### Scalar with Static Methods
+### Complex Scalar with Static Methods
 
 ```typescript
 // libs/util/lib/__scalar/coordinate/coordinate.constant.ts
-import { Float } from "@akanjs/base";
-import { Field, Model } from "@akanjs/constant";
+import { enumOf, Float } from "@akanjs/base";
+import { via } from "@akanjs/constant";
 
-export class Coordinate {
-  @Field.Prop(() => [Float], { default: [0, 0], example: [127.114367, 37.497114] })
-  coordinates: number[];
-
-  @Field.Prop(() => Float, { default: 0 })
-  altitude: number;
+export class CoordinateType extends enumOf("coordinateType", ["Point"] as const) {}
 
+export class Coordinate extends via((field) => ({
+  type: field(CoordinateType, { default: "Point" }),
+  coordinates: field([Float], { default: [0, 0], example: [127.114367, 37.497114] }),
+  altitude: field(Float, { default: 0 }),
+})) {
   static getDistanceKm(loc1: Coordinate, loc2: Coordinate) {
     const [lon1, lat1] = loc1.coordinates;
     const [lon2, lat2] = loc2.coordinates;
-    // Distance calculation logic...
+    const R = 6371;
+    // ... calculation logic
     return distance;
   }
 
-  static moveMeters(loc: Coordinate, x: number, y: number): Coordinate {
-    // Calculate new position...
-    return { ...loc, coordinates: [newLon, newLat] };
+  static moveMeters(loc: Coordinate, x: number, y: number, z: number = 0): Coordinate {
+    const [lon, lat] = loc.coordinates;
+    const dx = ((x / 1000 / 6371) * (180 / Math.PI)) / Math.cos(lat * (Math.PI / 180));
+    const dy = (y / 1000 / 6371) * (180 / Math.PI);
+    return { ...loc, coordinates: [lon + dx, lat + dy], altitude: loc.altitude + z };
   }
 }
 ```
 
-## Summary Checklist
+## Pro Tips
+
+- **Keep scalars focused**: If it grows too large, split it into multiple scalars
+- **Value objects only**: Avoid adding ID or timestamp fields (use Models for that)
+- **Define enums first**: Define enums before the scalar class that uses them
+- **Dictionary support**: Don't forget to create `dictionary.ts` for i18n support
+- **Reusability**: Create separate scalars for commonly used structures
+
+## Summary
 
 1. **Location**: `__scalar/<camelCase>/<camelCase>.constant.ts`
-2. **Structure**: Single `@Model.Scalar` class per file
-3. **Naming**: Class name = PascalCase directory name
-4. **Decorator**: `` with exact class name match
-5. **Enum Values**: Always camelCase (`active`, not `ACTIVE`)
-6. **Fields**: Use `@Field.Prop` with arrow function types
-7. **Arrays**: Wrap in `[]` (e.g., `[Int]`)
-8. **Enums**: Export with `enumOf` and derived type
-9. **Dates**: Always use `Dayjs` type with `Date` decorator
-10. **Nullability**: Use `| null` with `{ nullable: true }`
-11. **Validation**: Implement field-level constraints
+2. **Import**: `via` from `@akanjs/constant`, `enumOf` from `@akanjs/base`
+3. **Scalar Class**: `export class Name extends via((field) => ({...})) {}`
+4. **Enum Class**: `export class EnumName extends enumOf("enumName", [...] as const) {}`
+5. **Fields**: `field(Type)` or `field(Type, { options })`
+6. **Optional**: Use `.optional()` chain method
+7. **Arrays**: Use `[Type]` syntax
+8. **Enum Values**: Always camelCase
 
 Following these patterns ensures type-safe, maintainable scalar definitions that integrate seamlessly with the Akan.js framework's data modeling layer.