@praxisjs/decorators 1.2.0 → 1.3.0

package/dist/create-getter-decorator.js

@@ -5,6 +5,23 @@ export function createGetterDecorator(behavior) {
         };
     };
 }
+export function createWritableGetterDecorator(behavior) {
+    return function (target, context) {
+        context.addInitializer(function () {
+            const instance = this;
+            const binding = behavior.bind(instance, context.name, target);
+            const descriptor = {
+                get: binding.get,
+                configurable: true,
+                enumerable: false,
+            };
+            if (binding.set !== undefined)
+                descriptor.set = binding.set;
+            Object.defineProperty(instance, context.name, descriptor);
+        });
+        return target;
+    };
+}
 export function createGetterObserverDecorator(behavior) {
     return function (target, context) {
         context.addInitializer(function () {

package/dist/create-getter-decorator.js.map

@@ -1 +1 @@
-{"version":3,"file":"create-getter-decorator.js","sourceRoot":"","sources":["../src/create-getter-decorator.ts"],"names":[],"mappings":"AAWA,MAAM,UAAU,qBAAqB,CAAC,QAAwB;IAC5D,OAAO,UACL,MAAyB,EACzB,QAA8C;QAE9C,OAAO;YACL,OAAO,QAAQ,CAAC,IAAI,CAClB,MAAmC,EACnC,IAAc,CACf,EAAO,CAAC;QACX,CAAC,CAAC;IACJ,CAAC,CAAC;AACJ,CAAC;AAeD,MAAM,UAAU,6BAA6B,CAAC,QAAgC;IAC5E,OAAO,UACL,MAAyB,EACzB,OAA6C;QAE7C,OAAO,CAAC,cAAc,CAAC;YACrB,QAAQ,CAAC,OAAO,CACd,MAAmC,EACnC,IAAc,EACd,OAAO,CAAC,IAAc,CACvB,CAAC;QACJ,CAAC,CAAC,CAAC;IACL,CAAC,CAAC;AACJ,CAAC"}
+{"version":3,"file":"create-getter-decorator.js","sourceRoot":"","sources":["../src/create-getter-decorator.ts"],"names":[],"mappings":"AAWA,MAAM,UAAU,qBAAqB,CAAC,QAAwB;IAC5D,OAAO,UACL,MAAyB,EACzB,QAA8C;QAE9C,OAAO;YACL,OAAO,QAAQ,CAAC,IAAI,CAClB,MAAmC,EACnC,IAAc,CACf,EAAO,CAAC;QACX,CAAC,CAAC;IACJ,CAAC,CAAC;AACJ,CAAC;AAqBD,MAAM,UAAU,6BAA6B,CAAC,QAAgC;IAC5E,OAAO,UACL,MAAyB,EACzB,OAA6C;QAE7C,OAAO,CAAC,cAAc,CAAC;YACrB,MAAM,QAAQ,GAAG,IAAc,CAAC;YAChC,MAAM,OAAO,GAAG,QAAQ,CAAC,IAAI,CAAC,QAAQ,EAAE,OAAO,CAAC,IAAI,EAAE,MAAmC,CAAC,CAAC;YAC3F,MAAM,UAAU,GAAuB;gBACrC,GAAG,EAAE,OAAO,CAAC,GAAG;gBAChB,YAAY,EAAE,IAAI;gBAClB,UAAU,EAAE,KAAK;aAClB,CAAC;YACF,IAAI,OAAO,CAAC,GAAG,KAAK,SAAS;gBAAE,UAAU,CAAC,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC;YAC5D,MAAM,CAAC,cAAc,CAAC,QAAQ,EAAE,OAAO,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;QAC5D,CAAC,CAAC,CAAC;QACH,OAAO,MAAM,CAAC;IAChB,CAAC,CAAC;AACJ,CAAC;AAeD,MAAM,UAAU,6BAA6B,CAAC,QAAgC;IAC5E,OAAO,UACL,MAAyB,EACzB,OAA6C;QAE7C,OAAO,CAAC,cAAc,CAAC;YACrB,QAAQ,CAAC,OAAO,CACd,MAAmC,EACnC,IAAc,EACd,OAAO,CAAC,IAAc,CACvB,CAAC;QACJ,CAAC,CAAC,CAAC;IACL,CAAC,CAAC;AACJ,CAAC"}

package/dist/index.d.ts

@@ -7,5 +7,6 @@ export { type ReactiveHost } from "./reactive-host";
 export { createClassDecorator, ClassBehavior, type ClassEnhancement, } from "./create-class-decorator";
 export { createMethodDecorator, type MethodBehavior, } from "./create-method-decorator";
 export { createLifecycleMethodDecorator, type LifecycleMethodBehavior, } from "./create-lifecycle-method-decorator";
-export { createGetterDecorator, type GetterBehavior, createGetterObserverDecorator, type GetterObserverBehavior, } from "./create-getter-decorator";
+export { createGetterDecorator, type GetterBehavior, createWritableGetterDecorator, type WritableGetterBehavior, type WritableGetterBinding, createGetterObserverDecorator, type GetterObserverBehavior, } from "./create-getter-decorator";
+export { createAccessorDecorator, type AccessorBehavior, type AccessorBinding, } from "./create-accessor-decorator";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,EACL,IAAI,EACJ,IAAI,EACJ,GAAG,EACH,IAAI,EACJ,KAAK,EACL,QAAQ,EACR,QAAQ,EACR,IAAI,EACJ,KAAK,EACL,KAAK,EACL,KAAK,QAAQ,EACb,KAAK,SAAS,GACf,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,IAAI,EACJ,KAAK,EACL,QAAQ,EACR,SAAS,EACT,IAAI,EACJ,SAAS,EACT,OAAO,EACP,KAAK,SAAS,EACd,OAAO,EACP,MAAM,EACN,QAAQ,EACR,kBAAkB,EAClB,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACpB,MAAM,EACN,SAAS,GACV,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,KAAK,OAAO,EAAE,aAAa,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AACxE,OAAO,EACL,oBAAoB,EACpB,KAAK,aAAa,EAClB,KAAK,YAAY,GAClB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,EACL,oBAAoB,EACpB,aAAa,EACb,KAAK,gBAAgB,GACtB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,qBAAqB,EACrB,KAAK,cAAc,GACpB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,8BAA8B,EAC9B,KAAK,uBAAuB,GAC7B,MAAM,qCAAqC,CAAC;AAC7C,OAAO,EACL,qBAAqB,EACrB,KAAK,cAAc,EACnB,6BAA6B,EAC7B,KAAK,sBAAsB,GAC5B,MAAM,2BAA2B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,EACL,IAAI,EACJ,IAAI,EACJ,GAAG,EACH,IAAI,EACJ,KAAK,EACL,QAAQ,EACR,QAAQ,EACR,IAAI,EACJ,KAAK,EACL,KAAK,EACL,KAAK,QAAQ,EACb,KAAK,SAAS,GACf,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,IAAI,EACJ,KAAK,EACL,QAAQ,EACR,SAAS,EACT,IAAI,EACJ,SAAS,EACT,OAAO,EACP,KAAK,SAAS,EACd,OAAO,EACP,MAAM,EACN,QAAQ,EACR,kBAAkB,EAClB,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACpB,MAAM,EACN,SAAS,GACV,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,KAAK,OAAO,EAAE,aAAa,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AACxE,OAAO,EACL,oBAAoB,EACpB,KAAK,aAAa,EAClB,KAAK,YAAY,GAClB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,EACL,oBAAoB,EACpB,aAAa,EACb,KAAK,gBAAgB,GACtB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,qBAAqB,EACrB,KAAK,cAAc,GACpB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,8BAA8B,EAC9B,KAAK,uBAAuB,GAC7B,MAAM,qCAAqC,CAAC;AAC7C,OAAO,EACL,qBAAqB,EACrB,KAAK,cAAc,EACnB,6BAA6B,EAC7B,KAAK,sBAAsB,EAC3B,KAAK,qBAAqB,EAC1B,6BAA6B,EAC7B,KAAK,sBAAsB,GAC5B,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,uBAAuB,EACvB,KAAK,gBAAgB,EACrB,KAAK,eAAe,GACrB,MAAM,6BAA6B,CAAC"}

package/dist/index.js

@@ -6,5 +6,6 @@ export { createFieldDecorator, } from "./create-field-decorator";
 export { createClassDecorator, ClassBehavior, } from "./create-class-decorator";
 export { createMethodDecorator, } from "./create-method-decorator";
 export { createLifecycleMethodDecorator, } from "./create-lifecycle-method-decorator";
-export { createGetterDecorator, createGetterObserverDecorator, } from "./create-getter-decorator";
+export { createGetterDecorator, createWritableGetterDecorator, createGetterObserverDecorator, } from "./create-getter-decorator";
+export { createAccessorDecorator, } from "./create-accessor-decorator";
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,EACL,IAAI,EACJ,IAAI,EACJ,GAAG,EACH,IAAI,EACJ,KAAK,EACL,QAAQ,EACR,QAAQ,EACR,IAAI,EACJ,KAAK,EACL,KAAK,GAGN,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,IAAI,EACJ,KAAK,EACL,QAAQ,EACR,SAAS,EACT,IAAI,EACJ,SAAS,EACT,OAAO,EAEP,OAAO,EACP,MAAM,EACN,QAAQ,EACR,kBAAkB,EAGlB,MAAM,EACN,SAAS,GACV,MAAM,cAAc,CAAC;AACtB,OAAO,EAAgB,aAAa,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AACxE,OAAO,EACL,oBAAoB,GAGrB,MAAM,0BAA0B,CAAC;AAElC,OAAO,EACL,oBAAoB,EACpB,aAAa,GAEd,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,qBAAqB,GAEtB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,8BAA8B,GAE/B,MAAM,qCAAqC,CAAC;AAC7C,OAAO,EACL,qBAAqB,EAErB,6BAA6B,GAE9B,MAAM,2BAA2B,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,EACL,IAAI,EACJ,IAAI,EACJ,GAAG,EACH,IAAI,EACJ,KAAK,EACL,QAAQ,EACR,QAAQ,EACR,IAAI,EACJ,KAAK,EACL,KAAK,GAGN,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,IAAI,EACJ,KAAK,EACL,QAAQ,EACR,SAAS,EACT,IAAI,EACJ,SAAS,EACT,OAAO,EAEP,OAAO,EACP,MAAM,EACN,QAAQ,EACR,kBAAkB,EAGlB,MAAM,EACN,SAAS,GACV,MAAM,cAAc,CAAC;AACtB,OAAO,EAAgB,aAAa,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AACxE,OAAO,EACL,oBAAoB,GAGrB,MAAM,0BAA0B,CAAC;AAElC,OAAO,EACL,oBAAoB,EACpB,aAAa,GAEd,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,qBAAqB,GAEtB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,8BAA8B,GAE/B,MAAM,qCAAqC,CAAC;AAC7C,OAAO,EACL,qBAAqB,EAErB,6BAA6B,EAG7B,6BAA6B,GAE9B,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,uBAAuB,GAGxB,MAAM,6BAA6B,CAAC"}

package/dist/properties/computed.d.ts

@@ -1,2 +1,12 @@
-export declare function Computed(): <This, T>(target: (this: This) => T, _context: ClassGetterDecoratorContext<This, T>) => (this: This) => T;
+export interface ComputedOptions<T = unknown> {
+    get?: (this: object) => T;
+    set?: (this: object, value: T) => void;
+}
+export declare function Computed<T, Owner extends object = object>(options: {
+    get: (this: Owner) => T;
+    set: (this: Owner, value: T) => void;
+}): <This extends object>(target: ClassAccessorDecoratorTarget<This, T>, context: ClassAccessorDecoratorContext<This, T>) => ClassAccessorDecoratorResult<This, T>;
+export declare function Computed(options?: {
+    set?: (this: object, value: unknown) => void;
+}): <This, R>(target: (this: This) => R, context: ClassGetterDecoratorContext<This, R>) => (this: This) => R;
 //# sourceMappingURL=computed.d.ts.map

package/dist/properties/computed.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"computed.d.ts","sourceRoot":"","sources":["../../src/properties/computed.ts"],"names":[],"mappings":"AAIA,wBAAgB,QAAQ,8GAavB"}
+{"version":3,"file":"computed.d.ts","sourceRoot":"","sources":["../../src/properties/computed.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,eAAe,CAAC,CAAC,GAAG,OAAO;IAC1C,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,CAAC,CAAC;IAC1B,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC;CACxC;AAKD,wBAAgB,QAAQ,CAAC,CAAC,EAAE,KAAK,SAAS,MAAM,GAAG,MAAM,EAAE,OAAO,EAAE;IAClE,GAAG,EAAE,CAAC,IAAI,EAAE,KAAK,KAAK,CAAC,CAAC;IACxB,GAAG,EAAE,CAAC,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC;CACtC,GAAG,CAAC,IAAI,SAAS,MAAM,EACtB,MAAM,EAAE,4BAA4B,CAAC,IAAI,EAAE,CAAC,CAAC,EAC7C,OAAO,EAAE,6BAA6B,CAAC,IAAI,EAAE,CAAC,CAAC,KAC5C,4BAA4B,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;AAG3C,wBAAgB,QAAQ,CAAC,OAAO,CAAC,EAAE;IACjC,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CAC9C,GAAG,CAAC,IAAI,EAAE,CAAC,EACV,MAAM,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,CAAC,EACzB,OAAO,EAAE,2BAA2B,CAAC,IAAI,EAAE,CAAC,CAAC,KAC1C,CAAC,IAAI,EAAE,IAAI,KAAK,CAAC,CAAC"}

package/dist/properties/computed.js

@@ -1,15 +1,27 @@
 import { computed } from "@praxisjs/core/internal";
-import { createGetterDecorator } from "../create-getter-decorator";
-export function Computed() {
-    const cache = new WeakMap();
-    return createGetterDecorator({
-        wrap(original, instance) {
-            let c = cache.get(instance);
-            if (!c) {
-                c = computed(() => original.call(instance));
-                cache.set(instance, c);
-            }
-            return c;
+import { createAccessorDecorator } from "../create-accessor-decorator";
+import { createWritableGetterDecorator } from "../create-getter-decorator";
+export function Computed(options) {
+    const optionsGet = options?.get;
+    const optionsSet = options?.set;
+    if (optionsGet) {
+        return createAccessorDecorator({
+            bind(instance, _name, _initialValue) {
+                const c = computed(() => optionsGet.call(instance));
+                return {
+                    get: c,
+                    set: optionsSet ? (value) => { optionsSet.call(instance, value); } : undefined,
+                };
+            },
+        });
+    }
+    return createWritableGetterDecorator({
+        bind(instance, _name, original) {
+            const c = computed(() => original.call(instance));
+            return {
+                get: c,
+                set: optionsSet ? (value) => { optionsSet.call(instance, value); } : undefined,
+            };
         },
     });
 }

package/dist/properties/computed.js.map

@@ -1 +1 @@
-{"version":3,"file":"computed.js","sourceRoot":"","sources":["../../src/properties/computed.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAEnD,OAAO,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AAEnE,MAAM,UAAU,QAAQ;IACtB,MAAM,KAAK,GAAG,IAAI,OAAO,EAAyB,CAAC;IAEnD,OAAO,qBAAqB,CAAC;QAC3B,IAAI,CAAC,QAAQ,EAAE,QAAQ;YACrB,IAAI,CAAC,GAAG,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;YAC5B,IAAI,CAAC,CAAC,EAAE,CAAC;gBACP,CAAC,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC;gBAC5C,KAAK,CAAC,GAAG,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC;YACzB,CAAC;YACD,OAAO,CAAC,CAAC;QACX,CAAC;KACF,CAAC,CAAC;AACL,CAAC"}
+{"version":3,"file":"computed.js","sourceRoot":"","sources":["../../src/properties/computed.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAEnD,OAAO,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AACvE,OAAO,EAAE,6BAA6B,EAAE,MAAM,4BAA4B,CAAC;AA0B3E,MAAM,UAAU,QAAQ,CAAc,OAA4B;IAChE,MAAM,UAAU,GAAG,OAAO,EAAE,GAA8C,CAAC;IAC3E,MAAM,UAAU,GAAG,OAAO,EAAE,GAA2D,CAAC;IAExF,IAAI,UAAU,EAAE,CAAC;QACf,OAAO,uBAAuB,CAAC;YAC7B,IAAI,CAAC,QAAQ,EAAE,KAAK,EAAE,aAAa;gBACjC,MAAM,CAAC,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC;gBACpD,OAAO;oBACL,GAAG,EAAE,CAAC;oBACN,GAAG,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC,KAAK,EAAE,EAAE,GAAG,UAAU,CAAC,IAAI,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS;iBAC/E,CAAC;YACJ,CAAC;SACF,CAAC,CAAC;IACL,CAAC;IAED,OAAO,6BAA6B,CAAC;QACnC,IAAI,CAAC,QAAQ,EAAE,KAAK,EAAE,QAAQ;YAC5B,MAAM,CAAC,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC;YAClD,OAAO;gBACL,GAAG,EAAE,CAAC;gBACN,GAAG,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC,KAAK,EAAE,EAAE,GAAG,UAAU,CAAC,IAAI,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS;aAC/E,CAAC;QACJ,CAAC;KACF,CAAC,CAAC;AACL,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@praxisjs/decorators",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -15,8 +15,8 @@
     "typescript": "^5.9.3"
   },
   "dependencies": {
-    "@praxisjs/core": "1.7.0",
-    "@praxisjs/shared": "0.2.0"
+    "@praxisjs/core": "1.8.0",
+    "@praxisjs/shared": "0.3.0"
   },
   "scripts": {
     "build": "tsc",

package/src/__tests__/properties.test.ts

@@ -4,6 +4,8 @@ import { StatefulComponent } from "@praxisjs/core";
 import { signal, computed } from "@praxisjs/core/internal";
 
 import { createFieldDecorator } from "../create-field-decorator";
+import { createGetterDecorator } from "../create-getter-decorator";
+import { createAccessorDecorator } from "../create-accessor-decorator";
 import { Watch } from "../functions/watch";
 import { When } from "../functions/when";
 import { Compose } from "../properties/compose";
@@ -152,39 +154,243 @@ describe("Prop decorator", () => {
 
 describe("Computed decorator", () => {
   it("wraps a getter in a computed — result is memoized", () => {
-    const fn = vi.fn(function (this: { base: number }) {
-      return this.base * 2;
-    });
+    const s = signal(5);
+    const fn = vi.fn(function (this: object) { return s() * 2; });
 
-    const wrappedGetter = Computed()(fn, {} as ClassGetterDecoratorContext);
-    const instance = { base: 5 } as unknown as StatefulComponent;
+    const { ctx, run } = getterCtx("doubled");
+    Computed()(fn, ctx);
+    const instance = {} as unknown as StatefulComponent;
+    run(instance);
 
-    const result1 = wrappedGetter.call(instance);
-    const result2 = wrappedGetter.call(instance);
+    const result1 = (instance as unknown as Record<string, unknown>).doubled;
+    const result2 = (instance as unknown as Record<string, unknown>).doubled;
     expect(result1).toBe(10);
     expect(result2).toBe(10);
-    expect(fn).toHaveBeenCalledTimes(1); // lazy caching
+    expect(fn).toHaveBeenCalledTimes(1);
   });
 
   it("recomputes when underlying signal changes", () => {
     const s = signal(3);
     const getter = function (this: object) { return s() * 2; };
-    const wrapped = Computed()(getter, {} as ClassGetterDecoratorContext);
+    const { ctx, run } = getterCtx("val");
+    Computed()(getter, ctx);
     const obj = {} as unknown as StatefulComponent;
-    expect(wrapped.call(obj)).toBe(6);
+    run(obj);
+
+    expect((obj as unknown as Record<string, unknown>).val).toBe(6);
     s.set(5);
-    expect(wrapped.call(obj)).toBe(10);
+    expect((obj as unknown as Record<string, unknown>).val).toBe(10);
   });
 
   it("is per-instance — separate computed per object", () => {
     const s = signal(1);
     const getter = function (this: object) { return s(); };
-    const wrapped = Computed()(getter, {} as ClassGetterDecoratorContext);
+    const { ctx, run } = getterCtx("val");
+    Computed()(getter, ctx);
     const a = {} as unknown as StatefulComponent;
     const b = {} as unknown as StatefulComponent;
-    expect(wrapped.call(a)).toBe(1);
-    expect(wrapped.call(b)).toBe(1);
-    // Both share the same signal but have independent computed instances
+    run(a);
+    run(b);
+
+    expect((a as unknown as Record<string, unknown>).val).toBe(1);
+    expect((b as unknown as Record<string, unknown>).val).toBe(1);
+  });
+});
+
+// ── Computed (writable) ───────────────────────────────────────────────────────
+
+function getterCtx(name: string) {
+  const initializers: Array<(this: unknown) => void> = [];
+  return {
+    ctx: {
+      name,
+      kind: "getter" as const,
+      addInitializer(fn: (this: unknown) => void) {
+        initializers.push(fn);
+      },
+    } as unknown as ClassGetterDecoratorContext,
+    run(instance: unknown) {
+      initializers.forEach((fn) => { fn.call(instance); });
+    },
+  };
+}
+
+describe("Computed decorator — writable (set option)", () => {
+  it("setter is called when property is assigned", () => {
+    const written: number[] = [];
+    const { ctx, run } = getterCtx("double");
+
+    const s = signal(3);
+    const getter = function (this: object) { return s() * 2; };
+    Computed({ set: (v: unknown) => { written.push(v as number); } })(getter, ctx);
+
+    const instance = {} as unknown as StatefulComponent;
+    run(instance);
+
+    (instance as unknown as Record<string, unknown>).double = 42;
+    expect(written).toEqual([42]);
+  });
+
+  it("setter receives the component instance as this", () => {
+    let capturedThis: unknown;
+    const { ctx, run } = getterCtx("val");
+
+    const getter = function (this: object) { return 0; };
+    Computed({ set(this: unknown, _v: unknown) { capturedThis = this; } })(getter, ctx);
+
+    const instance = { id: "target" } as unknown as StatefulComponent;
+    run(instance);
+
+    (instance as unknown as Record<string, unknown>).val = 99;
+    expect(capturedThis).toBe(instance);
+  });
+
+  it("getter still returns the computed value after set option is added", () => {
+    const s = signal(5);
+    const { ctx, run } = getterCtx("doubled");
+
+    const getter = function (this: object) { return s() * 2; };
+    Computed({ set: (_v: unknown) => { /* no-op */ } })(getter, ctx);
+
+    const instance = {} as unknown as StatefulComponent;
+    run(instance);
+
+    expect((instance as unknown as Record<string, unknown>).doubled).toBe(10);
+    s.set(7);
+    expect((instance as unknown as Record<string, unknown>).doubled).toBe(14);
+  });
+
+  it("setter writes through to underlying signals, updating the getter", () => {
+    const s = signal(0);
+    const { ctx, run } = getterCtx("celsius");
+
+    const getter = function (this: object) { return s(); };
+    Computed({ set: (v: unknown) => { s.set(v as number); } })(getter, ctx);
+
+    const instance = {} as unknown as StatefulComponent;
+    run(instance);
+
+    (instance as unknown as Record<string, unknown>).celsius = 100;
+    expect((instance as unknown as Record<string, unknown>).celsius).toBe(100);
+  });
+});
+
+// ── Computed (accessor form) ──────────────────────────────────────────────────
+
+describe("Computed decorator — accessor form ({ get, set })", () => {
+  function applyAccessorDecorator<T>(
+    options: { get: (this: object) => T; set: (this: object, value: T) => void },
+    instance: object,
+  ): { get: () => T; set: (v: T) => void } {
+    const target = {
+      get(this: object) { return undefined as T; },
+      set(_v: T) { /* original */ },
+    };
+    const ctx = { kind: "accessor", name: "value" } as unknown as ClassAccessorDecoratorContext<object, T>;
+    const result = Computed(options)(target, ctx);
+    result.init!.call(instance, undefined as unknown as T);
+    return {
+      get: () => result.get!.call(instance),
+      set: (v: T) => result.set!.call(instance, v),
+    };
+  }
+
+  it("get function is wrapped in a computed — result is memoized", () => {
+    const s = signal(3);
+    const getFn = vi.fn(function (this: object) { return s() * 2; });
+    const instance = {};
+    const { get } = applyAccessorDecorator({ get: getFn, set: () => { /* no-op */ } }, instance);
+
+    expect(get()).toBe(6);
+    expect(get()).toBe(6);
+    expect(getFn).toHaveBeenCalledTimes(1);
+  });
+
+  it("recomputes when underlying signal changes", () => {
+    const s = signal(10);
+    const instance = {};
+    const { get } = applyAccessorDecorator({
+      get(this: object) { return s() + 1; },
+      set() { /* no-op */ },
+    }, instance);
+
+    expect(get()).toBe(11);
+    s.set(20);
+    expect(get()).toBe(21);
+  });
+
+  it("set function is called when the setter is invoked", () => {
+    const written: number[] = [];
+    const instance = {};
+    const { set } = applyAccessorDecorator({
+      get(this: object) { return 0; },
+      set(_v: number) { written.push(_v); },
+    }, instance);
+
+    set(42);
+    expect(written).toEqual([42]);
+  });
+
+  it("set function receives the component instance as this", () => {
+    let capturedThis: unknown;
+    const instance = { id: "target" };
+    const { set } = applyAccessorDecorator({
+      get(this: object) { return 0; },
+      set(this: unknown) { capturedThis = this; },
+    }, instance);
+
+    set(1);
+    expect(capturedThis).toBe(instance);
+  });
+
+  it("set writes through to underlying signals, updating the getter", () => {
+    const s = signal(0);
+    const instance = {};
+    const { get, set } = applyAccessorDecorator({
+      get(this: object) { return s(); },
+      set(this: object, v: number) { s.set(v); },
+    }, instance);
+
+    set(100);
+    expect(get()).toBe(100);
+  });
+
+  it("is per-instance — separate computed per object", () => {
+    const s = signal(5);
+    const options = {
+      get(this: object) { return s() * 2; },
+      set() { /* no-op */ },
+    };
+    const a = {};
+    const b = {};
+    const decA = applyAccessorDecorator(options, a);
+    const decB = applyAccessorDecorator(options, b);
+
+    expect(decA.get()).toBe(10);
+    expect(decB.get()).toBe(10);
+    s.set(7);
+    expect(decA.get()).toBe(14);
+    expect(decB.get()).toBe(14);
+  });
+
+  it("accessor form without set — setter is a no-op", () => {
+    const s = signal(5);
+    const instance = {};
+    const target = { get() { return undefined as unknown as number; }, set() { /* original */ } };
+    const ctx = { kind: "accessor", name: "value" } as unknown as ClassAccessorDecoratorContext<object, number>;
+    // Bypass overload constraint — optionsSet is undefined at runtime
+    type AccessorDecoFactory = (opts: { get: (this: object) => number }) => (
+      t: typeof target,
+      c: typeof ctx,
+    ) => ClassAccessorDecoratorResult<object, number>;
+    const result = (Computed as unknown as AccessorDecoFactory)(
+      { get(this: object) { return s() * 2; } },
+    )(target, ctx);
+    result.init!.call(instance, 0);
+
+    expect(result.get!.call(instance)).toBe(10);
+    expect(() => { result.set!.call(instance, 99); }).not.toThrow();
+    expect(result.get!.call(instance)).toBe(10); // unchanged — no setter
   });
 });
 
@@ -1157,3 +1363,83 @@ describe("createFieldDecorator — additional property", () => {
     expect((instance as unknown as Record<string, unknown>).extraProp).toBe("extra");
   });
 });
+
+// ── createGetterDecorator ─────────────────────────────────────────────────────
+
+describe("createGetterDecorator", () => {
+  it("calls behavior.wrap on access and returns the wrapped value", () => {
+    const wrap = vi.fn((original: (this: object) => unknown, instance: object) => {
+      return () => (original.call(instance) as number) * 2;
+    });
+    const decorator = createGetterDecorator({ wrap });
+    const originalGetter = function (this: object) { return 5 as unknown; };
+    const ctx = { kind: "getter" } as ClassGetterDecoratorContext<object, number>;
+    const wrapped = decorator(originalGetter as (this: object) => number, ctx);
+
+    const instance = {};
+    expect(wrapped.call(instance)).toBe(10);
+    expect(wrap).toHaveBeenCalledWith(originalGetter, instance);
+  });
+
+  it("passes the correct instance as this to behavior.wrap", () => {
+    let capturedInstance: unknown;
+    const decorator = createGetterDecorator({
+      wrap(_original, instance) {
+        capturedInstance = instance;
+        return () => 0;
+      },
+    });
+    const getter = function (this: object) { return 0 as unknown; };
+    const ctx = { kind: "getter" } as ClassGetterDecoratorContext<object, number>;
+    const wrapped = decorator(getter as (this: object) => number, ctx);
+
+    const instance = { id: "test-instance" };
+    wrapped.call(instance);
+    expect(capturedInstance).toBe(instance);
+  });
+});
+
+// ── createAccessorDecorator — init ────────────────────────────────────────────
+
+describe("createAccessorDecorator — init", () => {
+  it("init stores the initial value that bind receives on first get", () => {
+    let capturedInitialValue: unknown = "NOT_SET";
+    const behavior = {
+      bind(_inst: object, _name: string | symbol, initialValue: unknown) {
+        capturedInitialValue = initialValue;
+        return { get: () => initialValue };
+      },
+    };
+    const decorator = createAccessorDecorator(behavior);
+    const target = {
+      get() { return 0; },
+      set() { /* original */ },
+    } as ClassAccessorDecoratorTarget<object, number>;
+    const ctx = { kind: "accessor", name: "val" } as unknown as ClassAccessorDecoratorContext<object, number>;
+    const result = decorator(target, ctx);
+
+    const instance = {};
+    const returned = result.init!.call(instance, 42);
+    result.get!.call(instance); // triggers bind
+    expect(returned).toBe(42);
+    expect(capturedInitialValue).toBe(42);
+  });
+
+  it("init returns the initial value unchanged", () => {
+    const behavior = {
+      bind(_inst: object, _name: string | symbol, initialValue: unknown) {
+        return { get: () => initialValue };
+      },
+    };
+    const decorator = createAccessorDecorator(behavior);
+    const target = {
+      get() { return ""; },
+      set() { /* original */ },
+    } as ClassAccessorDecoratorTarget<object, string>;
+    const ctx = { kind: "accessor", name: "s" } as unknown as ClassAccessorDecoratorContext<object, string>;
+    const result = decorator(target, ctx);
+
+    const instance = {};
+    expect(result.init!.call(instance, "hello")).toBe("hello");
+  });
+});

package/src/create-accessor-decorator.ts

@@ -0,0 +1,45 @@
+export interface AccessorBinding {
+  get: () => unknown;
+  set?: (value: unknown) => void;
+}
+
+export interface AccessorBehavior {
+  /**
+   * Called once per instance on first access. `initialValue` is the value
+   * provided by the `accessor` field initializer (e.g. `accessor count = 0`).
+   * Returns the get/set pair used by the accessor.
+   */
+  bind(instance: object, name: string | symbol, initialValue: unknown): AccessorBinding;
+}
+
+export function createAccessorDecorator(behavior: AccessorBehavior) {
+  return function <This extends object, V>(
+    _target: ClassAccessorDecoratorTarget<This, V>,
+    context: ClassAccessorDecoratorContext<This, V>,
+  ): ClassAccessorDecoratorResult<This, V> {
+    const bindings = new WeakMap<object, AccessorBinding>();
+    const initValues = new WeakMap<object, unknown>();
+
+    function getBinding(instance: object): AccessorBinding {
+      let b = bindings.get(instance);
+      if (!b) {
+        b = behavior.bind(instance, context.name, initValues.get(instance));
+        bindings.set(instance, b);
+      }
+      return b;
+    }
+
+    return {
+      init(this: This, value: V): V {
+        initValues.set(this as object, value);
+        return value;
+      },
+      get(this: This): V {
+        return getBinding(this as object).get() as V;
+      },
+      set(this: This, value: V): void {
+        getBinding(this as object).set?.(value as unknown);
+      },
+    };
+  };
+}

package/src/create-getter-decorator.ts

@@ -23,6 +23,45 @@ export function createGetterDecorator(behavior: GetterBehavior) {
   };
 }
 
+export interface WritableGetterBinding {
+  get: () => unknown;
+  set?: (value: unknown) => void;
+}
+
+export interface WritableGetterBehavior {
+  /**
+   * Called once per instance during construction. Returns the get/set pair
+   * that will be installed on the instance via `Object.defineProperty`.
+   * If `set` is omitted, the property is read-only at runtime (though TypeScript
+   * may still see a setter if one is declared in the class body).
+   */
+  bind(
+    instance: object,
+    name: string | symbol,
+    original: (this: object) => unknown,
+  ): WritableGetterBinding;
+}
+
+export function createWritableGetterDecorator(behavior: WritableGetterBehavior) {
+  return function <This, T>(
+    target: (this: This) => T,
+    context: ClassGetterDecoratorContext<This, T>,
+  ): (this: This) => T {
+    context.addInitializer(function (this: unknown) {
+      const instance = this as object;
+      const binding = behavior.bind(instance, context.name, target as (this: object) => unknown);
+      const descriptor: PropertyDescriptor = {
+        get: binding.get,
+        configurable: true,
+        enumerable: false,
+      };
+      if (binding.set !== undefined) descriptor.set = binding.set;
+      Object.defineProperty(instance, context.name, descriptor);
+    });
+    return target;
+  };
+}
+
 export interface GetterObserverBehavior {
   /**
    * Called once per instance when the class is initialized.

package/src/index.ts

@@ -54,6 +54,14 @@ export {
 export {
   createGetterDecorator,
   type GetterBehavior,
+  createWritableGetterDecorator,
+  type WritableGetterBehavior,
+  type WritableGetterBinding,
   createGetterObserverDecorator,
   type GetterObserverBehavior,
 } from "./create-getter-decorator";
+export {
+  createAccessorDecorator,
+  type AccessorBehavior,
+  type AccessorBinding,
+} from "./create-accessor-decorator";