@gi-tcg/gts-runtime 0.6.8 → 0.7.1

package/dist/index.d.ts

@@ -15,8 +15,8 @@ declare namespace AttributeReturn {
       "~meta": void;
     };
   };
-  type With<VM extends IViewModel<any, any, any>, TMeta = VM["~namedDefinition"]["~meta"]> = {
-    namedDefinition: BlockDefinitionRewriteMeta<VM["~namedDefinition"], TMeta>;
+  type With<VMI extends IViewModelInstance, TMeta = VMI["~viewModel"]["~namedDefinition"]["~meta"]> = {
+    namedDefinition: BlockDefinitionRewriteMeta<VMI["~viewModel"]["~namedDefinition"], TMeta>;
   };
   type DoneRewriteMeta<NewMeta> = {
     namedDefinition: {
@@ -24,17 +24,12 @@ declare namespace AttributeReturn {
     };
     rewriteMeta: NewMeta;
   };
-  type WithRewriteMeta<NewMeta, VM extends IViewModel<any, any, any>, TMeta = VM["~namedDefinition"]["~meta"]> = {
-    namedDefinition: BlockDefinitionRewriteMeta<VM["~namedDefinition"], TMeta>;
+  type WithRewriteMeta<NewMeta, VMI extends IViewModelInstance, TMeta = VMI["~viewModel"]["~namedDefinition"]["~meta"]> = {
+    namedDefinition: BlockDefinitionRewriteMeta<VMI["~viewModel"]["~namedDefinition"], TMeta>;
     rewriteMeta: NewMeta;
   };
 }
 //#endregion
-//#region src/symbols.d.ts
-type Meta = "~meta";
-type Action = "~action";
-type NamedDefinition = "~namedDefinition";
-//#endregion
 //#region src/view.d.ts
 type AttributeName = string | symbol;
 interface SingleAttributeNode {
@@ -66,39 +61,50 @@ declare function createBinding(rootVM: IViewModel<any, any, any>, node: SingleAt
 interface AttributeBlockDefinition {
   "~meta": any;
 }
-type BlockDefinitionRewriteMeta<BlockDef extends AttributeBlockDefinition, NewMeta> = Computed<Omit<BlockDef, Meta> & {
+interface PartialAttributeBlockDefinition extends Partial<Record<string, AttributeDefinition>> {}
+type BlockDefinitionRewriteMeta<BlockDef extends AttributeBlockDefinition, NewMeta> = Computed<Omit<BlockDef, "~meta"> & {
   "~meta": NewMeta;
 }, AttributeBlockDefinition>;
+interface IViewModelInstance<T extends IViewModel<any, any, any> = IViewModel<any, any, any>> {
+  "~viewModel": T;
+}
+type DeferredIViewModel<T> = T extends IViewModel<any, any, any> ? T : never;
+interface IReboundViewModel<BaseViewModel extends IViewModel<any, any, any>, NewCtorArgs extends any[]> extends DeferredIViewModel<IViewModel<BaseViewModel["~modelType"], BaseViewModel["~namedDefinition"], NewCtorArgs>> {}
+interface INarrowedViewModel<BaseViewModel extends IViewModel<any, any, any>, NewMeta extends BaseViewModel["~namedDefinition"]["~meta"]> extends DeferredIViewModel<IViewModel<BaseViewModel["~modelType"], BlockDefinitionRewriteMeta<BaseViewModel["~namedDefinition"], NewMeta>, BaseViewModel["~ctorArgs"]>> {}
+interface IExtendedViewModel<BaseViewModel extends IViewModel<any, any, any>, ChildModelT extends BaseViewModel["~modelType"], ChildBlockDef extends PartialAttributeBlockDefinition, ChildCtorArgs extends any[]> extends DeferredIViewModel<IViewModel<ChildModelT, Computed<Omit<BaseViewModel["~namedDefinition"], keyof ChildBlockDef> & ChildBlockDef & {
+  "~meta": BaseViewModel["~namedDefinition"]["~meta"];
+}>, ChildCtorArgs>> {}
 interface IViewModel<ModelT, BlockDef extends AttributeBlockDefinition, CtorArgs extends any[]> {
+  "~modelType": ModelT;
+  "~ctorArgs": CtorArgs;
+  "~namedDefinition": BlockDef;
+  new (): IViewModelInstance<this>;
+  "~viewModel": this;
   parse(view: View<BlockDefinitionRewriteMeta<BlockDef, unknown>>, ...args: CtorArgs): ModelT;
   /**
   * Creates a new ViewModel with the same actions and binders, but with
-  * - a different constructor that accepts the specified arguments, and/or
-  * - a different initial Meta.
+  * a different constructor that accepts the specified arguments.
   *
   * This is useful for creating binding ViewModels directly that forwards
   * the binding logic to inner ViewModels.
   */
-  bind<NewMeta = BlockDef[Meta]>(): IViewModel<ModelT, BlockDefinitionRewriteMeta<BlockDef, NewMeta>, CtorArgs>;
-  bind<NewMeta = BlockDef[Meta]>(...args: CtorArgs): IViewModel<ModelT, BlockDefinitionRewriteMeta<BlockDef, NewMeta>, []>;
-  extend<ChildT extends ModelT, const ChildBlockDef extends Partial<Record<string | Action, AttributeDefinition>>, ChildCtorArgs extends any[] = []>(Ctor: new (...args: ChildCtorArgs) => ChildT, modelDefFn: (helper: AttributeDefHelper<ChildT>) => ChildBlockDef): IViewModel<ChildT, Computed<Omit<BlockDef, keyof ChildBlockDef> & ChildBlockDef & {
-    "~meta": BlockDef[Meta];
-  }>, ChildCtorArgs>;
-  "~namedDefinition": BlockDef;
+  bind<This extends IViewModel<any, any, any>>(this: This, ...args: CtorArgs): IReboundViewModel<This, []>;
+  /**
+  * Rewrite the initial meta.
+  * @param newMeta 
+  */
+  narrow<This extends IViewModel<any, any, any>, const NewMeta extends This["~namedDefinition"]["~meta"]>(this: This, newMeta: NewMeta): INarrowedViewModel<This, NewMeta>;
+  extend<This extends IViewModel<any, any, any>, ChildT extends ModelT, const ChildBlockDef extends PartialAttributeBlockDefinition, ChildCtorArgs extends any[] = []>(this: This, Ctor: new (...args: ChildCtorArgs) => ChildT, modelDefFn: (helper: AttributeDefHelper<ChildT>) => ChildBlockDef): IExtendedViewModel<This, ChildT, ChildBlockDef, ChildCtorArgs>;
 }
 type LazyAttributeActionOrBinder<ModelT> = (model: ModelT, positionals: () => unknown[], named: View<any>) => unknown;
 declare function getCurrentContext(): "action" | "binder" | null;
-declare class ViewModel<ModelT, BlockDef extends AttributeBlockDefinition, CtorArgs extends any[]> implements IViewModel<ModelT, BlockDef, CtorArgs> {
+declare class ViewModelRuntime {
   #private;
-  "~namedDefinition": BlockDef;
-  constructor(Ctor: new (...args: CtorArgs) => ModelT);
-  "~setActionOrBinder"(context: "action" | "binder", name: PropertyKey, action: LazyAttributeActionOrBinder<ModelT>): void;
-  parse(view: View<BlockDefinitionRewriteMeta<BlockDef, unknown>>, ...args: CtorArgs): ModelT;
-  bind<NewMeta = BlockDef[Meta]>(): IViewModel<ModelT, BlockDefinitionRewriteMeta<BlockDef, NewMeta>, CtorArgs>;
-  bind<NewMeta = BlockDef[Meta]>(...args: CtorArgs): IViewModel<ModelT, BlockDefinitionRewriteMeta<BlockDef, NewMeta>, []>;
-  extend<ChildT extends ModelT, const ChildBlockDef extends Partial<Record<string | Action, AttributeDefinition>>, ChildCtorArgs extends any[] = []>(Ctor: new (...args: ChildCtorArgs) => ChildT, modelDefFn: (helper: AttributeDefHelper<ChildT>) => ChildBlockDef): IViewModel<ChildT, Computed<Omit<BlockDef, keyof ChildBlockDef> & ChildBlockDef & {
-    "~meta": BlockDef[Meta];
-  }>, ChildCtorArgs>;
+  constructor(Ctor: new (...args: any[]) => any);
+  setActionOrBinder(context: "action" | "binder", name: PropertyKey, action: LazyAttributeActionOrBinder<any>): void;
+  parse(view: View<any>, ...args: any[]): any;
+  bind(...args: any[]): ViewModelRuntime;
+  extend(ChildCtor: new (...args: any[]) => any, modelDefFn: (helper: AttributeDefHelper<any>) => any): ViewModelRuntime;
 }
 interface SimpleAttributeOptions {
   required?: true;
@@ -111,7 +117,7 @@ type WithSimpleOptions<Base, Options extends SimpleAttributeOptions> = Base & (O
 } : {});
 declare class AttributeDefHelper<ModelT> {
   #private;
-  constructor(viewModel: ViewModel<ModelT, any, any>);
+  constructor(vmr: ViewModelRuntime);
   "~assignActions"(defResult: Partial<Record<string, unknown>>): void;
   attribute<T extends AttributeDefinition & {
     as?: undefined;
@@ -136,9 +142,10 @@ declare class AttributeDefHelper<ModelT> {
     }, Options>;
   };
 }
-declare function defineViewModel<T, const BlockDef extends Partial<Record<string | Action, AttributeDefinition>>, CtorArgs extends any[] = [], InitMeta = void>(Ctor: new (...args: CtorArgs) => T, modelDefFn: (helper: AttributeDefHelper<T>) => BlockDef, initMeta?: InitMeta): IViewModel<T, BlockDef & {
+declare function defineViewModel<T, const BlockDef extends PartialAttributeBlockDefinition, CtorArgs extends any[] = [], InitMeta = unknown>(Ctor: new (...args: CtorArgs) => T, modelDefFn: (helper: AttributeDefHelper<T>) => BlockDef, initMeta?: InitMeta): IViewModel<T, BlockDef & {
   "~meta": InitMeta;
 }, CtorArgs>;
+declare function extendViewModel<BaseViewModel extends IViewModel<any, any, any>, ChildModelT extends BaseViewModel["~modelType"], const ChildBlockDef extends PartialAttributeBlockDefinition, ChildCtorArgs extends any[] = []>(baseViewModel: BaseViewModel, Ctor: new (...args: ChildCtorArgs) => ChildModelT, modelDefFn: (helper: AttributeDefHelper<ChildModelT>) => ChildBlockDef): IExtendedViewModel<BaseViewModel, ChildModelT, ChildBlockDef, ChildCtorArgs>;
 interface AttributeDefinition {
   (...args: any[]): AttributePositionalReturnBase;
   as?(): any;
@@ -260,18 +267,18 @@ type IfAll<T extends (boolean | undefined)[], TrueT, FalseT> = T[number] extends
 type SimpleViewModelAttribute<ValueT, Options extends SimpleViewModelOptions> = {
   (value: ValueT): AttributeReturn.Done;
 } & IfAll<[Options["recursive"], IsSingleton<ExtractObject<ValueT>>], {
-  (): AttributeReturn.With<SimpleViewModel<ExtractObject<ValueT>, Options>>;
+  (): AttributeReturn.With<IViewModelInstance<ISimpleViewModel<ExtractObject<ValueT>, Options>>>;
 }, IfAll<[Options["booleanSwitch"], true extends ValueT ? true : false], {
   (): AttributeReturn.Done;
 }, {}>>;
-interface SimpleViewModel<T, Options extends SimpleViewModelOptions = {}> extends IViewModel<T, { [K in keyof T]-?: SimpleViewModelAttribute<T[K], Options> & {
+interface ISimpleViewModel<T, Options extends SimpleViewModelOptions = {}> extends IViewModel<T, { [K in keyof T]-?: SimpleViewModelAttribute<T[K], Options> & {
   uniqueKey(): K;
   required(): {} extends Pick<T, K> ? false : true;
 } } & {
-  "~meta": undefined;
+  "~meta": unknown;
 }, []> {
   Model: new () => T;
 }
-declare function defineSimpleViewModel<const T extends StandardJSONSchemaV1, const Options extends SimpleViewModelOptions = {}>(schema: T, options?: Options): SimpleViewModel<StandardJSONSchemaV1.InferInput<T>, Options>;
+declare function defineSimpleViewModel<const T extends StandardJSONSchemaV1, const Options extends SimpleViewModelOptions = {}>(schema: T, options?: Options): ISimpleViewModel<StandardJSONSchemaV1.InferInput<T>, Options>;
 //#endregion
-export { type AttributeReturn as AR, type AttributeReturn, type Action, type AttributeBlockDefinition, type AttributeDefinition, type IViewModel, type Meta, type NamedAttributesNode, type NamedDefinition, type SimpleAttributeOptions, type SimpleViewModel, type SimpleViewModelOptions, type SingleAttributeNode, type View, createBinding, createDefine, defineSimpleViewModel, defineViewModel, getCurrentContext };
+export { type AttributeReturn as AR, type AttributeReturn, type AttributeBlockDefinition, type AttributeDefinition, type IExtendedViewModel, type INarrowedViewModel, type IReboundViewModel, type ISimpleViewModel, type IViewModel, type IViewModelInstance, type NamedAttributesNode, type SimpleAttributeOptions, type SimpleViewModelOptions, type SingleAttributeNode, type View, createBinding, createDefine, defineSimpleViewModel, defineViewModel, extendViewModel, getCurrentContext };

package/dist/index.js

@@ -34,14 +34,14 @@ let currentContext = null;
 function getCurrentContext() {
 	return currentContext;
 }
-var ViewModel = class ViewModel {
+var ViewModelRuntime = class ViewModelRuntime {
 	#registeredActions = /* @__PURE__ */ new Map();
 	#registeredBinders = /* @__PURE__ */ new Map();
 	#Ctor;
 	constructor(Ctor) {
 		this.#Ctor = Ctor;
 	}
-	"~setActionOrBinder"(context, name, action) {
+	setActionOrBinder(context, name, action) {
 		if (context === "action") this.#registeredActions.set(name, action);
 		else this.#registeredBinders.set(name, action);
 	}
@@ -64,36 +64,60 @@ var ViewModel = class ViewModel {
 		currentContext = null;
 		return model;
 	}
-	#clone() {
-		const newVM = new ViewModel(this.#Ctor);
-		newVM.#registeredActions = new Map(this.#registeredActions);
-		newVM.#registeredBinders = new Map(this.#registeredBinders);
-		return newVM;
+	#clone(Ctor = this.#Ctor) {
+		const newVMR = new ViewModelRuntime(Ctor);
+		newVMR.#registeredActions = new Map(this.#registeredActions);
+		newVMR.#registeredBinders = new Map(this.#registeredBinders);
+		return newVMR;
 	}
 	bind(...args) {
-		if (args.length === 0) return this;
-		const newModel = this.#clone();
-		newModel.#Ctor = class extends this.#Ctor {
+		const ParentCtor = this.#Ctor;
+		class ReboundCtor extends ParentCtor {
 			constructor() {
 				super(...args);
 			}
-		};
-		return newModel;
+		}
+		return this.#clone(ReboundCtor);
 	}
-	extend(Ctor, modelDefFn) {
-		const newVM = new ViewModel(Ctor);
-		for (const [name, action] of this.#registeredActions) newVM["~setActionOrBinder"]("action", name, action);
-		for (const [name, binder] of this.#registeredBinders) newVM["~setActionOrBinder"]("binder", name, binder);
-		const helper = new AttributeDefHelper(newVM);
+	extend(ChildCtor, modelDefFn) {
+		const newVMR = this.#clone(ChildCtor);
+		const helper = new AttributeDefHelper(newVMR);
 		const defResult = modelDefFn(helper);
 		helper["~assignActions"](defResult);
-		return newVM;
+		return newVMR;
 	}
 };
+const runtimeViewModelSlot = Symbol("runtimeViewModel");
+function isViewModel(value) {
+	return typeof value === "function" && runtimeViewModelSlot in value;
+}
+function createViewModel(vmr) {
+	class ViewModelDescriptor {
+		static [runtimeViewModelSlot] = vmr;
+		constructor() {
+			const name = new.target.name;
+			throw new Error(`ViewModel cannot be constructed. Use static method instead: \`${name}.parse\`, \`${name}.extend\` etc.`);
+		}
+		static parse(view, ...args) {
+			return vmr.parse(view, ...args);
+		}
+		static bind(...args) {
+			if (args.length === 0) return this;
+			return createViewModel(vmr.bind(...args));
+		}
+		static narrow(_newMeta) {
+			return this;
+		}
+		static extend(Ctor, modelDefFn) {
+			return createViewModel(vmr.extend(Ctor, modelDefFn));
+		}
+	}
+	return ViewModelDescriptor;
+}
 var AttributeDefHelper = class AttributeDefHelper {
-	#viewModel;
-	constructor(viewModel) {
-		this.#viewModel = viewModel;
+	#vmr;
+	constructor(vmr) {
+		this.#vmr = vmr;
 	}
 	static #lazyActionSlot = Symbol("actionSlot");
 	static #lazyBinderSlot = Symbol("binderSlot");
@@ -104,9 +128,9 @@ var AttributeDefHelper = class AttributeDefHelper {
 				continue;
 			}
 			const actionDescriptor = Object.getOwnPropertyDescriptor(value, AttributeDefHelper.#lazyActionSlot);
-			if (actionDescriptor) this.#viewModel["~setActionOrBinder"]("action", name, actionDescriptor.value);
+			if (actionDescriptor) this.#vmr.setActionOrBinder("action", name, actionDescriptor.value);
 			const binderDescriptor = Object.getOwnPropertyDescriptor(value, AttributeDefHelper.#lazyBinderSlot);
-			if (binderDescriptor) this.#viewModel["~setActionOrBinder"]("binder", name, binderDescriptor.value);
+			if (binderDescriptor) this.#vmr.setActionOrBinder("binder", name, binderDescriptor.value);
 		}
 	}
 	attribute(action, binder) {
@@ -117,13 +141,13 @@ var AttributeDefHelper = class AttributeDefHelper {
 			enumerable: true
 		});
 		let lazyBinder;
-		if (typeof binder === "function") lazyBinder = (model, positionals, named) => binder(model, positionals(), named);
-		else if (binder) {
+		if (isViewModel(binder)) {
 			const vm = binder;
 			lazyBinder = (model, positionals, named) => {
 				return vm.parse(named);
 			};
-		} else lazyBinder = () => {};
+		} else if (typeof binder === "function") lazyBinder = (model, positionals, named) => binder(model, positionals(), named);
+		else lazyBinder = () => {};
 		Object.defineProperty(returnValue, AttributeDefHelper.#lazyBinderSlot, {
 			value: lazyBinder,
 			enumerable: true
@@ -140,11 +164,14 @@ var AttributeDefHelper = class AttributeDefHelper {
 	}
 };
 function defineViewModel(Ctor, modelDefFn, initMeta) {
-	const vm = new ViewModel(Ctor);
-	const helper = new AttributeDefHelper(vm);
+	const vmr = new ViewModelRuntime(Ctor);
+	const helper = new AttributeDefHelper(vmr);
 	const defResult = modelDefFn(helper);
 	helper["~assignActions"](defResult);
-	return vm;
+	return createViewModel(vmr);
+}
+function extendViewModel(baseViewModel, Ctor, modelDefFn) {
+	return baseViewModel.extend(Ctor, modelDefFn);
 }
 //#endregion
 //#region src/simple_view_model.ts
@@ -166,8 +193,8 @@ function extractObjectSchema(propSchema) {
 }
 function createSimpleViewModelFromJsonSchema(jsonSchema, options) {
 	const Ctor = class SimpleViewModel {};
-	const vm = new ViewModel(Ctor);
-	const helper = new AttributeDefHelper(vm);
+	const vmr = new ViewModelRuntime(Ctor);
+	const helper = new AttributeDefHelper(vmr);
 	const defResult = {};
 	for (const key of Object.keys(jsonSchema.properties ?? {})) {
 		const propSchema = jsonSchema.properties[key];
@@ -175,13 +202,14 @@ function createSimpleViewModelFromJsonSchema(jsonSchema, options) {
 		defResult[key] = registerAttribute(helper, key, propSchema, options);
 	}
 	helper["~assignActions"](defResult);
-	Object.defineProperty(vm, "Model", {
+	const ViewModel = createViewModel(vmr);
+	Object.defineProperty(ViewModel, "Model", {
 		value: Ctor,
 		writable: false,
 		enumerable: true,
 		configurable: true
 	});
-	return vm;
+	return ViewModel;
 }
 function registerAttribute(helper, key, propSchema, options) {
 	let objectSchema = null;
@@ -208,4 +236,4 @@ function defineSimpleViewModel(schema, options) {
 	return createSimpleViewModelFromJsonSchema(schema["~standard"].jsonSchema.input({ target: "draft-2020-12" }), resolvedOptions);
 }
 //#endregion
-export { createBinding, createDefine, defineSimpleViewModel, defineViewModel, getCurrentContext };
+export { createBinding, createDefine, defineSimpleViewModel, defineViewModel, extendViewModel, getCurrentContext };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gi-tcg/gts-runtime",
-  "version": "0.6.8",
+  "version": "0.7.1",
   "repository": {
     "type": "git",
     "url": "https://github.com/piovium/gts.git"

package/src/attribute_return.ts

@@ -1,7 +1,7 @@
 import type {
   AttributeBlockDefinition,
   BlockDefinitionRewriteMeta,
-  IViewModel,
+  IViewModelInstance,
 } from "./view_model.ts";
 
 export type Computed<T, Constraint = any> = T extends Constraint
@@ -28,10 +28,13 @@ export namespace AttributeReturn {
   };
 
   export type With<
-    VM extends IViewModel<any, any, any>,
-    TMeta = VM["~namedDefinition"]["~meta"],
+    VMI extends IViewModelInstance,
+    TMeta = VMI["~viewModel"]["~namedDefinition"]["~meta"],
   > = {
-    namedDefinition: BlockDefinitionRewriteMeta<VM["~namedDefinition"], TMeta>;
+    namedDefinition: BlockDefinitionRewriteMeta<
+      VMI["~viewModel"]["~namedDefinition"],
+      TMeta
+    >;
   };
 
   export type DoneRewriteMeta<NewMeta> = {
@@ -41,10 +44,13 @@ export namespace AttributeReturn {
 
   export type WithRewriteMeta<
     NewMeta,
-    VM extends IViewModel<any, any, any>,
-    TMeta = VM["~namedDefinition"]["~meta"],
+    VMI extends IViewModelInstance,
+    TMeta = VMI["~viewModel"]["~namedDefinition"]["~meta"],
   > = {
-    namedDefinition: BlockDefinitionRewriteMeta<VM["~namedDefinition"], TMeta>;
+    namedDefinition: BlockDefinitionRewriteMeta<
+      VMI["~viewModel"]["~namedDefinition"],
+      TMeta
+    >;
     rewriteMeta: NewMeta;
   };
 }

package/src/index.ts

@@ -1,18 +1,22 @@
 export {
   defineViewModel,
+  extendViewModel,
   getCurrentContext,
   type AttributeDefinition,
   type IViewModel,
+  type IViewModelInstance,
+  type IReboundViewModel,
+  type INarrowedViewModel,
+  type IExtendedViewModel,
   type SimpleAttributeOptions,
   type AttributeBlockDefinition,
 } from "./view_model.ts";
 export {
   defineSimpleViewModel,
-  type SimpleViewModel,
+  type ISimpleViewModel,
   type SimpleViewModelOptions,
 } from "./simple_view_model.ts";
 export type { AttributeReturn, AR } from "./attribute_return.ts";
-export type { Action, Meta, NamedDefinition } from "./symbols.ts";
 
 export {
   createBinding,

package/src/simple_view_model.ts

@@ -1,9 +1,10 @@
 import type { StandardJSONSchemaV1 } from "@standard-schema/spec";
 import {
   AttributeDefHelper,
-  ViewModel,
+  createViewModel,
   type IViewModel,
-  type AttributeAction,
+  type IViewModelInstance,
+  ViewModelRuntime,
 } from "./view_model.ts";
 import type { AttributeReturn } from "./attribute_return.ts";
 import { Ajv2020 } from "ajv/dist/2020.js";
@@ -39,7 +40,9 @@ type SimpleViewModelAttribute<
 } & IfAll<
   [Options["recursive"], IsSingleton<ExtractObject<ValueT>>],
   {
-    (): AttributeReturn.With<SimpleViewModel<ExtractObject<ValueT>, Options>>;
+    (): AttributeReturn.With<
+      IViewModelInstance<ISimpleViewModel<ExtractObject<ValueT>, Options>>
+    >;
   },
   IfAll<
     [Options["booleanSwitch"], true extends ValueT ? true : false],
@@ -48,7 +51,7 @@ type SimpleViewModelAttribute<
   >
 >;
 
-export interface SimpleViewModel<
+export interface ISimpleViewModel<
   T,
   Options extends SimpleViewModelOptions = {},
 > extends IViewModel<
@@ -59,7 +62,7 @@ export interface SimpleViewModel<
       required(): {} extends Pick<T, K> ? false : true;
     };
   } & {
-    "~meta": undefined;
+    "~meta": unknown;
   },
   []
 > {
@@ -97,10 +100,10 @@ function extractObjectSchema(
 function createSimpleViewModelFromJsonSchema(
   jsonSchema: Record<string, unknown>,
   options: SimpleViewModelOptions,
-): SimpleViewModel<any, any> {
+): ISimpleViewModel<any, any> {
   const Ctor = class SimpleViewModel {};
-  const vm = new ViewModel<any, any, []>(Ctor);
-  const helper = new AttributeDefHelper(vm);
+  const vmr = new ViewModelRuntime(Ctor);
+  const helper = new AttributeDefHelper(vmr);
   const defResult: Record<string, any> = {};
   for (const key of Object.keys(jsonSchema.properties ?? {})) {
     const propSchema = (jsonSchema.properties as Record<string, unknown>)[key];
@@ -115,13 +118,14 @@ function createSimpleViewModelFromJsonSchema(
     );
   }
   helper["~assignActions"](defResult);
-  Object.defineProperty(vm, "Model", {
+  const ViewModel = createViewModel(vmr);
+  Object.defineProperty(ViewModel, "Model", {
     value: Ctor,
     writable: false,
     enumerable: true,
     configurable: true,
   });
-  return vm as any;
+  return ViewModel as ISimpleViewModel<any, any>;
 }
 
 function registerAttribute(
@@ -162,7 +166,7 @@ export function defineSimpleViewModel<
 >(
   schema: T,
   options?: Options,
-): SimpleViewModel<StandardJSONSchemaV1.InferInput<T>, Options> {
+): ISimpleViewModel<StandardJSONSchemaV1.InferInput<T>, Options> {
   const resolvedOptions: SimpleViewModelOptions = {
     booleanSwitch: false,
     recursive: false,
@@ -174,5 +178,5 @@ export function defineSimpleViewModel<
   return createSimpleViewModelFromJsonSchema(
     jsonSchema,
     resolvedOptions,
-  ) as SimpleViewModel<StandardJSONSchemaV1.InferInput<T>, Options>;
+  ) as ISimpleViewModel<StandardJSONSchemaV1.InferInput<T>, Options>;
 }

package/src/view_model.ts

@@ -3,64 +3,115 @@ import type {
   AttributeReturn,
   Computed,
 } from "./attribute_return.ts";
-import type { Action, Meta } from "./symbols.ts";
 import { View } from "./view.ts";
 
 export interface AttributeBlockDefinition {
   "~meta": any;
 }
 
+export interface PartialAttributeBlockDefinition extends Partial<
+  Record<string, AttributeDefinition>
+> {}
+
 export type BlockDefinitionRewriteMeta<
   BlockDef extends AttributeBlockDefinition,
   NewMeta,
 > = Computed<
-  Omit<BlockDef, Meta> & { "~meta": NewMeta },
+  Omit<BlockDef, "~meta"> & { "~meta": NewMeta },
   AttributeBlockDefinition
 >;
 
+export interface IViewModelInstance<
+  T extends IViewModel<any, any, any> = IViewModel<any, any, any>,
+> {
+  "~viewModel": T;
+}
+
+export type DeferredIViewModel<T> =
+  T extends IViewModel<any, any, any> ? T : never;
+
+export interface IReboundViewModel<
+  BaseViewModel extends IViewModel<any, any, any>,
+  NewCtorArgs extends any[],
+> extends DeferredIViewModel<
+  IViewModel<
+    BaseViewModel["~modelType"],
+    BaseViewModel["~namedDefinition"],
+    NewCtorArgs
+  >
+> {}
+export interface INarrowedViewModel<
+  BaseViewModel extends IViewModel<any, any, any>,
+  NewMeta extends BaseViewModel["~namedDefinition"]["~meta"],
+> extends DeferredIViewModel<
+  IViewModel<
+    BaseViewModel["~modelType"],
+    BlockDefinitionRewriteMeta<BaseViewModel["~namedDefinition"], NewMeta>,
+    BaseViewModel["~ctorArgs"]
+  >
+> {}
+
+export interface IExtendedViewModel<
+  BaseViewModel extends IViewModel<any, any, any>,
+  ChildModelT extends BaseViewModel["~modelType"],
+  ChildBlockDef extends PartialAttributeBlockDefinition,
+  ChildCtorArgs extends any[],
+> extends DeferredIViewModel<
+  IViewModel<
+    ChildModelT,
+    Computed<
+      Omit<BaseViewModel["~namedDefinition"], keyof ChildBlockDef> &
+        ChildBlockDef & { "~meta": BaseViewModel["~namedDefinition"]["~meta"] }
+    >,
+    ChildCtorArgs
+  >
+> {}
+
 export interface IViewModel<
   ModelT,
   BlockDef extends AttributeBlockDefinition,
   CtorArgs extends any[],
 > {
+  "~modelType": ModelT;
+  "~ctorArgs": CtorArgs;
+  "~namedDefinition": BlockDef;
+  new (): IViewModelInstance<this>;
+  "~viewModel": this;
   parse(
     view: View<BlockDefinitionRewriteMeta<BlockDef, unknown>>,
     ...args: CtorArgs
   ): ModelT;
   /**
    * Creates a new ViewModel with the same actions and binders, but with
-   * - a different constructor that accepts the specified arguments, and/or
-   * - a different initial Meta.
+   * a different constructor that accepts the specified arguments.
    *
    * This is useful for creating binding ViewModels directly that forwards
    * the binding logic to inner ViewModels.
    */
-  bind<NewMeta = BlockDef[Meta]>(): IViewModel<
-    ModelT,
-    BlockDefinitionRewriteMeta<BlockDef, NewMeta>,
-    CtorArgs
-  >;
-  bind<NewMeta = BlockDef[Meta]>(
+  bind<This extends IViewModel<any, any, any>>(
+    this: This,
     ...args: CtorArgs
-  ): IViewModel<ModelT, BlockDefinitionRewriteMeta<BlockDef, NewMeta>, []>;
+  ): IReboundViewModel<This, []>;
+
+  /**
+   * Rewrite the initial meta.
+   * @param newMeta 
+   */
+  narrow<This extends IViewModel<any, any, any>, const NewMeta extends This["~namedDefinition"]["~meta"]>(
+    this: This,
+    newMeta: NewMeta,
+  ): INarrowedViewModel<This, NewMeta>;
+  
   extend<
+    This extends IViewModel<any, any, any>,
     ChildT extends ModelT,
-    const ChildBlockDef extends Partial<
-      Record<string | Action, AttributeDefinition>
-    >,
+    const ChildBlockDef extends PartialAttributeBlockDefinition,
     ChildCtorArgs extends any[] = [],
   >(
+    this: This,
     Ctor: new (...args: ChildCtorArgs) => ChildT,
     modelDefFn: (helper: AttributeDefHelper<ChildT>) => ChildBlockDef,
-  ): IViewModel<
-    ChildT,
-    Computed<
-      Omit<BlockDef, keyof ChildBlockDef> &
-        ChildBlockDef & { "~meta": BlockDef[Meta] }
-    >,
-    ChildCtorArgs
-  >;
-  "~namedDefinition": BlockDef;
+  ): IExtendedViewModel<This, ChildT, ChildBlockDef, ChildCtorArgs>;
 }
 
 type LazyAttributeActionOrBinder<ModelT> = (
@@ -74,28 +125,19 @@ export function getCurrentContext(): "action" | "binder" | null {
   return currentContext;
 }
 
-export class ViewModel<
-  ModelT,
-  BlockDef extends AttributeBlockDefinition,
-  CtorArgs extends any[],
-> implements IViewModel<ModelT, BlockDef, CtorArgs> {
-  declare "~namedDefinition": BlockDef;
-
-  #registeredActions: Map<PropertyKey, LazyAttributeActionOrBinder<ModelT>> =
-    new Map();
-  #registeredBinders: Map<PropertyKey, LazyAttributeActionOrBinder<ModelT>> =
-    new Map();
+export class ViewModelRuntime {
+  #registeredActions = new Map<PropertyKey, LazyAttributeActionOrBinder<any>>();
+  #registeredBinders = new Map<PropertyKey, LazyAttributeActionOrBinder<any>>();
+  #Ctor: new (...args: any[]) => any;
 
-  #Ctor: new (...args: CtorArgs) => ModelT;
-
-  constructor(Ctor: new (...args: CtorArgs) => ModelT) {
+  constructor(Ctor: new (...args: any[]) => any) {
     this.#Ctor = Ctor;
   }
 
-  "~setActionOrBinder"(
+  setActionOrBinder(
     context: "action" | "binder",
     name: PropertyKey,
-    action: LazyAttributeActionOrBinder<ModelT>,
+    action: LazyAttributeActionOrBinder<any>,
   ): void {
     if (context === "action") {
       this.#registeredActions.set(name, action);
@@ -104,10 +146,7 @@ export class ViewModel<
     }
   }
 
-  parse(
-    view: View<BlockDefinitionRewriteMeta<BlockDef, unknown>>,
-    ...args: CtorArgs
-  ): ModelT {
+  parse(view: View<any>, ...args: any[]): any {
     currentContext = view._bindingCtx ? "binder" : "action";
     const model = new this.#Ctor(...args);
     for (const attrNode of view._node.attributes) {
@@ -133,65 +172,87 @@ export class ViewModel<
     return model;
   }
 
-  #clone() {
-    const newVM = new ViewModel(this.#Ctor);
-    newVM.#registeredActions = new Map(this.#registeredActions);
-    newVM.#registeredBinders = new Map(this.#registeredBinders);
-    return newVM;
+  #clone(Ctor = this.#Ctor): ViewModelRuntime {
+    const newVMR = new ViewModelRuntime(Ctor);
+    newVMR.#registeredActions = new Map(this.#registeredActions);
+    newVMR.#registeredBinders = new Map(this.#registeredBinders);
+    return newVMR;
   }
 
-  bind<NewMeta = BlockDef[Meta]>(): IViewModel<
-    ModelT,
-    BlockDefinitionRewriteMeta<BlockDef, NewMeta>,
-    CtorArgs
-  >;
-  bind<NewMeta = BlockDef[Meta]>(
-    ...args: CtorArgs
-  ): IViewModel<ModelT, BlockDefinitionRewriteMeta<BlockDef, NewMeta>, []>;
-  bind<NewMeta = BlockDef[Meta]>(
-    ...args: any[]
-  ): IViewModel<ModelT, BlockDefinitionRewriteMeta<BlockDef, NewMeta>, any> {
-    if (args.length === 0) {
-      return this as any;
-    }
-    const newModel = this.#clone() as ViewModel<any, any, any>;
-    newModel.#Ctor = class extends (this.#Ctor as new (...args: any[]) => any) {
+  bind(...args: any[]): ViewModelRuntime {
+    const ParentCtor = this.#Ctor;
+    class ReboundCtor extends ParentCtor {
       constructor() {
         super(...args);
       }
-    };
-    return newModel as IViewModel<any, any, any>;
+    }
+    return this.#clone(ReboundCtor);
   }
 
-  extend<
-    ChildT extends ModelT,
-    const ChildBlockDef extends Partial<
-      Record<string | Action, AttributeDefinition>
-    >,
-    ChildCtorArgs extends any[] = [],
-  >(
-    Ctor: new (...args: ChildCtorArgs) => ChildT,
-    modelDefFn: (helper: AttributeDefHelper<ChildT>) => ChildBlockDef,
-  ): IViewModel<
-    ChildT,
-    Computed<
-      Omit<BlockDef, keyof ChildBlockDef> &
-        ChildBlockDef & { "~meta": BlockDef[Meta] }
-    >,
-    ChildCtorArgs
-  > {
-    const newVM = new ViewModel<ChildT, any, ChildCtorArgs>(Ctor);
-    for (const [name, action] of this.#registeredActions) {
-      newVM["~setActionOrBinder"]("action", name, action as any);
-    }
-    for (const [name, binder] of this.#registeredBinders) {
-      newVM["~setActionOrBinder"]("binder", name, binder as any);
-    }
-    const helper = new AttributeDefHelper(newVM);
+  extend(
+    ChildCtor: new (...args: any[]) => any,
+    modelDefFn: (helper: AttributeDefHelper<any>) => any,
+  ): ViewModelRuntime {
+    const newVMR = this.#clone(ChildCtor);
+    const helper = new AttributeDefHelper(newVMR);
     const defResult = modelDefFn(helper);
     helper["~assignActions"](defResult);
-    return newVM as any;
+    return newVMR;
+  }
+}
+
+const runtimeViewModelSlot: unique symbol = Symbol("runtimeViewModel");
+
+function isViewModel(value: unknown): value is IViewModel<any, any, any> {
+  return typeof value === "function" && runtimeViewModelSlot in value;
+}
+
+export function createViewModel<
+  ModelT,
+  BlockDef extends AttributeBlockDefinition,
+  CtorArgs extends any[],
+>(vmr: ViewModelRuntime): IViewModel<ModelT, BlockDef, CtorArgs> {
+  class ViewModelDescriptor implements IViewModelInstance {
+    declare static "~modelType": ModelT;
+    declare static "~ctorArgs": CtorArgs;
+    declare static "~namedDefinition": BlockDef;
+
+    static readonly [runtimeViewModelSlot] = vmr;
+
+    constructor() {
+      const name = new.target.name;
+      throw new Error(
+        `ViewModel cannot be constructed. Use static method instead: \`${name}.parse\`, \`${name}.extend\` etc.`,
+      );
+    }
+
+    static parse(view: View<any>, ...args: CtorArgs): ModelT {
+      return vmr.parse(view, ...args);
+    }
+
+    static bind(...args: any[]): IViewModel<any, any, any> {
+      if (args.length === 0) {
+        return this;
+      }
+      return createViewModel(vmr.bind(...args));
+    }
+
+    static narrow(_newMeta: any): IViewModel<any, any, any> {
+      return this;
+    }
+
+    static extend(
+      Ctor: new (...args: any[]) => any,
+      modelDefFn: (helper: AttributeDefHelper<any>) => any,
+    ): IViewModel<any, any, any> {
+      return createViewModel(vmr.extend(Ctor, modelDefFn));
+    }
+
+    declare "~viewModel": typeof ViewModelDescriptor;
+    declare static "~viewModel": typeof ViewModelDescriptor;
   }
+
+  return ViewModelDescriptor as IViewModel<ModelT, BlockDef, CtorArgs>;
 }
 
 export interface SimpleAttributeOptions {
@@ -206,9 +267,9 @@ type WithSimpleOptions<Base, Options extends SimpleAttributeOptions> = Base &
     : {});
 
 export class AttributeDefHelper<ModelT> {
-  #viewModel: ViewModel<ModelT, any, any>;
-  constructor(viewModel: ViewModel<ModelT, any, any>) {
-    this.#viewModel = viewModel;
+  #vmr: ViewModelRuntime;
+  constructor(vmr: ViewModelRuntime) {
+    this.#vmr = vmr;
   }
 
   static readonly #lazyActionSlot: unique symbol = Symbol("actionSlot");
@@ -228,22 +289,14 @@ export class AttributeDefHelper<ModelT> {
         AttributeDefHelper.#lazyActionSlot,
       );
       if (actionDescriptor) {
-        this.#viewModel["~setActionOrBinder"](
-          "action",
-          name,
-          actionDescriptor.value,
-        );
+        this.#vmr.setActionOrBinder("action", name, actionDescriptor.value);
       }
       const binderDescriptor = Object.getOwnPropertyDescriptor(
         value,
         AttributeDefHelper.#lazyBinderSlot,
       );
       if (binderDescriptor) {
-        this.#viewModel["~setActionOrBinder"](
-          "binder",
-          name,
-          binderDescriptor.value,
-        );
+        this.#vmr.setActionOrBinder("binder", name, binderDescriptor.value);
       }
     }
   }
@@ -273,14 +326,14 @@ export class AttributeDefHelper<ModelT> {
       enumerable: true,
     });
     let lazyBinder: LazyAttributeActionOrBinder<ModelT>;
-    if (typeof binder === "function") {
-      lazyBinder = (model, positionals, named) =>
-        binder(model, positionals(), named);
-    } else if (binder) {
+    if (isViewModel(binder)) {
       const vm = binder;
       lazyBinder = (model, positionals, named) => {
         return vm.parse(named);
       };
+    } else if (typeof binder === "function") {
+      lazyBinder = (model, positionals, named) =>
+        binder(model, positionals(), named);
     } else {
       lazyBinder = () => {};
     }
@@ -332,19 +385,37 @@ export class AttributeDefHelper<ModelT> {
 
 export function defineViewModel<
   T,
-  const BlockDef extends Partial<Record<string | Action, AttributeDefinition>>,
+  const BlockDef extends PartialAttributeBlockDefinition,
   CtorArgs extends any[] = [],
-  InitMeta = void,
+  InitMeta = unknown,
 >(
   Ctor: new (...args: CtorArgs) => T,
   modelDefFn: (helper: AttributeDefHelper<T>) => BlockDef,
   initMeta?: InitMeta,
 ): IViewModel<T, BlockDef & { "~meta": InitMeta }, CtorArgs> {
-  const vm = new ViewModel<T, BlockDef & { "~meta": InitMeta }, CtorArgs>(Ctor);
-  const helper = new AttributeDefHelper(vm);
+  const vmr = new ViewModelRuntime(Ctor);
+  const helper = new AttributeDefHelper<T>(vmr);
   const defResult = modelDefFn(helper);
   helper["~assignActions"](defResult);
-  return vm;
+  return createViewModel(vmr);
+}
+
+export function extendViewModel<
+  BaseViewModel extends IViewModel<any, any, any>,
+  ChildModelT extends BaseViewModel["~modelType"],
+  const ChildBlockDef extends PartialAttributeBlockDefinition,
+  ChildCtorArgs extends any[] = [],
+>(
+  baseViewModel: BaseViewModel,
+  Ctor: new (...args: ChildCtorArgs) => ChildModelT,
+  modelDefFn: (helper: AttributeDefHelper<ChildModelT>) => ChildBlockDef,
+): IExtendedViewModel<
+  BaseViewModel,
+  ChildModelT,
+  ChildBlockDef,
+  ChildCtorArgs
+> {
+  return baseViewModel.extend(Ctor, modelDefFn);
 }
 
 export interface AttributeDefinition {

package/src/symbols.ts

@@ -1,3 +0,0 @@
-export type Meta = "~meta";
-export type Action = "~action";
-export type NamedDefinition = "~namedDefinition";