Index: gdjn.ct
==================================================================
--- gdjn.ct
+++ gdjn.ct
@@ -56,20 +56,22 @@
 	deficient: it is deficient in one particular way: it only operates over bytestrings. so you can use a PEG to parse raw text, or you can use it to implement a lexer, but you can't have both a PEG lexer and parser, which is really fucking dumb and makes things like dealing with whitespace far more painful than it needs to be.)
 
 ##obj object model
 godot uses a strongly javalike OOP system, which translates poorly to Janet's prototype-based OO. gdjn therefore uses the following convention to translate between the two.
 
-the engine executes the "compile-time" phase of a janet script once it is finished loading. it is the responsibility of the compile-time thunk to set up the local environment to represent a class using def statements. the abstract serves as a proxy for method calls. when a lookup is performed against a class proxy, the proxy inspects its attached environment and returns an appropriate object.
+class definitions are represented by janet environments. any environment with the proper definitions and annotations can be treated as a class, whether from janet code or from GDScript. environments that do not define a class are treated as simple janet modules; their functionality is exported to GDScript by representing a janet module as an abstract class with only static members.
 
-unadorned immutable bindings are treated as constants. values with the [":field type] annotation are treated as object fields. when a new instance is created, space is allocated for a field of the appropriate type, and initialized to the value of the binding. public [`var] mutable bindins are treated as static variables.
+the engine/editor executes the "compile-time" phase of a janet script once it is finished loading or saving. it is the responsibility of the compile-time thunk to define the runtime behavior of the class by populating the environment with the proper bindings. 
+
+unadorned immutable bindings are treated as constants. values with the [":field type] annotation are treated as object fields. when a new instance is created, space is allocated for a field of the appropriate type, and initialized to the value of the binding. public [`var] mutable bindings are treated as static variables.
 
 ~~~[janet] example bindings
 (def name "Lisuan") # constant string
-(def name :field "Lisuan") # field of type string, initializes to "Lisuan"
-(def name {:field :variant} "Lisuan") field of type variant
+(def name :prop "Lisuan") # field of type string, initializes to "Lisuan"
+(def name {:prop :variant} "Lisuan") field of type variant
 (def- secret "swordfish") # private constant
-(def- secret :field "swordfish") # private string field
+(def- secret :prop "swordfish") # private string field
 (var count 0) # static variable of type int
 (var- count 0) # private static variable of type int
 ~~~
 
 unadorned functions are treated as static functions.
@@ -76,40 +78,44 @@
 
 private functions (those declared with [`def-]) are available only within the class implementation. they are not exported as methods.
 
 functions with the annotation [":method] are treated as methods. when invoked, they are passed a [`self]-reference as their first argument.
 
-function type signatures can be specified with the annotations [":takes [...]] and [`:gives [$type]].
+function type signatures can be specified with the annotation ["{:method {:sig [ty name ...] :ret ret-type}}].
 
-tables with the annotation [":subclass] are treated as environment tables specifying inner classes. the macro [`subclass] should generally be used to maintain uniform syntax between outer and inner classes, e.g.
+tables with the annotation [":subclass] are treated as environment tables specifying inner classes. the macro [`defclass] should generally be used to maintain uniform syntax between outer and inner classes, e.g.
 
 ~~~[janet]
-(use core)
 (use-classes Object RefCounted)
 (declare outerClass :is Object)
 (def val 10)
-(prop v vec3)
+(prop t :float 0)
+(conf v :vec3 0 0 0)
+(data x :packed-byte-array [])
 (defclass innerClass :is RefCounted
 	(def val 2))
 
 # equivalent to
-(import prim)
+(use core) # implicit
 (def Object (prim/load-class :Object))
 (def RefCounted (prim/load-class :RefCounted))
-(def *class-name* :meta :outerClass)
-(def *class-inherit* :meta Object)
+(def @id :outerClass)
+(def @inherit Object)
 (def val 10)
+(def t {:prop :float} 0)
+(def v {:prop :vector3} :export 0)
+(def x {:prop :packed-byte-array} :export-storage [])
 (def innerClass (do
-	(def *class-inherit* :meta RefCounted)
+	(def @inherit RefCounted)
 	(let [env (table/setproto @{} (curenv))]
 		(eval '(do
 			(def val 2))
 		env)
 	env)))
 ~~~
 
-since the annotations are somewhat verbose, macros are provided to automate the process.
+since the annotations are somewhat verbose, macros are provided to automate the process. note that while the subclass mechanism looks exceptionally tricksy and aggressively dynamic, all of the class definition code is executed completely at compile-time, so there is no runtime cost to defining a subclass rather than a top-level class.
 
 + janet + gdscript
 | ["(def count 10)] | ["const count := 10]
 | ["(def count {:field int} 10)] | ["var count: int = 10]
 | ["(defn open [path] ...)] | ["static func open(path: Variant) ...]

Index: src/janet-lang.gcd
==================================================================
--- src/janet-lang.gcd
+++ src/janet-lang.gcd
@@ -323,10 +323,13 @@
 			return (pstr) {
 				.v = (char*)str,
 				.sz = janet_string_length(str),
 			};
 		}
+	};
+	impl _get_script_method_list() -> array[dictionary] {
+		return me -> methodBinds;
 	};
 	impl _reload(bool keepState) -> int {
 		gd_array_clear(&me -> methodBinds);
 		/* parse the class environment */
 		JanetTable* const env = me -> env;