Repository: Jaseci-Labs/jaseci (language: python)

Issue:
{BUG) Fix for input information issue in MTLLM
## **Description**



Discussion / hints:

Fix patch:
diff --git a/README.md b/README.md
index 852c429b81..320ef0d4bf 100644
--- a/README.md
+++ b/README.md
@@ -18,15 +18,19 @@
 
 </div>
 
-Welcome to the Jaseci project. 
+Welcome to the Jaseci project.
 
 This is a collection of libraries and frameworks in the Jaseci Ecosystem.
 
-* [`jaclang`](jac/): The Jac programming language, a drop-in replacement for and supersets Python.
-* [`mtllm`](jac-mtllm/): Integrate LLM into your existing application with minimal effort.
-* [`jac-cloud`](jac-cloud/): The cloud-native library for Jac programs. `jac-cloud` automatically converts your local application to a production-ready server stack.
-* [`jac-streamlit`](tool_plugins/streamlit): Quickly build UI with Jac and Streamlit.
-* [`jac VSCE`](jac/support/vscode_ext): Official VSCode Extension for the Jac programming language.
+- [`jaclang`](jac/): The Jac programming language, a drop-in replacement for and supersets Python.
+- [`mtllm`](jac-mtllm/): Integrate LLM into your existing application with minimal effort.
+- [`jac-cloud`](jac-cloud/): The cloud-native library for Jac programs. `jac-cloud` automatically converts your local application to a production-ready server stack.
+- [`jac-streamlit`](tool_plugins/streamlit): Quickly build UI with Jac and Streamlit.
+- [`jac VSCE`](jac/support/vscode_ext): Official VSCode Extension for the Jac programming language.
+
+## Showcase Projects
+ - [`Visit_Zoo`](https://github.com/Thamirawaran/Visit_Zoo): An interactive zoo simulation where players explore various zoo sections through clickable buttons, images, and videos.
+ - [`littleX`](https://github.com/Thamirawaran/littleX): A minimalistic social media platform prototype developed using the Jac programming language.
 
 ## Contributing
 
@@ -34,7 +38,7 @@ See [CONTRIBUTING.md](.github/CONTRIBUTING.md).
 
 ## License
 
-Jaclang is distributed under the terms of both the MIT license with a few other open source projects vendored
+All Jaseci open source software is distributed under the terms of both the MIT license with a few other open source projects vendored
 within with various other licenses that are very permissive.
 
 See [LICENSE-MIT](.guthub/LICENSE), and
@@ -42,12 +46,13 @@ See [LICENSE-MIT](.guthub/LICENSE), and
 
 ## Trademark
 
-[Jaseci][jaseci] owns and protects the Jaclang trademarks and logos (the "Jaclang Trademarks").
+[Jaseci Labs, LLC][jaseci] owns and protects the Jaseci and Jac trademarks and logos.
+If you would like to use these names or brands, please reach out for approval.
+
+[jaseci]: https://jaseci.org/
 
-If you want to use these names or brands, please read the [media guide][media-guide].
+## University of Michigan Disclosure
 
-Third-party logos may be subject to third-party copyrights and trademarks. See [Licenses][policies-licenses] for details.
+The Jaseci open-source software (OSS) is maintained by [Jaseci Labs, LLC][jaseci] for which the following University of Michigan employees have either an ownership or advisory interest in Jaseci Labs, LLC: Prof. Jason Mars, Prof. Lingjia Tang, and Dr. Yiping Kang.
 
 [jaseci]: https://jaseci.org/
-[media-guide]: https://jaseci.org/policies/logo-policy-and-media-guide/
-[policies-licenses]: https://www.jaseci.org/policies/licenses
diff --git a/jac-cloud/jac_cloud/core/architype.py b/jac-cloud/jac_cloud/core/architype.py
index 062f50e539..7e42adbe82 100644
--- a/jac-cloud/jac_cloud/core/architype.py
+++ b/jac-cloud/jac_cloud/core/architype.py
@@ -387,15 +387,15 @@ def _pull(self) -> dict:
     def add_to_set(self, field: str, anchor: Anchor, remove: bool = False) -> None:
         """Add to set."""
         if field not in (add_to_set := self._add_to_set):
-            add_to_set[field] = {"$each": set()}
+            add_to_set[field] = {"$each": []}
 
-        ops: set = add_to_set[field]["$each"]
+        ops: list = add_to_set[field]["$each"]
 
         if remove:
             if anchor in ops:
                 ops.remove(anchor)
         else:
-            ops.add(anchor)
+            ops.append(anchor)
             self.pull(field, anchor, True)
 
     def pull(self, field: str, anchor: Anchor, remove: bool = False) -> None:
@@ -432,9 +432,10 @@ def make_stub(self: "BaseAnchor | TANCH") -> "BaseAnchor | TANCH":
         """Return unsynced copy of anchor."""
         if self.is_populated():
             unloaded = object.__new__(self.__class__)
-            unloaded.name = self.name
-            unloaded.id = self.id
-            return unloaded
+            # this will be refactored on abstraction
+            unloaded.name = self.name  # type: ignore[attr-defined]
+            unloaded.id = self.id  # type: ignore[attr-defined]
+            return unloaded  # type: ignore[return-value]
         return self
 
     def populate(self) -> None:
@@ -535,7 +536,7 @@ def update(self, bulk_write: BulkWrite, propagate: bool = False) -> None:
                 _added_edges = []
                 for anchor in added_edges:
                     if propagate:
-                        anchor.build_query(bulk_write)
+                        anchor.build_query(bulk_write)  # type: ignore[operator]
                     _added_edges.append(anchor.ref_id)
                 changes["$addToSet"]["edges"]["$each"] = _added_edges
             else:
@@ -552,9 +553,10 @@ def update(self, bulk_write: BulkWrite, propagate: bool = False) -> None:
             if pulled_edges:
                 _pulled_edges = []
                 for anchor in pulled_edges:
-                    if propagate and anchor.state.deleted is not True:
-                        anchor.state.deleted = True
-                        bulk_write.del_edge(anchor.id)
+                    # will be refactored on abstraction
+                    if propagate and anchor.state.deleted is not True:  # type: ignore[attr-defined]
+                        anchor.state.deleted = True  # type: ignore[attr-defined]
+                        bulk_write.del_edge(anchor.id)  # type: ignore[attr-defined, arg-type]
                     _pulled_edges.append(anchor.ref_id)
 
                 if added_edges:
@@ -592,7 +594,7 @@ def sync_hash(self) -> None:
             architype, type
         ):
             self.state.context_hashes = {
-                key: hash(dumps(val))
+                key: hash(val if isinstance(val, bytes) else dumps(val))
                 for key, val in architype.__serialize__().items()  # type:ignore[attr-defined] # mypy issue
             }
             self.state.full_hash = hash(pdumps(self.serialize()))
@@ -643,7 +645,7 @@ class NodeAnchor(BaseAnchor, _NodeAnchor):  # type: ignore[misc]
     """Node Anchor."""
 
     architype: "NodeArchitype"
-    edges: list["EdgeAnchor"]
+    edges: list["EdgeAnchor"]  # type: ignore[assignment]
 
     class Collection(BaseCollection["NodeAnchor"]):
         """NodeAnchor collection interface."""
diff --git a/jac-cloud/jac_cloud/jaseci/__init__.py b/jac-cloud/jac_cloud/jaseci/__init__.py
index b5b8cb78a1..e862465353 100644
--- a/jac-cloud/jac_cloud/jaseci/__init__.py
+++ b/jac-cloud/jac_cloud/jaseci/__init__.py
@@ -6,6 +6,7 @@
 from typing import Any, AsyncGenerator
 
 from fastapi import FastAPI as _FaststAPI, Request
+from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import ORJSONResponse
 
 from uvicorn import run as _run
@@ -59,6 +60,14 @@ async def lifespan(app: _FaststAPI) -> AsyncGenerator[None, _FaststAPI]:
 
             cls.__app__ = _FaststAPI(lifespan=lifespan)
 
+            cls.__app__.add_middleware(
+                CORSMiddleware,
+                allow_origins=getenv("ALLOW_ORIGINS", "*").split(","),
+                allow_credentials=True,
+                allow_methods=getenv("ALLOW_METHODS", "*").split(","),
+                allow_headers=getenv("ALLOW_HEADERS", "*").split(","),
+            )
+
             populate_yaml_specs(cls.__app__)
 
             from .routers import healthz_router, sso_router, user_router
diff --git a/jac-cloud/jac_cloud/jaseci/datasources/__init__.py b/jac-cloud/jac_cloud/jaseci/datasources/__init__.py
index 424f107e23..b478df4ec9 100644
--- a/jac-cloud/jac_cloud/jaseci/datasources/__init__.py
+++ b/jac-cloud/jac_cloud/jaseci/datasources/__init__.py
@@ -1,11 +1,13 @@
 """Jaseci Datasources."""
 
 from .collection import Collection
+from .localdb import MontyClient
 from .redis import CodeRedis, Redis, TokenRedis
 
 
 __all__ = [
     "Collection",
+    "MontyClient",
     "CodeRedis",
     "Redis",
     "TokenRedis",
diff --git a/jac-cloud/jac_cloud/jaseci/datasources/collection.py b/jac-cloud/jac_cloud/jaseci/datasources/collection.py
index 5425268e39..e4b971b5d7 100644
--- a/jac-cloud/jac_cloud/jaseci/datasources/collection.py
+++ b/jac-cloud/jac_cloud/jaseci/datasources/collection.py
@@ -46,6 +46,9 @@
 )
 from pymongo.server_api import ServerApi
 
+from .localdb import MontyClient, set_storage
+from ..utils import logger
+
 T = TypeVar("T")
 
 
@@ -137,16 +140,23 @@ def __documents__(cls, docs: Cursor) -> Generator[T, None, None]:
     @staticmethod
     def get_client() -> MongoClient:
         """Return pymongo.database.Database for mongodb connection."""
-        if not isinstance(Collection.__client__, MongoClient):
-            Collection.__client__ = MongoClient(
-                getenv(
-                    "DATABASE_HOST",
-                    "mongodb://localhost/?retryWrites=true&w=majority",
-                ),
-                server_api=ServerApi("1"),
-            )
-
-        return Collection.__client__
+        if (client := Collection.__client__) is None:
+            if host := getenv("DATABASE_HOST"):
+                client = Collection.__client__ = MongoClient(
+                    host,
+                    server_api=ServerApi("1"),
+                )
+            else:
+                logger.info("DATABASE_HOST is not available! Using LocalDB...")
+                set_storage(
+                    repository="mydatabase",
+                    storage="sqlite",
+                    mongo_version="4.4",
+                    use_bson=True,
+                )
+                client = Collection.__client__ = MontyClient("mydatabase")
+
+        return client
 
     @staticmethod
     def get_session() -> ClientSession:
diff --git a/jac-cloud/jac_cloud/jaseci/datasources/localdb.py b/jac-cloud/jac_cloud/jaseci/datasources/localdb.py
new file mode 100644
index 0000000000..d60c9f88c3
--- /dev/null
+++ b/jac-cloud/jac_cloud/jaseci/datasources/localdb.py
@@ -0,0 +1,163 @@
+"""Monty Implementations."""
+
+from typing import Any
+
+from montydb import MontyClient as _MontyClient, set_storage  # type: ignore[import-untyped]
+from montydb.collection import MontyCollection as _MontyCollection  # type: ignore[import-untyped]
+from montydb.database import MontyDatabase as _MontyDatabase  # type: ignore[import-untyped]
+
+from pymongo import DeleteMany, DeleteOne, InsertOne, UpdateMany, UpdateOne
+from pymongo.cursor import Cursor
+from pymongo.results import BulkWriteResult, InsertManyResult, InsertOneResult
+
+
+class MontyClientSession:
+    """Monty Client Session."""
+
+    def start_transaction(self) -> "MontyClientSession":
+        """Start transaction."""
+        return self
+
+    def abort_transaction(self) -> None:
+        """Abort transaction."""
+
+    def commit_transaction(self) -> None:
+        """Commit transaction."""
+
+    def __enter__(self) -> "MontyClientSession":
+        """Enter execution."""
+        return self
+
+    def __exit__(
+        self, exc_type: Any, exc_val: Any, exc_tb: Any  # noqa: ANN401
+    ) -> None:
+        """Exit execution."""
+        pass
+
+
+class MontyCollection(_MontyCollection):
+    """Monty Collection."""
+
+    def __init__(self, col: _MontyCollection) -> None:
+        """Override Init."""
+        self.__dict__.update(col.__dict__)
+
+    def create_indexes(self, *args, **kwargs: Any) -> None:  # noqa: ANN401, ANN002
+        """Bypass Create Indexes."""
+        pass
+
+    def insert_one(
+        self, document: dict, session: MontyClientSession | None = None
+    ) -> InsertOneResult:
+        """Override insert_one."""
+        return super().insert_one(document)
+
+    def insert_many(
+        self,
+        documents: list[dict],
+        session: MontyClientSession | None = None,
+        **kwargs: Any,  # noqa: ANN401
+    ) -> InsertManyResult:
+        """Override insert_many."""
+        return super().insert_many(documents, **kwargs)
+
+    def find(
+        self,
+        filter: dict | None = None,
+        projection: dict | None = None,
+        session: MontyClientSession | None = None,
+        **kwargs: Any,  # noqa: ANN401
+    ) -> Cursor:
+        """Override find."""
+        return super().find(filter, **kwargs)
+
+    def find_one(
+        self,
+        filter: dict | None = None,
+        projection: dict | None = None,
+        session: MontyClientSession | None = None,
+        **kwargs: Any,  # noqa: ANN401
+    ) -> Any | None:
+        """Override find_one."""
+        return super().find_one(filter, **kwargs)
+
+    def count_documents(
+        self,
+        filter: dict,
+        session: MontyClientSession | None = None,
+        **kwargs: Any,  # noqa: ANN401
+    ) -> int:
+        """Override count_documents."""
+        return super().count_documents(filter, **kwargs)
+
+    def bulk_write(
+        self,
+        ops: list[InsertOne | DeleteMany | DeleteOne | UpdateMany | UpdateOne],
+        ordered: bool = True,
+        session: MontyClientSession | None = None,
+        **kwargs: Any,  # noqa: ANN401
+    ) -> BulkWriteResult:
+        """Bulk write operations."""
+        deleted_count = 0
+        inserted_count = 0
+        modified_count = 0
+
+        for op in ops:
+            match op:
+                case InsertOne():
+                    if self.insert_one(op._doc).inserted_id:
+                        inserted_count += 1
+                case DeleteMany():
+                    deleted_count += self.delete_many(op._filter).deleted_count
+                case DeleteOne():
+                    deleted_count += self.delete_one(op._filter).deleted_count
+                case UpdateMany():
+                    modified_count += self.update_many(
+                        op._filter, op._doc
+                    ).modified_count
+                case UpdateOne():
+                    modified_count += self.update_one(
+                        op._filter, op._doc
+                    ).modified_count
+                case _:
+                    pass
+
+        return BulkWriteResult(
+            {
+                "bulk_api_result": {},
+                "deleted_count": deleted_count,
+                "inserted_count": inserted_count,
+                "matched_count": deleted_count + modified_count,
+                "modified_count": modified_count,
+                "upserted_count": 0,
+                "upserted_ids": {},
+            },
+            True,
+        )
+
+
+class MontyDatabase(_MontyDatabase):
+    """Monty Database."""
+
+    def __init__(self, db: _MontyDatabase) -> None:
+        """Override Init."""
+        self.__dict__.update(db.__dict__)
+
+    def get_collection(self, name: str) -> MontyCollection:
+        """Get Collection."""
+        return MontyCollection(super().get_collection(name))  # noqa: B009
+
+
+class MontyClient(_MontyClient):
+    """Monty Client."""
+
+    def get_database(self, name: str) -> MontyDatabase:
+        """Get local database."""
+        return MontyDatabase(super().get_database(name))
+
+    def start_session(self) -> MontyClientSession:
+        """Start session."""
+        return MontyClientSession()
+
+
+__all__ = ["MontyClient", "set_storage"]
diff --git a/jac-cloud/jac_cloud/jaseci/datasources/redis.py b/jac-cloud/jac_cloud/jaseci/datasources/redis.py
index 52be816451..e8022cab27 100644
--- a/jac-cloud/jac_cloud/jaseci/datasources/redis.py
+++ b/jac-cloud/jac_cloud/jaseci/datasources/redis.py
@@ -46,6 +46,7 @@ def get_rd() -> _Redis:
                     password=getenv("REDIS_PASS"),
                 )
             else:
+                logger.info("REDIS_HOST is not available! Using FakeRedis...")
                 Redis.__redis__ = FakeRedis()
 
         return Redis.__redis__
diff --git a/jac-cloud/jac_cloud/jaseci/routers/user.py b/jac-cloud/jac_cloud/jaseci/routers/user.py
index 52fa23969f..2c69d4b360 100644
--- a/jac-cloud/jac_cloud/jaseci/routers/user.py
+++ b/jac-cloud/jac_cloud/jaseci/routers/user.py
@@ -25,7 +25,7 @@
     invalidate_token,
     verify_code,
 )
-from ..utils import Emailer, logger
+from ..utils import Emailer, log_entry, log_exit, logger
 from ...core.architype import BulkWrite, NodeAnchor, Root
 
 
@@ -38,7 +38,7 @@
 @router.post("/register", status_code=status.HTTP_200_OK)
 def register(req: User.register_type()) -> ORJSONResponse:  # type: ignore
     """Register user API."""
-    # log = log_entry("register", req.email, req.printable())
+    log = log_entry("register", req.email, req.printable())
 
     with User.Collection.get_session() as session, session.start_transaction():
         root = Root().__jac__
@@ -60,7 +60,7 @@ def register(req: User.register_type()) -> ORJSONResponse:  # type: ignore
                     if not is_activated:
                         User.send_verification_code(create_code(id), req.email)
                     resp = {"message": "Successfully Registered!"}
-                    # log_exit(resp, log)
+                    log_exit(resp, log)
                     return ORJSONResponse(resp, 201)
             except (ConnectionFailure, OperationFailure) as ex:
                 if ex.has_error_label("TransientTransactionError"):
@@ -79,7 +79,7 @@ def register(req: User.register_type()) -> ORJSONResponse:  # type: ignore
                 break
 
     resp = {"message": "Registration Failed!"}
-    # log_exit(resp, log)
+    log_exit(resp, log)
     return ORJSONResponse(resp, 409)
 
 
diff --git a/jac-cloud/jac_cloud/jaseci/utils/logger.py b/jac-cloud/jac_cloud/jaseci/utils/logger.py
index d37ec4bd17..82e10e36c3 100644
--- a/jac-cloud/jac_cloud/jaseci/utils/logger.py
+++ b/jac-cloud/jac_cloud/jaseci/utils/logger.py
@@ -4,7 +4,6 @@
 from enum import IntEnum
 from io import text_encoding
 from itertools import chain
-from json import JSONEncoder, dumps
 from logging import FileHandler, LogRecord, getLogger
 from logging.handlers import (
     BaseRotatingHandler,
@@ -17,28 +16,16 @@
 from re import ASCII, compile, escape
 from stat import ST_MTIME
 from time import gmtime, localtime, strftime, time as ttime
+from traceback import format_exc
 from typing import Any
 
 from ecs_logging import StdlibFormatter
 
+from orjson import JSONEncodeError, dumps
+
 from starlette.datastructures import UploadFile
 
 DEFAULT_PART = [0]
-DEFAULT_SEPARATORS = (",", ":")
-
-
-class LogEncoder(JSONEncoder):
-    """Custom Log Encoder."""
-
-    def default(self, data: object) -> object:
-        """Override default handler."""
-        if isinstance(data, UploadFile):
-            return {
-                "name": data.filename,
-                "content_type": data.content_type,
-                "size": data.size,
-            }
-        return super().default(data)
 
 
 class MixedTimedRotatingFileHandler(TimedRotatingFileHandler, RotatingFileHandler):
@@ -277,9 +264,36 @@ class Level(IntEnum):
 logger.addHandler(handler)
 
 
+def cls_fullname(obj: object) -> str:
+    """Get class full name."""
+    cls = obj.__class__
+    module = cls.__module__
+    if module == "__builtin__":
+        return cls.__name__
+    return module + "." + cls.__name__
+
+
+def serializer(data: object) -> object:
+    """Override default handler."""
+    match data:
+        case UploadFile():
+            return {
+                "name": data.filename,
+                "content_type": data.content_type,
+                "size": data.size,
+            }
+        case _:
+            raise JSONEncodeError(
+                f"Type is not JSON serializable: {cls_fullname(data)}"
+            )
+
+
 def log_dumps(payload: dict[str, Any] | list[Any]) -> str:
     """Dump dictionary log."""
-    return dumps(payload, separators=DEFAULT_SEPARATORS, cls=LogEncoder)
+    try:
+        return dumps(payload, default=serializer).decode()
+    except Exception:
+        return format_exc()
 
 
 def log_entry(
diff --git a/jac-cloud/jac_cloud/plugin/cli.py b/jac-cloud/jac_cloud/plugin/cli.py
index 3f67238866..b78efccc77 100644
--- a/jac-cloud/jac_cloud/plugin/cli.py
+++ b/jac-cloud/jac_cloud/plugin/cli.py
@@ -13,8 +13,7 @@
 
 from pymongo.errors import ConnectionFailure, OperationFailure
 
-from .mini.cli_mini import serve_mini
-from ..core.architype import BulkWrite
+from ..core.architype import BulkWrite, NodeAnchor
 from ..core.context import SUPER_ROOT_ID
 from ..jaseci.datasources import Collection
 from ..jaseci.models import User as BaseUser
@@ -31,10 +30,6 @@ def create_cmd() -> None:
 
         @cmd_registry.register
         def serve(filename: str, host: str = "0.0.0.0", port: int = 8000) -> None:
-            if not getenv("DATABASE_HOST"):
-                serve_mini(filename=filename, host=host, port=port)
-                return
-
             from jac_cloud import FastAPI
 
             """Serve the jac application."""
@@ -55,7 +50,7 @@ def serve(filename: str, host: str = "0.0.0.0", port: int = 8000) -> None:
             elif filename.endswith(".jir"):
                 with open(filename, "rb") as f:
                     JacMachine(base).attach_program(
-                        JacProgram(mod_bundle=load(f), bytecode=None)
+                        JacProgram(mod_bundle=load(f), bytecode=None, sem_ir=None)
                     )
                     jac_import(
                         target=mod,
@@ -96,7 +91,7 @@ def create_system_admin(
             elif filename.endswith(".jir"):
                 with open(filename, "rb") as f:
                     JacMachine(base).attach_program(
-                        JacProgram(mod_bundle=load(f), bytecode=None)
+                        JacProgram(mod_bundle=load(f), bytecode=None, sem_ir=None)
                     )
                     jac_import(
                         target=mod,
@@ -143,11 +138,29 @@ def create_system_admin(
                 max_retry = BulkWrite.SESSION_MAX_TRANSACTION_RETRY
                 while retry <= max_retry:
                     try:
+                        if not NodeAnchor.Collection.find_by_id(
+                            SUPER_ROOT_ID, session=session
+                        ):
+                            NodeAnchor.Collection.insert_one(
+                                {
+                                    "_id": SUPER_ROOT_ID,
+                                    "name": None,
+                                    "root": None,
+                                    "access": {
+                                        "all": "NO_ACCESS",
+                                        "roots": {"anchors": {}},
+                                    },
+                                    "architype": {},
+                                    "edges": [],
+                                },
+                                session=session,
+                            )
                         if id := (
                             user_model.Collection.insert_one(req_obf, session=session)
                         ).inserted_id:
                             BulkWrite.commit(session)
                             return f"System Admin created with id: {id}"
+                        session.abort_transaction()
                     except (ConnectionFailure, OperationFailure) as ex:
                         if ex.has_error_label("TransientTransactionError"):
                             retry += 1
diff --git a/jac-cloud/jac_cloud/plugin/jaseci.py b/jac-cloud/jac_cloud/plugin/jaseci.py
index b428b6cb8f..10734f2fc6 100644
--- a/jac-cloud/jac_cloud/plugin/jaseci.py
+++ b/jac-cloud/jac_cloud/plugin/jaseci.py
@@ -53,8 +53,7 @@
 from ..core.context import ContextResponse, ExecutionContext, JaseciContext
 from ..jaseci import FastAPI
 from ..jaseci.security import authenticator
-
-# from ..jaseci.utils import log_entry, log_exit
+from ..jaseci.utils import log_entry, log_exit
 
 
 T = TypeVar("T")
@@ -179,12 +178,12 @@ def api_entry(
             pl = cast(BaseModel, payload).model_dump()
             body = pl.get("body", {})
 
-            # log = log_entry(
-            #     cls.__name__,
-            #     user.email if (user := getattr(request, "_user", None)) else None,
-            #     pl,
-            #     node,
-            # )
+            log = log_entry(
+                cls.__name__,
+                user.email if (user := getattr(request, "_user", None)) else None,
+                pl,
+                node,
+            )
 
             if isinstance(body, BaseUploadFile) and body_model:
                 body = loads(syncify(body.read)())
@@ -204,7 +203,7 @@ def api_entry(
                     return jctx.custom
 
                 resp = jctx.response(wlk.returns)
-                # log_exit(resp, log)
+                log_exit(resp, log)
 
                 return ORJSONResponse(resp, jctx.status)
             else:
@@ -502,6 +501,37 @@ def get_context() -> ExecutionContext:
 
         return JaseciContext.get()
 
+    @staticmethod
+    @hookimpl
+    def reset_graph(root: Root | None = None) -> int:
+        """Purge current or target graph."""
+        if not FastAPI.is_enabled():
+            return JacFeatureImpl.reset_graph(root=root)  # type: ignore[arg-type]
+
+        ctx = JaseciContext.get()
+        ranchor = root.__jac__ if root else ctx.root
+
+        deleted_count = 0  # noqa: SIM113
+
+        for node in NodeAnchor.Collection.find(
+            {"_id": {"$ne": ranchor.id}, "root": ranchor.id}
+        ):
+            ctx.mem.__mem__[node.id] = node
+            Jac.destroy(node)
+            deleted_count += 1
+
+        for edge in EdgeAnchor.Collection.find({"root": ranchor.id}):
+            ctx.mem.__mem__[edge.id] = edge
+            Jac.destroy(edge)
+            deleted_count += 1
+
+        for walker in WalkerAnchor.Collection.find({"root": ranchor.id}):
+            ctx.mem.__mem__[walker.id] = walker
+            Jac.destroy(walker)
+            deleted_count += 1
+
+        return deleted_count
+
     @staticmethod
     @hookimpl
     def make_architype(
@@ -756,7 +786,8 @@ def spawn_call(op1: Architype, op2: Architype) -> WalkerArchitype:
         if walker.next:
             current_node = walker.next[-1].architype
             for i in warch._jac_entry_funcs_:
-                if not i.trigger:
+                trigger = i.get_funcparam_annotations(i.func)
+                if not trigger:
                     if i.func:
                         walker.returns.append(i.func(warch, current_node))
                     else:
@@ -764,7 +795,8 @@ def spawn_call(op1: Architype, op2: Architype) -> WalkerArchitype:
         while len(walker.next):
             if current_node := walker.next.pop(0).architype:
                 for i in current_node._jac_entry_funcs_:
-                    if not i.trigger or isinstance(walker, i.trigger):
+                    trigger = i.get_funcparam_annotations(i.func)
+                    if not trigger or isinstance(warch, trigger):
                         if i.func:
                             walker.returns.append(i.func(current_node, warch))
                         else:
@@ -772,27 +804,30 @@ def spawn_call(op1: Architype, op2: Architype) -> WalkerArchitype:
                     if walker.disengaged:
                         return warch
                 for i in warch._jac_entry_funcs_:
-                    if not i.trigger or isinstance(current_node, i.trigger):
-                        if i.func and i.trigger:
+                    trigger = i.get_funcparam_annotations(i.func)
+                    if not trigger or isinstance(current_node, trigger):
+                        if i.func and trigger:
                             walker.returns.append(i.func(warch, current_node))
-                        elif not i.trigger:
+                        elif not trigger:
                             continue
                         else:
                             raise ValueError(f"No function {i.name} to call.")
                     if walker.disengaged:
                         return warch
                 for i in warch._jac_exit_funcs_:
-                    if not i.trigger or isinstance(current_node, i.trigger):
-                        if i.func and i.trigger:
+                    trigger = i.get_funcparam_annotations(i.func)
+                    if not trigger or isinstance(current_node, trigger):
+                        if i.func and trigger:
                             walker.returns.append(i.func(warch, current_node))
-                        elif not i.trigger:
+                        elif not trigger:
                             continue
                         else:
                             raise ValueError(f"No function {i.name} to call.")
                     if walker.disengaged:
                         return warch
                 for i in current_node._jac_exit_funcs_:
-                    if not i.trigger or isinstance(walker, i.trigger):
+                    trigger = i.get_funcparam_annotations(i.func)
+                    if not trigger or isinstance(warch, trigger):
                         if i.func:
                             walker.returns.append(i.func(current_node, warch))
                         else:
@@ -800,7 +835,8 @@ def spawn_call(op1: Architype, op2: Architype) -> WalkerArchitype:
                     if walker.disengaged:
                         return warch
         for i in warch._jac_exit_funcs_:
-            if not i.trigger:
+            trigger = i.get_funcparam_annotations(i.func)
+            if not trigger:
                 if i.func:
                     walker.returns.append(i.func(warch, current_node))
                 else:
diff --git a/jac-cloud/jac_cloud/plugin/mini/__init__.py b/jac-cloud/jac_cloud/plugin/mini/__init__.py
deleted file mode 100644
index 1fa8f770d8..0000000000
--- a/jac-cloud/jac_cloud/plugin/mini/__init__.py
+++ /dev/null
@@ -1,1 +0,0 @@
-"""Jaseci Plugins Mini."""
diff --git a/jac-cloud/jac_cloud/plugin/mini/cli_mini.py b/jac-cloud/jac_cloud/plugin/mini/cli_mini.py
deleted file mode 100644
index ff14b33c01..0000000000
--- a/jac-cloud/jac_cloud/plugin/mini/cli_mini.py
+++ /dev/null
@@ -1,197 +0,0 @@
-"""Module for registering CLI plugins for jaseci."""
-
-from dataclasses import Field, MISSING, asdict, fields, is_dataclass
-from inspect import isclass
-from os import getenv, path
-from pickle import load
-from typing import Any, Type, cast, get_type_hints
-
-from asyncer import syncify
-
-from fastapi import APIRouter, Depends, FastAPI, File, Response, UploadFile, status
-from fastapi.responses import ORJSONResponse
-
-from jac_cloud.jaseci.utils import populate_yaml_specs
-
-from jaclang import jac_import
-from jaclang.plugin.feature import JacFeature as Jac
-from jaclang.runtimelib.architype import (
-    Anchor,
-    Architype,
-    WalkerArchitype,
-)
-from jaclang.runtimelib.context import ExecutionContext
-from jaclang.runtimelib.machine import JacMachine, JacProgram
-
-from orjson import loads
-
-from pydantic import BaseModel, Field as pyField, ValidationError, create_model
-
-from starlette.datastructures import UploadFile as BaseUploadFile
-
-from uvicorn import run
-
-FILE_TYPES = {
-    UploadFile,
-    list[UploadFile],
-    UploadFile | None,
-    list[UploadFile] | None,
-}
-
-
-def response(reports: list[Any], status: int = 200) -> ORJSONResponse:
-    """Return serialized version of reports."""
-    resp: dict[str, Any] = {"status": status}
-
-    for key, val in enumerate(reports):
-        clean_response(key, val, reports)
-    resp["reports"] = reports
-
-    return ORJSONResponse(resp, status_code=status)
-
-
-def clean_response(key: str | int, val: Any, obj: list | dict) -> None:  # noqa: ANN401
-    """Cleanup and override current object."""
-    match val:
-        case list():
-            for idx, lval in enumerate(val):
-                clean_response(idx, lval, val)
-        case dict():
-            for key, dval in val.items():
-                clean_response(key, dval, val)
-        case Anchor():
-            cast(dict, obj)[key] = asdict(val.report())
-        case Architype():
-            cast(dict, obj)[key] = asdict(val.__jac__.report())
-        case val if is_dataclass(val) and not isinstance(val, type):
-            cast(dict, obj)[key] = asdict(val)
-        case _:
-            pass
-
-
-def gen_model_field(cls: type, field: Field, is_file: bool = False) -> tuple[type, Any]:
-    """Generate Specs for Model Field."""
-    if field.default is not MISSING:
-        consts = (cls, pyField(default=field.default))
-    elif callable(field.default_factory):
-        consts = (cls, pyField(default_factory=field.default_factory))
-    else:
-        consts = (cls, File(...) if is_file else ...)
-
-    return consts
-
-
-def populate_apis(router: APIRouter, cls: Type[WalkerArchitype]) -> None:
-    """Generate FastAPI endpoint based on WalkerArchitype class."""
-    body: dict[str, Any] = {}
-    files: dict[str, Any] = {}
-
-    hintings = get_type_hints(cls)
-    for f in fields(cls):
-        f_name = f.name
-        f_type = hintings[f_name]
-        if f_type in FILE_TYPES:
-            files[f_name] = gen_model_field(f_type, f, True)
-        else:
-            consts = gen_model_field(f_type, f)
-            body[f_name] = consts
-
-    payload: dict[str, Any] = {
-        "files": (
-            create_model(f"{cls.__name__.lower()}_files_model", **files),
-            Depends(),
-        ),
-    }
-
-    body_model = None
-    if body:
-        body_model = create_model(f"{cls.__name__.lower()}_body_model", **body)
-
-        if files:
-            payload["body"] = (UploadFile, File(...))
-        else:
-            payload["body"] = (body_model, ...)
-
-    payload_model = create_model(f"{cls.__name__.lower()}_request_model", **payload)
-
-    def api_entry(
-        node: str | None,
-        payload: payload_model = Depends(),  # type: ignore # noqa: B008
-    ) -> ORJSONResponse:
-        pl = cast(BaseModel, payload).model_dump()
-        body = pl.get("body", {})
-
-        if isinstance(body, BaseUploadFile) and body_model:
-            body = loads(syncify(body.read)())
-            try:
-                body = body_model(**body).model_dump()
-            except ValidationError as e:
-                return ORJSONResponse({"detail": e.errors()})
-
-        jctx = ExecutionContext.create(session=getenv("DATABASE", "database"))
-        jctx.set_entry_node(node)
-
-        Jac.spawn_call(cls(**body, **pl["files"]), jctx.entry_node.architype)
-        jctx.close()
-
-        return response(jctx.reports, getattr(jctx, "status", 200))
-
-    def api_root(
-        payload: payload_model = Depends(),  # type: ignore # noqa: B008
-    ) -> Response:
-        return api_entry(None, payload)
-
-    router.post(url := f"/{cls.__name__}", summary=url)(api_root)
-    router.post(url := f"/{cls.__name__}/{{node}}", summary=url)(api_entry)
-
-
-def serve_mini(filename: str, host: str = "0.0.0.0", port: int = 8000) -> None:
-    """Serve the jac application."""
-    base, mod = path.split(filename)
-    base = base if base else "./"
-    mod = mod[:-4]
-
-    if filename.endswith(".jac"):
-        (module,) = jac_import(
-            target=mod,
-            base_path=base,
-            cachable=True,
-            override_name="__main__",
-        )
-    elif filename.endswith(".jir"):
-        with open(filename, "rb") as f:
-            JacMachine(base).attach_program(
-                JacProgram(mod_bundle=load(f), bytecode=None)
-            )
-            (module,) = jac_import(
-                target=mod,
-                base_path=base,
-                cachable=True,
-                override_name="__main__",
-            )
-    else:
-        JacMachine.detach()
-        raise ValueError("Not a valid file!\nOnly supports `.jac` and `.jir`")
-
-    app = FastAPI()
-
-    populate_yaml_specs(app)
-
-    healtz_router = APIRouter(prefix="/healthz", tags=["monitoring"])
-    walker_router = APIRouter(prefix="/walker", tags=["walker"])
-
-    @healtz_router.get("", status_code=status.HTTP_200_OK)
-    def healthz() -> Response:
-        """Healthz API."""
-        return Response()
-
-    for obj in module.__dict__.values():
-        if isclass(obj) and issubclass(obj, WalkerArchitype):
-            populate_apis(walker_router, obj)
-
-    app.include_router(healtz_router)
-    app.include_router(walker_router)
-
-    run(app, host=host, port=port)
-
-    JacMachine.detach()
diff --git a/jac-cloud/setup.py b/jac-cloud/setup.py
index ebdc55ce43..9b946b4eea 100644
--- a/jac-cloud/setup.py
+++ b/jac-cloud/setup.py
@@ -2,14 +2,14 @@
 
 from setuptools import find_packages, setup
 
-VERSION = "0.1.7"
+VERSION = "0.1.10"
 
 setup(
     name="jac-cloud",
     version=VERSION,
     packages=find_packages(include=["jac_cloud", "jac_cloud.*"]),
     install_requires=[
-        "jaclang~=0.7.24",
+        "jaclang~=0.7.26",
         "fastapi~=0.111.0",
         "pydantic~=2.8.2",
         "pymongo~=4.8.0",
@@ -33,6 +33,7 @@
         "fakeredis~=2.24.1",
         "ecs-logging~=2.2.0",
         "types-PyYAML~=6.0.12.20240917",
+        "montydb~=2.5.3",
     ],
     package_data={},
     entry_points={
diff --git a/jac-mtllm/.pre-commit-config.yaml b/jac-mtllm/.pre-commit-config.yaml
index e62aff9de3..891f61e0e5 100644
--- a/jac-mtllm/.pre-commit-config.yaml
+++ b/jac-mtllm/.pre-commit-config.yaml
@@ -10,10 +10,12 @@ repos:
     rev: 24.1.1
     hooks:
       - id: black
+        exclude: '__jac_gen__'
   - repo: https://github.com/PyCQA/flake8
     rev: 6.1.0
     hooks:
       - id: flake8
+        exclude: '__jac_gen__'
         args: ["--config=jac-mtllm/.flake8"]
         additional_dependencies: [pep8-naming, flake8_import_order, flake8_docstrings, flake8_comprehensions, flake8_bugbear, flake8_annotations, flake8_simplify]
   - repo: https://github.com/pre-commit/mirrors-mypy
@@ -21,6 +23,7 @@ repos:
     hooks:
       - id: mypy
         additional_dependencies: [types-PyYAML, types-requests]
+        exclude: '__jac_gen__'
         args:
           - --follow-imports=silent
           - --ignore-missing-imports
diff --git a/jac-mtllm/examples/car_scratch.jpg b/jac-mtllm/examples/car_scratch.jpg
new file mode 100644
index 0000000000..7407f77fda
Binary files /dev/null and b/jac-mtllm/examples/car_scratch.jpg differ
diff --git a/jac-mtllm/examples/inherit_basellm.jac b/jac-mtllm/examples/inherit_basellm.jac
new file mode 100644
index 0000000000..66ba1289b1
--- /dev/null
+++ b/jac-mtllm/examples/inherit_basellm.jac
@@ -0,0 +1,103 @@
+import from mtllm.llms.base { BaseLLM }
+import:py from PIL { Image }
+import torch;
+import from transformers { AutoModelForCausalLM, AutoProcessor }
+
+glob PROMPT_TEMPLATE: str = """
+[Information]
+{information}
+
+[Context]
+{context}
+
+[Output Information]
+{output_information}
+
+[Type Explanations]
+{type_explanations}
+
+[Action]
+{action}
+""";  # [Context] will not be appear in the prompt
+
+obj Florence :BaseLLM: {
+    with entry {
+        MTLLM_PROMPT = PROMPT_TEMPLATE;
+    }
+    can init(model_id: str) {
+        self.verbose = True;
+        self.max_tries = 0;
+        self.type_check = False;
+        self.model = AutoModelForCausalLM.from_pretrained(
+            model_id,
+            trust_remote_code=True, torch_dtype='auto'
+        ).eval().cuda();
+        self.processor = AutoProcessor.from_pretrained(
+            model_id,
+            trust_remote_code=True
+        );
+    }
+
+    can __infer__(meaning: str, image: Image, **kwargs: tuple) -> str {
+        can run_example(task_prompt: str, image: Image) -> str {
+            prompt = task_prompt;
+            inputs = self.processor(
+                text=prompt,
+                images=image,
+                return_tensors="pt"
+            ).to(
+                'cuda',
+                torch.float16
+            );
+            generated_ids = self.model.generate(
+                input_ids=inputs["input_ids"].cuda(),
+                pixel_values=inputs["pixel_values"].cuda(),
+                max_new_tokens=1024,
+                early_stopping=False,
+                do_sample=False,
+                num_beams=3,
+
+            );
+            generated_text = self.processor.batch_decode(
+                generated_ids,
+                skip_special_tokens=False
+            )[0];
+            parsed_answer = self.processor.post_process_generation(
+                generated_text,
+                task=task_prompt, image_size=(image.width, image.height)
+            );
+
+            return parsed_answer;
+        }
+
+        result = run_example('<MORE_DETAILED_CAPTION>', image=image);
+        return str(next(iter(result.values())));
+    }
+
+    can __call__(meaning: str, media: list, **kwargs: tuple) {
+        if self.verbose {
+            print(f'MEANING_IN:\n{meaning}');
+            print('MEDIA:\n', media);
+        }
+        image = media[0].value;
+        return self.__infer__(meaning, image, **kwargs);
+    }
+}
+
+glob llm = Florence('microsoft/Florence-2-base');
+
+enum DamageType {
+    NoDamage,
+    MinorDamage,
+    MajorDamage,
+    Destroyed
+}
+
+can ""
+predict_vehicle_damage(img: Image) -> DamageType by llm(is_custom=True,raw_output=True);
+
+with entry {
+    img = 'car_scratch.jpg';
+    image = Image.open(img);
+    print(predict_vehicle_damage(image));
+}
diff --git a/jac-mtllm/mtllm/aott.py b/jac-mtllm/mtllm/aott.py
index 20f1797069..f39c5d6e4c 100644
--- a/jac-mtllm/mtllm/aott.py
+++ b/jac-mtllm/mtllm/aott.py
@@ -6,6 +6,8 @@
 
 from typing import Mapping
 
+from PIL import Image as PILImage
+
 from jaclang.compiler.semtable import SemRegistry
 
 from loguru import logger
@@ -22,6 +24,7 @@
     TypeExplanation,
     Video,
 )
+from mtllm.utils import format_template_section
 
 
 def aott_raise(
@@ -33,6 +36,7 @@ def aott_raise(
     action: str,
     context: str,
     method: str,
+    is_custom: bool,
     tools: list[Tool],
     model_params: dict,
     _globals: dict,
@@ -41,14 +45,18 @@ def aott_raise(
     """AOTT Raise uses the information (Meanings types values) provided to generate a prompt(meaning in)."""
     _globals["finish_tool"] = finish_tool
     contains_media: bool = any(
-        isinstance(x.value, (Image, Video)) for x in inputs_information
+        isinstance(x.value, (Image, Video, PILImage.Image)) for x in inputs_information
     )
     informations_str = "\n".join([str(x) for x in informations])
     inputs_information_repr: list[dict] | str
-    if contains_media:
+    media = []
+    if contains_media and not is_custom:
         inputs_information_repr = []
-        for x in inputs_information:
-            inputs_information_repr.extend(x.to_list_dict())
+        for input_info in inputs_information:
+            inputs_information_repr.extend(input_info.to_list_dict())
+    elif is_custom:
+        media = [x for x in inputs_information if isinstance(x.value, PILImage.Image)]
+        inputs_information_repr = "\n".join([str(x) for x in inputs_information])
     else:
         inputs_information_repr = "\n".join([str(x) for x in inputs_information])
 
@@ -60,14 +68,15 @@ def aott_raise(
     tools.append(finish_tool)
     method_prompt = model.MTLLM_METHOD_PROMPTS[method]
     if isinstance(inputs_information_repr, str):
-        mtllm_prompt = model.MTLLM_PROMPT.format(
-            information=informations_str,
-            inputs_information=inputs_information_repr,
-            output_information=str(output_hint),
-            type_explanations=type_explanations_str,
-            action=action,
-            context=context,
-        ).strip()
+        all_values = {
+            "information": informations_str,
+            "inputs_information": inputs_information_repr,
+            "output_information": str(output_hint),
+            "type_explanations": type_explanations_str,
+            "action": action,
+            "context": context,
+        }
+        mtllm_prompt = format_template_section(model.MTLLM_PROMPT, all_values)
         if not is_react:
             meaning_typed_input_list = [system_prompt, mtllm_prompt, method_prompt]
         else:
@@ -79,17 +88,18 @@ def aott_raise(
                 method_prompt,
             ]
     else:
-        upper_half = model.MTLLM_PROMPT.split("{inputs_information}")[0]
-        lower_half = model.MTLLM_PROMPT.split("{inputs_information}")[1]
-        upper_half = upper_half.format(
-            information=informations_str,
-            context=context,
-        )
-        lower_half = lower_half.format(
-            output_information=str(output_hint),
-            type_explanations=type_explanations_str,
-            action=action,
-        )
+        upper_half, lower_half = model.MTLLM_PROMPT.split("{inputs_information}")
+        upper_values = {
+            "information": informations_str,
+            "context": context,
+        }
+        lower_values = {
+            "output_information": str(output_hint),
+            "type_explanations": type_explanations_str,
+            "action": action,
+        }
+        upper_half = format_template_section(upper_half, upper_values)
+        lower_half = format_template_section(lower_half, lower_values)
         meaning_typed_input_list = [
             {"type": "text", "text": system_prompt},
             {"type": "text", "text": upper_half},
@@ -118,10 +128,10 @@ def aott_raise(
         return f"[Output] {result}"
     meaning_typed_input = (
         "\n".join(meaning_typed_input_list)  # type: ignore
-        if not contains_media
+        if not (contains_media and not is_custom)
         else meaning_typed_input_list
     )
-    return model(meaning_typed_input, **model_params)  # type: ignore
+    return model(meaning_typed_input, media=media, **model_params)  # type: ignore
 
 
 def execute_react(
diff --git a/jac-mtllm/mtllm/llms/base.py b/jac-mtllm/mtllm/llms/base.py
index b7cbafc0ef..c5aad4eb4e 100644
--- a/jac-mtllm/mtllm/llms/base.py
+++ b/jac-mtllm/mtllm/llms/base.py
@@ -6,7 +6,8 @@
 
 from loguru import logger
 
-from mtllm.types import OutputHint, ReActOutput, TypeExplanation
+from mtllm.types import InputInformation, OutputHint, ReActOutput, TypeExplanation
+from mtllm.utils import format_template_section
 
 
 httpx_logger = logging.getLogger("httpx")
@@ -161,7 +162,12 @@ def __infer__(self, meaning_in: str | list[dict], **kwargs: dict) -> str:
         """Infer a response from the input meaning."""
         raise NotImplementedError
 
-    def __call__(self, input_text: str | list[dict], **kwargs: dict) -> str:
+    def __call__(
+        self,
+        input_text: str | list[dict],
+        media: list[Optional[InputInformation]],
+        **kwargs: dict,
+    ) -> str:
         """Infer a response from the input text."""
         if self.verbose:
             logger.info(f"Meaning In\n{input_text}")
@@ -251,11 +257,14 @@ def _fix_react_output(
         """Fix the output string."""
         if self.verbose:
             logger.info(f"Error: {error}, Fixing the output.")
-        react_output_fix_prompt = self.REACT_OUTPUT_FIX_PROMPT.format(
-            model_output=meaning_out,
-            error=str(error),
-            tool_explanations=tool_explanations,
-            type_explanations=type_explanations,
+        react_output_fix_values = {
+            "model_output": meaning_out,
+            "error": str(error),
+            "tool_explanations": tool_explanations,
+            "type_explanations": type_explanations,
+        }
+        react_output_fix_prompt = format_template_section(
+            self.REACT_OUTPUT_FIX_PROMPT, react_output_fix_values
         )
         return self.__infer__(react_output_fix_prompt)
 
@@ -266,12 +275,15 @@ def _check_output(
         output_type_explanations: list[TypeExplanation],
     ) -> bool:
         """Check if the output is in the desired format."""
-        output_check_prompt = self.OUTPUT_CHECK_PROMPT.format(
-            model_output=output,
-            output_type=output_type,
-            output_type_info="\n".join(
+        react_values = {
+            "model_output": output,
+            "output_type": output_type,
+            "output_type_info": "\n".join(
                 [str(info) for info in output_type_explanations]
             ),
+        }
+        output_check_prompt = format_template_section(
+            self.OUTPUT_CHECK_PROMPT, react_values
         )
         llm_output = self.__infer__(output_check_prompt)
         return "yes" in llm_output.lower()
@@ -298,14 +310,16 @@ def _extract_output(
                 )
             else:
                 logger.info("Extracting output from the meaning out string.")
-
-        output_extract_prompt = self.OUTPUT_EXTRACT_PROMPT.format(
-            model_output=meaning_out,
-            previous_output=previous_output,
-            output_info=str(output_hint),
-            output_type_info="\n".join(
+        output_check_values = {
+            "model_output": meaning_out,
+            "previous_output": previous_output,
+            "output_info": str(output_hint),
+            "output_type_info": "\n".join(
                 [str(info) for info in output_type_explanations]
             ),
+        }
+        output_extract_prompt = format_template_section(
+            self.OUTPUT_EXTRACT_PROMPT, output_check_values
         )
         llm_output = self.__infer__(output_extract_prompt)
         is_in_desired_format = self._check_output(
@@ -376,12 +390,15 @@ def _fix_output(
         """Fix the output string."""
         if self.verbose:
             logger.info(f"Error: {error}, Fixing the output.")
-        output_fix_prompt = self.OUTPUT_FIX_PROMPT.format(
-            model_output=output,
-            output_type=output_hint.type,
-            output_type_info="\n".join(
+        output_fix_values = {
+            "model_output": output,
+            "output_type": output_hint.type,
+            "output_type_info": "\n".join(
                 [str(info) for info in output_type_explanations]
             ),
-            error=error,
+            "error": str(error),
+        }
+        output_fix_prompt = format_template_section(
+            self.OUTPUT_FIX_PROMPT, output_fix_values
         )
         return self.__infer__(output_fix_prompt)
diff --git a/jac-mtllm/mtllm/plugin.py b/jac-mtllm/mtllm/plugin.py
index 781a1d9e8b..1b2c13de1a 100644
--- a/jac-mtllm/mtllm/plugin.py
+++ b/jac-mtllm/mtllm/plugin.py
@@ -1,8 +1,6 @@
 """Plugin for Jac's with_llm feature."""
 
 import ast as ast3
-import os
-import pickle
 from typing import Any, Callable, Mapping, Optional, Sequence
 
 import jaclang.compiler.absyntree as ast
@@ -53,20 +51,20 @@ def with_llm(
         _locals: Mapping,
     ) -> Any:  # noqa: ANN401
         """Jac's with_llm feature."""
-        with open(
-            os.path.join(
-                os.path.dirname(file_loc),
-                "__jac_gen__",
-                os.path.basename(file_loc).replace(".jac", ".registry.pkl"),
-            ),
-            "rb",
-        ) as f:
-            mod_registry = pickle.load(f)
+        from jaclang.runtimelib.machine import JacMachine
+
+        mod_registry = JacMachine.get().jac_program.sem_ir
 
         _scope = SemScope.get_scope_from_str(scope)
         assert _scope is not None, f"Invalid scope: {scope}"
 
         method = model_params.pop("method") if "method" in model_params else "Normal"
+        is_custom = (
+            model_params.pop("is_custom") if "is_custom" in model_params else False
+        )
+        raw_output = (
+            model_params.pop("raw_output") if "raw_output" in model_params else False
+        )
         available_methods = model.MTLLM_METHOD_PROMPTS.keys()
         assert (
             method in available_methods
@@ -117,13 +115,18 @@ def with_llm(
             action,
             context,
             method,
+            is_custom,
             _tools,
             model_params,
             _globals,
             _locals,
         )
-        _output = model.resolve_output(
-            meaning_out, output_hint, output_type_explanations, _globals, _locals
+        _output = (
+            model.resolve_output(
+                meaning_out, output_hint, output_type_explanations, _globals, _locals
+            )
+            if not raw_output
+            else meaning_out
         )
         return _output
 
diff --git a/jac-mtllm/mtllm/utils.py b/jac-mtllm/mtllm/utils.py
index 3720144bd5..2e1e060ef9 100644
--- a/jac-mtllm/mtllm/utils.py
+++ b/jac-mtllm/mtllm/utils.py
@@ -97,3 +97,19 @@ def get_filtered_registry(mod_registry: SemRegistry, scope: SemScope) -> SemRegi
             filtered_registry.registry[_scope] = sem_info_list
 
     return filtered_registry
+
+
+def extract_template_placeholders(template: str) -> list:
+    """Extract placeholders from the template."""
+    return re.findall(r"{(.*?)}", template)
+
+
+def format_template_section(template_section: str, values_dict: dict) -> str:
+    """Format a template section with given values."""
+    placeholders = extract_template_placeholders(template_section)
+    formatted_sections = []
+    for placeholder in placeholders:
+        if placeholder in values_dict and values_dict[placeholder]:
+            section_template = f"[{placeholder.title()}]\n{values_dict[placeholder]}"
+            formatted_sections.append(section_template)
+    return "\n\n".join(formatted_sections).strip()
diff --git a/jac-mtllm/pyproject.toml b/jac-mtllm/pyproject.toml
index 464dfefa4d..223b00a308 100644
--- a/jac-mtllm/pyproject.toml
+++ b/jac-mtllm/pyproject.toml
@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "mtllm"
-version = "0.3.2"
+version = "0.3.4"
 description = "MTLLM Provides Easy to use APIs for different LLM Providers to be used with Jaseci's Jaclang Programming Language."
 authors = ["Jason Mars <jason@jaseci.org>"]
 maintainers = ["Jason Mars <jason@jaseci.org>"]
@@ -9,7 +9,7 @@ readme = "README.md"
 keywords = ["llm", "jaclang", "jaseci", "mtllm"]
 
 [tool.poetry.dependencies]
-jaclang = "~0.7.16"
+jaclang = "~0.7.25"
 loguru = "~0.7.2"
 openai = { version = "~1.30.4", optional = true }
 anthropic = { version = "~0.26.1", optional = true }
diff --git a/jac-splice-orc/.gitignore b/jac-splice-orc/.gitignore
new file mode 100644
index 0000000000..f5da62b155
--- /dev/null
+++ b/jac-splice-orc/.gitignore
@@ -0,0 +1,5 @@
+*.egg-info
+__jac_gen__
+build
+*.pyc
+__pycache__
\ No newline at end of file
diff --git a/jac-splice-orc/ReadMe.md b/jac-splice-orc/ReadMe.md
new file mode 100644
index 0000000000..fea42303e9
--- /dev/null
+++ b/jac-splice-orc/ReadMe.md
@@ -0,0 +1,458 @@
+# JAC Cloud Orchestrator (`jac-splice-orc`)
+
+
+JAC Cloud Orchestrator (`jac-splice-orc`) is a system designed to dynamically import any Python module, deploy it as a Kubernetes Pod, and expose it as an independent gRPC service. This enables any Python module to be used as a microservice, providing flexibility and scalability in a cloud environment.
+
+---
+
+## Table of Contents
+
+- [Overview](#overview)
+- [Features](#features)
+- [Architecture](#architecture)
+  - [System Components](#system-components)
+  - [Data Flow](#data-flow)
+- [Project Structure](#project-structure)
+- [Setup](#setup)
+  - [Prerequisites](#prerequisites)
+  - [1. Clone the Repository](#1-clone-the-repository)
+  - [2. Install Dependencies](#2-install-dependencies)
+  - [3. Configure the System](#3-configure-the-system)
+  - [4. Initialize the System](#4-initialize-the-system)
+- [Docker Usage](#docker-usage)
+- [Usage](#usage)
+  - [Client Application](#client-application)
+  - [Example Usage](#example-usage)
+    - [Importing Remote Modules](#importing-remote-modules)
+    - [Example: Using NumPy as a Remote Module](#example-using-numpy-as-a-remote-module)
+- [Configuration](#configuration)
+  - [Environment Variables](#environment-variables)
+  - [Module Configuration](#module-configuration)
+- [Troubleshooting](#troubleshooting)
+- [Flow Diagram](#flow-diagram)
+- [Notes](#notes)
+- [Contributing](#contributing)
+- [License](#license)
+
+---
+
+## Overview
+
+Imagine having the ability to use any Python module as a remote service, seamlessly integrating it into your application without worrying about the underlying infrastructure. JAC Cloud Orchestrator allows you to dynamically deploy Python modules as microservices in a Kubernetes environment, exposing them via gRPC for remote execution.
+
+This system abstracts away the complexities of remote execution, pod management, and inter-service communication, enabling developers to focus on building applications rather than managing infrastructure.
+
+---
+
+## Features
+
+- **Dynamic Module Deployment**: Import and deploy any Python module as a Kubernetes Pod on-demand.
+- **gRPC Service Exposure**: Expose modules as gRPC services for efficient remote procedure calls.
+- **Transparent Remote Execution**: Use remote modules as if they were local, with automatic handling of data serialization and deserialization.
+- **Pod Management**: Automatically create, manage, and terminate pods based on usage.
+- **Scalability**: Scale services horizontally by deploying multiple instances.
+- **Resource Optimization**: Allocate resources dynamically, ensuring optimal utilization.
+
+---
+
+## Architecture
+
+![Architecture Diagram](jac_splice_orc/assets/Splice-Orc-2.png)
+
+### System Components
+
+1. **Client Application**
+   - The interface through which users interact with remote modules.
+   - Handles serialization and deserialization of data.
+   - Provides proxy objects to interact with remote modules seamlessly.
+
+2. **Pod Manager**
+   - Manages Kubernetes pods and services for modules.
+   - Receives requests from the client and ensures the appropriate pods are running.
+   - Forwards method execution requests to the corresponding pods.
+
+3. **Module Server (Pod)**
+   - Runs the requested Python module within a Kubernetes pod.
+   - Exposes the module's functionalities via a gRPC server.
+   - Executes methods and returns results to the Pod Manager.
+
+### Data Flow
+
+1. **Client Requests**: The client makes a request to use a module's method.
+2. **Pod Manager Processing**: The Pod Manager checks if the module's pod is running; if not, it creates it.
+3. **Method Execution**: The Pod Manager forwards the request to the module's pod.
+4. **Result Retrieval**: The module pod executes the method and returns the result.
+5. **Client Receives Result**: The client receives and deserializes the result, making it available for use.
+
+---
+
+## Project Structure
+
+```
+jac-splice-orc/
+│
+├── jac_splice_orc/
+│   ├── __init__.py
+│   ├── config/
+│   │   └── config.json                  # Main configuration file
+│   ├── config_loader.py                 # Configuration loader utility
+│   ├── grpc_local/
+│   │   ├── __init__.py
+│   │   └── module_service.proto         # Protocol Buffers definition
+│   ├── managers/
+│   │   ├── __init__.py
+│   │   ├── pod_manager.py               # Pod Manager to handle pod operations
+│   │   ├── proxy_manager.py             # Proxy Manager for handling client-side proxying
+│   ├── plugin/
+│   │   ├── __init__.py
+│   │   └── splice_plugin.py             # Plugin for integration with jaclang
+│   ├── server/
+│   │   ├── __init__.py
+│   │   └── server.py                    # gRPC server to serve the imported module as a service
+│   └── utils/
+│       ├── __init__.py
+│       └── startup.sh                   # Startup script for initializing the server
+├── k8s/
+│   ├── pod_manager_deployment.yml       # Kubernetes deployment manifest
+├── docker/
+│   ├── Dockerfile                       # Dockerfile
+├── requirements.txt                     # Python dependencies
+├── setup.py                             # Installation script
+└── README.md                            # Project documentation
+```
+
+---
+
+## Setup
+
+### Prerequisites
+
+Before you begin, ensure that you have the following installed and configured:
+
+- **Python** (version 3.9 or later): [Install Python](https://www.python.org/downloads/)
+- **Docker** (version 20.10 or later): [Install Docker](https://docs.docker.com/get-docker/)
+- **Kubernetes** (version 1.21 or later): [Install Kubernetes](https://kubernetes.io/docs/setup/)
+- **kubectl** command-line tool: [Install kubectl](https://kubernetes.io/docs/tasks/tools/)
+- **Jac**: [Install Jaclang](https://github.com/Jaseci-Labs/jasecii)
+- **Kubernetes Cluster**: Ensure you have access to a Kubernetes cluster (local or remote).
+
+Ensure that your Kubernetes cluster is up and running, and that you can connect to it using `kubectl`.
+
+### 1. Clone the Repository
+
+Clone the `jac-splice-orc` repository to your local machine:
+
+```bash
+git clone https://github.com/Jaseci-Labs/jac-splice-orc.git
+cd jac-splice-orc
+```
+
+### 2. Install Dependencies
+
+Create a virtual environment and install the required Python packages:
+
+```bash
+python -m venv venv
+source venv/bin/activate  # On Windows: venv\Scripts\activate
+pip install -r requirements.txt
+```
+
+**Note**: The `requirements.txt` file includes all necessary dependencies, such as `kubernetes`, `grpcio`, `PyYAML`, and others.
+
+### 3. Configure the System
+
+The application uses a `config.json` file located in the `jac_splice_orc/config/` directory for all configurations.
+
+**Update the Configuration File**
+
+Edit `jac_splice_orc/config/config.json` to match your environment. Here's an example configuration:
+
+```json
+{
+  "kubernetes": {
+    "namespace": "jac-splice-orc",
+    "service_account_name": "jac-orc-sa",
+    "pod_manager": {
+      "deployment_name": "pod-manager-deployment",
+      "service_account_name": "jac-orc-sa",
+      "container_name": "pod-manager",
+      "image_name": "jaseci/jac-splice-orc:latest",
+      "container_port": 8000,
+      "service_name": "pod-manager-service",
+      "service_type": "LoadBalancer",
+      "env_vars": {
+        "SERVICE_TYPE": "pod_manager",
+        "NAMESPACE": "jac-splice-orc",
+        "IMAGE_NAME": "jaseci/jac-splice-orc:latest"
+      },
+      "resources": {
+        "requests": {
+          "memory": "1500Mi",
+          "cpu": "500m"
+        },
+        "limits": {
+          "memory": "2000Mi",
+          "cpu": "1"
+        }
+      }
+    }
+  },
+  "module_config": {
+    "numpy": {
+      "lib_mem_size_req": "100Mi",
+      "dependency": [],
+      "lib_cpu_req": "500m",
+      "load_type": "remote"
+    }
+    // Add other module configurations as needed
+  },
+  "environment": {
+    "POD_MANAGER_URL": ""
+  }
+}
+```
+
+**Note**:
+
+- Replace `jaseci/jac-splice-orc:latest` with your own image if you have customized it.
+- Adjust resource requests and limits according to your environment.
+
+### 4. Initialize the System
+
+Use the provided CLI command to initialize the Pod Manager and Kubernetes resources:
+
+```bash
+jac orc_initialize jac-splice-orc
+```
+
+**Explanation**:
+
+- `jac orc_initialize`: Invokes the initialization command provided by the plugin.
+- `jac-splice-orc`: Specifies the Kubernetes namespace to use. If not provided, it defaults to the namespace specified in `config.json`.
+
+**What This Command Does**:
+
+- Creates the specified Kubernetes namespace if it doesn't exist.
+- Creates the ServiceAccount, Role, and RoleBinding required for the Pod Manager.
+- Deploys the Pod Manager Deployment and Service to the Kubernetes cluster.
+- Updates the `POD_MANAGER_URL` in the `config.json` file with the actual service URL.
+
+**Verify the Deployment**:
+
+Check that the resources have been created in Kubernetes:
+
+```bash
+kubectl get namespaces
+kubectl get deployments -n jac-splice-orc
+kubectl get services -n jac-splice-orc
+kubectl get pods -n jac-splice-orc
+```
+
+---
+
+## Docker Usage
+
+### Building the Docker Image
+
+Build the Docker image using the provided Dockerfile:
+
+```bash
+docker build -t your_dockerhub_username/jac-splice-orc:latest .
+```
+
+Replace `your_dockerhub_username` with your Docker Hub username or preferred image name.
+
+### Running the Docker Container
+
+You can run the container as either the Pod Manager or a Module Service by setting the `SERVICE_TYPE` environment variable.
+
+#### Running the Pod Manager
+
+```bash
+docker run -d -p 8000:8000 -e SERVICE_TYPE=pod_manager your_dockerhub_username/jac-splice-orc:latest
+```
+
+This starts the Pod Manager service on port 8000.
+
+#### Running a Module Service
+
+```bash
+docker run -d -p 50051:50051 -e SERVICE_TYPE=module_service -e MODULE_NAME=your_module_name your_dockerhub_username/jac-splice-orc:latest
+```
+
+Replace `your_module_name` with the name of the Python module you want to serve. This starts the Module Service on port 50051.
+
+### Dockerfile Overview
+
+The Dockerfile sets up an image that can run either the Pod Manager or a Module Service:
+
+- **Base Image**: Uses `python:3.12-slim` for a lightweight environment.
+- **Dependencies**: Installs necessary Python packages like `grpcio`, `fastapi`, `kubernetes`, and `numpy`.
+- **Application Code**: Copies the gRPC service definitions and application code into the image.
+- **Entrypoint**: Uses an environment variable `SERVICE_TYPE` to decide which service to start (`pod_manager` or `module_service`).
+
+---
+
+## Usage
+
+### Client Application
+
+The client application provides a seamless way to interact with remote modules as if they were local. It handles the complexities of remote communication, serialization, and deserialization.
+
+#### **Client Components**
+
+- **`ModuleProxy`**: Provides proxy objects for modules, handling remote method calls.
+- **`RemoteObjectProxy`**: Acts as a dynamic proxy for method calls on remote modules or objects.
+
+### Example Usage
+
+#### Importing Remote Modules
+
+With the system initialized, you can now import and use remote Python modules in your JAC programs.
+
+**Example JAC Code**:
+
+```jac
+with entry {
+    import: py numpy;
+    arr = numpy.array([1, 2, 3, 4]);
+    print(arr);
+    result = numpy.sum(arr);
+    print(result);
+}
+```
+
+#### Example: Using NumPy as a Remote Module
+
+**Step 1: Write the JAC Program**
+
+Create a file named `example.jac` with the following content:
+
+```jac
+with entry {
+    import: py numpy;
+    arr = numpy.array([1, 2, 3, 4]);
+    print("Array:", arr);
+    result = numpy.sum(arr);
+    print("Sum:", result);
+}
+```
+
+**Step 2: Run the JAC Program**
+
+Run the JAC program using the `jac` command:
+
+```bash
+jac run example.jac
+```
+
+**Expected Output**:
+
+```
+Array: [1 2 3 4]
+Sum: 10
+```
+
+**Explanation**:
+
+- The `import: py numpy;` statement tells the JAC runtime to import the `numpy` module.
+- Since `numpy` is configured with `"load_type": "remote"` in `config.json`, the system uses the `ModuleProxy` to interact with `numpy` running in a remote Kubernetes pod.
+- The array creation and sum calculation are performed remotely, and the results are returned to your local program.
+
+---
+
+## Configuration
+
+### Environment Variables
+
+While most configurations are stored in `config.json`, you can still use environment variables if needed.
+
+- **`POD_MANAGER_URL`**: URL of the Pod Manager service (updated automatically during initialization).
+- **`NAMESPACE`**: Kubernetes namespace to deploy pods (default is `jac-splice-orc`).
+
+### Module Configuration
+
+In the `config.json` file, under `module_config`, you can specify configurations for each module:
+
+- **`dependency`**: List of additional Python packages required by the module.
+- **`lib_cpu_req`**: CPU resource request for the pod (e.g., `"500m"`).
+- **`lib_mem_size_req`**: Memory resource request for the pod (e.g., `"512Mi"`).
+- **`load_type`**: Set to `"remote"` to handle the module remotely.
+
+**Example:**
+
+```json
+"numpy": {
+  "lib_mem_size_req": "100Mi",
+  "dependency": [],
+  "lib_cpu_req": "500m",
+  "load_type": "remote"
+}
+```
+
+---
+
+## Troubleshooting
+
+### 1. Pod Manager Not Accessible
+
+If the `POD_MANAGER_URL` is not set or the Pod Manager service is not accessible:
+
+- Ensure that the `jac orc_initialize` command has been run successfully.
+- Check that the Pod Manager service is running:
+
+  ```bash
+  kubectl get services -n jac-splice-orc
+  ```
+
+- Verify that the `POD_MANAGER_URL` in `config.json` has been updated. It should be set to the external IP or hostname of the Pod Manager service.
+
+### 2. Errors Importing Modules
+
+If you encounter errors when importing modules:
+
+- Ensure that the module is correctly configured in the `module_config` section of `config.json`.
+- Check that the module's `load_type` is set to `"remote"` if you intend to use it as a remote module.
+- Verify that the module's dependencies are correctly specified in the `dependency` list.
+
+### 3. Kubernetes Resource Issues
+
+If Kubernetes resources are not being created or updated:
+
+- Ensure that you have the correct permissions to create resources in the specified namespace.
+- Check the Kubernetes cluster status and logs for any errors.
+
+### 4. Logs and Debugging
+
+- Check the logs of the Pod Manager pod:
+
+  ```bash
+  kubectl logs deployment/pod-manager-deployment -n jac-splice-orc
+  ```
+
+- Check the logs of the module pods if they have been created.
+
+---
+
+## Flow Diagram
+
+![Flow Diagram](jac_splice_orc/assets/Splice-Orc.png)
+
+---
+
+## Notes
+
+- **Configuration Management**: The system uses a `config.json` file for configuration, enhancing flexibility and maintainability.
+- **Namespace Handling**: You can specify the Kubernetes namespace during initialization or let it default to the one specified in the configuration.
+- **Pod Manager URL**: The `POD_MANAGER_URL` is automatically updated in the configuration file after initialization, ensuring that the client knows how to communicate with the Pod Manager.
+- **Error Handling**: If the `POD_MANAGER_URL` is not set, the system will prompt you to run the initialization command.
+
+---
+
+## Additional Notes
+
+- **Custom Modules**: You can configure additional Python modules in the `module_config` section of `config.json` and use them in your JAC programs.
+- **Resource Configuration**: Adjust the resource requests and limits in the configurations to suit your environment and module requirements.
+- **Extensibility**: The system can be extended to support more complex modules and configurations.
+
+---
diff --git a/jac-splice-orc/docker/Dockerfile b/jac-splice-orc/docker/Dockerfile
new file mode 100644
index 0000000000..4b92a76431
--- /dev/null
+++ b/jac-splice-orc/docker/Dockerfile
@@ -0,0 +1,37 @@
+# Use a single base image
+FROM python:3.12-slim
+
+# Install common dependencies
+RUN pip install --no-cache-dir grpcio grpcio-tools fastapi uvicorn kubernetes python-multipart numpy
+
+# Create a working directory
+WORKDIR /app
+
+# Copy the gRPC service proto file for module services
+COPY grpc_local/module_service.proto /app/grpc_local/
+
+# Run gRPC file generation
+RUN python -m grpc_tools.protoc \
+    -I/app/grpc_local \
+    --python_out=/app/grpc_local \
+    --grpc_python_out=/app/grpc_local \
+    /app/grpc_local/module_service.proto
+
+# Copy pod manager code, server, and utils
+COPY managers/pod_manager.py /app/pod_manager.py
+COPY server /app/server
+COPY utils /app/utils
+
+# Expose the relevant ports (50051 for gRPC, 8000 for FastAPI)
+EXPOSE 50051 8000
+
+# Use an environment variable to decide what service to run
+# Default to "module_service"
+ENV SERVICE_TYPE="module_service"
+
+# Define entrypoint script that decides which service to start
+COPY utils/startup.sh /app/utils/startup.sh
+RUN chmod +x /app/utils/startup.sh
+
+# Start the appropriate service based on the environment variable
+CMD ["/app/utils/startup.sh"]
diff --git a/jac-splice-orc/jac_splice_orc/__init__.py b/jac-splice-orc/jac_splice_orc/__init__.py
new file mode 100644
index 0000000000..697254dc6e
--- /dev/null
+++ b/jac-splice-orc/jac_splice_orc/__init__.py
@@ -0,0 +1,1 @@
+"""Importing required modules and classes."""
diff --git a/jac-splice-orc/jac_splice_orc/assets/Splice-Orc-2.png b/jac-splice-orc/jac_splice_orc/assets/Splice-Orc-2.png
new file mode 100644
index 0000000000..252362d388
Binary files /dev/null and b/jac-splice-orc/jac_splice_orc/assets/Splice-Orc-2.png differ
diff --git a/jac-splice-orc/jac_splice_orc/assets/Splice-Orc.png b/jac-splice-orc/jac_splice_orc/assets/Splice-Orc.png
new file mode 100644
index 0000000000..6b791839d6
Binary files /dev/null and b/jac-splice-orc/jac_splice_orc/assets/Splice-Orc.png differ
diff --git a/jac-splice-orc/jac_splice_orc/config/__init__.py b/jac-splice-orc/jac_splice_orc/config/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/jac-splice-orc/jac_splice_orc/config/config.json b/jac-splice-orc/jac_splice_orc/config/config.json
new file mode 100644
index 0000000000..248bd9c4b2
--- /dev/null
+++ b/jac-splice-orc/jac_splice_orc/config/config.json
@@ -0,0 +1,68 @@
+{
+    "kubernetes": {
+        "namespace": "jac-splice-test",
+        "service_account_name": "jac-orc-sa",
+        "pod_manager": {
+            "deployment_name": "pod-manager-deployment",
+            "service_account_name": "jac-orc-sa",
+            "container_name": "pod-manager",
+            "image_name": "ashishmahendra/jac-splice-orc:0.1.8",
+            "container_port": 8000,
+            "service_name": "pod-manager-service",
+            "service_type": "LoadBalancer",
+            "env_vars": {
+                "SERVICE_TYPE": "pod_manager",
+                "NAMESPACE": "jac-splice-test",
+                "IMAGE_NAME": "ashishmahendra/jac-splice-orc:0.1.8"
+            },
+            "resources": {
+                "requests": {
+                    "memory": "1500Mi",
+                    "cpu": "500m"
+                },
+                "limits": {
+                    "memory": "2000Mi",
+                    "cpu": "1"
+                }
+            }
+        }
+    },
+    "module_config": {
+        "numpy": {
+            "lib_mem_size_req": "100Mi",
+            "dependency": [],
+            "lib_cpu_req": "500m",
+            "load_type": "remote"
+        },
+        "pandas": {
+            "lib_mem_size_req": "200Mi",
+            "dependency": [
+                "numpy",
+                "pytz",
+                "dateutil"
+            ],
+            "lib_cpu_req": "700m",
+            "load_type": "remote"
+        },
+        "transformers": {
+            "lib_mem_size_req": "2000Mi",
+            "dependency": [
+                "torch",
+                "transformers"
+            ],
+            "lib_cpu_req": "1.0",
+            "load_type": "remote"
+        },
+        "ollama": {
+            "lib_mem_size_req": "300Mi",
+            "dependency": [
+                "ollama"
+            ],
+            "lib_cpu_req": "500m",
+            "load_type": "remote"
+        }
+    },
+    "environment": {
+        "POD_MANAGER_URL": "http://a88a549ed32f14b14b1333a81ebd7a2a-1627559794.us-west-2.elb.amazonaws.com:8000"
+    }
+}
\ No newline at end of file
diff --git a/jac-splice-orc/jac_splice_orc/config/config_loader.py b/jac-splice-orc/jac_splice_orc/config/config_loader.py
new file mode 100644
index 0000000000..3b23b6b8b5
--- /dev/null
+++ b/jac-splice-orc/jac_splice_orc/config/config_loader.py
@@ -0,0 +1,60 @@
+# config_loader.py
+
+import os
+import json
+import logging
+
+
+class ConfigLoader:
+    """Loads configurations from a JSON file."""
+
+    def __init__(self, config_file_path=None):
+        if config_file_path is None:
+            # Default config file path
+            config_file_path = os.path.join(
+                os.path.dirname(__file__), "..", "config", "config.json"
+            )
+        self.config_file_path = config_file_path
+        self.config = self.load_config()
+
+    def load_config(self):
+        """Load the JSON configuration file."""
+        try:
+            with open(self.config_file_path, "r") as f:
+                config = json.load(f)
+            return config
+        except FileNotFoundError:
+            logging.error(f"Configuration file not found at {self.config_file_path}")
+            raise
+        except json.JSONDecodeError as e:
+            logging.error(f"Error parsing JSON configuration: {e}")
+            raise
+
+    def get(self, *keys, default=None):
+        """Retrieve a configuration value using a sequence of keys."""
+        cfg = self.config
+        for key in keys:
+            if cfg and key in cfg:
+                cfg = cfg.get(key)
+            else:
+                return default
+        return cfg if cfg is not None else default
+
+    def set(self, keys, value):
+        """Set a configuration value using a list of keys."""
+        cfg = self.config
+        for key in keys[:-1]:
+            if key not in cfg or not isinstance(cfg[key], dict):
+                cfg[key] = {}
+            cfg = cfg[key]
+        cfg[keys[-1]] = value
+
+    def save_config(self):
+        """Save the current configuration back to the JSON file."""
+        try:
+            with open(self.config_file_path, "w") as f:
+                json.dump(self.config, f, indent=4)
+            logging.info(f"Configuration saved to {self.config_file_path}")
+        except Exception as e:
+            logging.error(f"Error saving configuration: {e}")
+            raise
diff --git a/jac-splice-orc/jac_splice_orc/grpc_local/__init__.py b/jac-splice-orc/jac_splice_orc/grpc_local/__init__.py
new file mode 100644
index 0000000000..697254dc6e
--- /dev/null
+++ b/jac-splice-orc/jac_splice_orc/grpc_local/__init__.py
@@ -0,0 +1,1 @@
+"""Importing required modules and classes."""
diff --git a/jac-splice-orc/jac_splice_orc/grpc_local/module_service.proto b/jac-splice-orc/jac_splice_orc/grpc_local/module_service.proto
new file mode 100644
index 0000000000..a626302b9c
--- /dev/null
+++ b/jac-splice-orc/jac_splice_orc/grpc_local/module_service.proto
@@ -0,0 +1,20 @@
+// module_service.proto
+
+syntax = "proto3";
+
+service ModuleService {
+    rpc ExecuteMethod(MethodRequest) returns (MethodResponse) {}
+}
+
+message MethodRequest {
+    string obj_id = 1; // ID of the object instance (empty for module-level)
+    string method_name = 2;
+    repeated string args = 3; // Serialized arguments
+    map<string, string> kwargs = 4; // Serialized keyword arguments
+}
+
+message MethodResponse {
+    string result = 1; // Serialized result
+    string obj_id = 2; // Object ID if result is an object
+    bool is_callable = 3; // Indicates if the result is callable
+}
diff --git a/jac-splice-orc/jac_splice_orc/managers/__init__.py b/jac-splice-orc/jac_splice_orc/managers/__init__.py
new file mode 100644
index 0000000000..697254dc6e
--- /dev/null
+++ b/jac-splice-orc/jac_splice_orc/managers/__init__.py
@@ -0,0 +1,1 @@
+"""Importing required modules and classes."""
diff --git a/jac-splice-orc/jac_splice_orc/managers/pod_manager.py b/jac-splice-orc/jac_splice_orc/managers/pod_manager.py
new file mode 100644
index 0000000000..6b4d1da8f8
--- /dev/null
+++ b/jac-splice-orc/jac_splice_orc/managers/pod_manager.py
@@ -0,0 +1,303 @@
+"""This module provides a FastAPI-based API for managing Kubernetes pods."""
+
+import logging
+import os
+import time
+
+from typing import Any, List
+
+from fastapi import Body, FastAPI, HTTPException, Query
+
+import grpc
+
+from grpc_local import module_service_pb2, module_service_pb2_grpc
+
+from kubernetes import client, config
+
+from pydantic import BaseModel
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
+
+app = FastAPI()
+
+
+class PodManager:
+    """Manages Kubernetes pods and services for modules."""
+
+    def __init__(self, namespace: str = "default") -> None:
+        """Initialize Kubernetes client."""
+        if os.getenv("TEST_ENV") == "true":
+            logging.info("Running in test environment, skipping Kubernetes config.")
+        else:
+            try:
+                config.load_incluster_config()
+            except config.ConfigException:
+                config.load_kube_config()
+        self.v1 = client.CoreV1Api()
+        self.namespace = os.getenv("NAMESPACE", namespace)
+
+    def create_requirements_file(self, module_name: str, module_config: dict) -> str:
+        """Generate a requirements.txt file based on the module configuration."""
+        requirements_path = f"/app/requirements/{module_name}/requirements.txt"
+
+        # Ensure the module directory exists
+        os.makedirs(os.path.dirname(requirements_path), exist_ok=True)
+
+        with open(requirements_path, "w") as f:
+            dependencies = module_config.get("dependency", [])
+            for dep in dependencies:
+                f.write(f"{dep}\n")
+
+        logging.info(
+            f"Created requirements.txt for {module_name} at {requirements_path}"
+        )
+        return requirements_path
+
+    def create_pod(self, module_name: str, module_config: dict) -> Any:
+        """Create a pod and service for the given module."""
+        image_name = os.getenv("IMAGE_NAME", "ashishmahendra/jac-splice-orc:0.1.8")
+
+        pod_name = f"{module_name}-pod"
+        service_name = f"{module_name}-service"
+        logging.info(
+            f"Creating pod {pod_name}...\n Image: {image_name}\n Service: {service_name}\n Namespace: {self.namespace}"
+        )
+        try:
+            pod_info = self.v1.read_namespaced_pod(
+                name=pod_name, namespace=self.namespace
+            )
+            if pod_info.status.phase == "Running":
+                return {"message": f"Pod {pod_name} is already running."}
+            else:
+                raise HTTPException(
+                    status_code=409,
+                    detail=f"Pod {pod_name} exists but is not running.",
+                )
+        except client.exceptions.ApiException as e:
+            requirements_file_path = self.create_requirements_file(
+                module_name, module_config
+            )
+            if e.status == 404:
+                # Pod does not exist, so create it
+                pod_manifest = {
+                    "apiVersion": "v1",
+                    "kind": "Pod",
+                    "metadata": {
+                        "name": pod_name,
+                        "labels": {"app": pod_name},
+                    },
+                    "spec": {
+                        "containers": [
+                            {
+                                "name": "module-container",
+                                "image": image_name,
+                                "env": [{"name": "MODULE_NAME", "value": module_name}],
+                                "ports": [{"containerPort": 50051}],
+                                "resources": {
+                                    "requests": {
+                                        "cpu": module_config["lib_cpu_req"],
+                                        "memory": module_config["lib_mem_size_req"],
+                                    },
+                                    "limits": {
+                                        "cpu": module_config["lib_cpu_req"],
+                                        "memory": module_config["lib_mem_size_req"],
+                                    },
+                                },
+                                "volumeMounts": [
+                                    {
+                                        "name": "requirements-volume",
+                                        "mountPath": f"/app/requirements/{module_name}",
+                                    }
+                                ],
+                            }
+                        ],
+                        "volumes": [
+                            {
+                                "name": "requirements-volume",
+                                "configMap": {"name": f"{module_name}-requirements"},
+                            }
+                        ],
+                        "restartPolicy": "Never",
+                    },
+                }
+
+                _ = self.v1.create_namespaced_config_map(
+                    self.namespace,
+                    body={
+                        "metadata": {"name": f"{module_name}-requirements"},
+                        "data": {
+                            "requirements.txt": open(requirements_file_path, "r").read()
+                        },
+                    },
+                )
+                self.v1.create_namespaced_pod(self.namespace, body=pod_manifest)
+                logging.info(f"Pod {pod_name} created.")
+                self.wait_for_pod_ready(pod_name)
+
+        # Create Service
+        try:
+            _ = self.v1.read_namespaced_service(
+                name=service_name, namespace=self.namespace
+            )
+            logging.info(f"Service {service_name} already exists.")
+        except client.exceptions.ApiException as e:
+            if e.status == 404:
+                service_manifest = {
+                    "apiVersion": "v1",
+                    "kind": "Service",
+                    "metadata": {"name": service_name},
+                    "spec": {
+                        "selector": {"app": pod_name},
+                        "ports": [
+                            {"protocol": "TCP", "port": 50051, "targetPort": 50051}
+                        ],
+                        "type": "ClusterIP",
+                    },
+                }
+                self.v1.create_namespaced_service(self.namespace, body=service_manifest)
+                logging.info(f"Service {service_name} created.")
+
+        return {"message": f"Pod {pod_name} and service {service_name} created."}
+
+    def delete_pod(self, module_name: str) -> Any:
+        """Delete the pod and service for the given module."""
+        pod_name = f"{module_name}-pod"
+        service_name = f"{module_name}-service"
+
+        # Delete Pod
+        try:
+            self.v1.delete_namespaced_pod(name=pod_name, namespace=self.namespace)
+            logging.info(f"Pod {pod_name} deleted.")
+        except client.exceptions.ApiException:
+            raise HTTPException(status_code=404, detail=f"Pod {pod_name} not found.")
+
+        # Delete Service
+        try:
+            self.v1.delete_namespaced_service(
+                name=service_name, namespace=self.namespace
+            )
+            logging.info(f"Service {service_name} deleted.")
+        except client.exceptions.ApiException:
+            raise HTTPException(
+                status_code=404, detail=f"Service {service_name} not found."
+            )
+
+        return {"message": f"Pod {pod_name} and service {service_name} deleted."}
+
+    def wait_for_pod_ready(self, pod_name: str) -> None:
+        """Wait until the pod is ready."""
+        max_retries = 30
+        retries = 0
+        while retries < max_retries:
+            pod_info = self.v1.read_namespaced_pod(
+                name=pod_name, namespace=self.namespace
+            )
+            if pod_info.status.phase == "Running":
+                logging.info(
+                    f"Pod {pod_name} is running with IP {pod_info.status.pod_ip}"
+                )
+                return
+            retries += 1
+            time.sleep(2)
+        raise Exception(f"Timeout: Pod {pod_name} failed to reach 'Running' state.")
+
+    def get_pod_service_ip(self, module_name: str) -> str:
+        """Look up the service IP for the pod corresponding to the module."""
+        service_name = f"{module_name}-service"
+        try:
+            service_info = self.v1.read_namespaced_service(
+                name=service_name, namespace=self.namespace
+            )
+            return service_info.spec.cluster_ip
+        except client.exceptions.ApiException:
+            raise HTTPException(
+                status_code=404, detail=f"Service for module {module_name} not found."
+            )
+
+    def forward_to_pod(
+        self,
+        module_name: str,
+        method_name: str,
+        obj_id: str,
+        args: list,
+        kwargs: dict,
+    ) -> Any:
+        import json
+
+        pod_name = f"{module_name}-pod"
+        service_ip = self.get_pod_service_ip(module_name)
+
+        self.wait_for_pod_ready(pod_name)
+
+        serialized_args = [json.dumps(arg) for arg in args]
+        serialized_kwargs = {key: json.dumps(value) for key, value in kwargs.items()}
+        channel = grpc.insecure_channel(f"{service_ip}:50051")
+        stub = module_service_pb2_grpc.ModuleServiceStub(channel)
+        request = module_service_pb2.MethodRequest(
+            obj_id=obj_id,
+            method_name=method_name,
+            args=serialized_args,
+            kwargs=serialized_kwargs,
+        )
+        max_retries = 5
+        for _ in range(max_retries):
+            try:
+                response = stub.ExecuteMethod(request)
+                if response.obj_id:
+                    return {
+                        "obj_id": response.obj_id,
+                        "is_callable": response.is_callable,
+                    }
+                else:
+                    return {"result": response.result}
+            except grpc.RpcError as e:
+                if e.code() == grpc.StatusCode.UNAVAILABLE:
+                    time.sleep(2)
+                    continue
+                else:
+                    logging.error(f"gRPC error: {e.details()}")
+                    raise HTTPException(
+                        status_code=500, detail=f"gRPC error: {e.details()}"
+                    )
+        logging.error("gRPC server unavailable after retries")
+        raise HTTPException(
+            status_code=500, detail="gRPC server unavailable after retries"
+        )
+
+
+pod_manager = PodManager()
+
+
+class RunModuleRequest(BaseModel):
+    """Request for running a module."""
+
+    args: List[Any] = []
+    kwargs: dict[str, Any] = {}
+
+
+@app.post("/run_module")
+async def run_module(
+    module_name: str = Query(..., description="Name of the module"),
+    method_name: str = Query(..., description="Name of the method"),
+    obj_id: str = Query(None, description="Object ID"),
+    request: RunModuleRequest = Body(
+        ..., description="Arguments and keyword arguments"
+    ),
+):
+    """Run a module and return the result."""
+    return pod_manager.forward_to_pod(
+        module_name, method_name, obj_id, request.args, request.kwargs
+    )
+
+
+@app.post("/create_pod/{module_name}")
+def create_pod(module_name: str, module_config: dict = Body(...)) -> Any:
+    """Create a pod and service for the given module and return the result."""
+    return pod_manager.create_pod(module_name, module_config)
+
+
+@app.delete("/delete_pod/{module_name}")
+def delete_pod(module_name: str) -> Any:
+    """Delete the pod and service for the given module and return the result."""
+    return pod_manager.delete_pod(module_name)
diff --git a/jac-splice-orc/jac_splice_orc/managers/proxy_manager.py b/jac-splice-orc/jac_splice_orc/managers/proxy_manager.py
new file mode 100644
index 0000000000..a06027ec42
--- /dev/null
+++ b/jac-splice-orc/jac_splice_orc/managers/proxy_manager.py
@@ -0,0 +1,139 @@
+import requests
+import json
+import numpy as np
+import base64
+
+
+class PodManagerProxy:
+    def __init__(self, pod_manager_url: str):
+        self.pod_manager_url = pod_manager_url
+
+    def create_pod(self, module_name: str, module_config: dict):
+        """Send a request to the pod manager to create the pod and service."""
+        response = requests.post(
+            f"{self.pod_manager_url}/create_pod/{module_name}", json=module_config
+        )
+        if response.status_code == 200:
+            return response.json()
+        else:
+            raise Exception(f"Failed to create pod: {response.text}")
+
+    def delete_pod(self, module_name: str):
+        """Send a request to the pod manager to delete the pod and service."""
+        response = requests.delete(f"{self.pod_manager_url}/delete_pod/{module_name}")
+        if response.status_code == 200:
+            return response.json()
+        else:
+            raise Exception(f"Failed to delete pod: {response.text}")
+
+    def run_module(self, module_name, method_name, obj_id, args, kwargs):
+        # Serialize arguments
+        def serialize_arg(arg):
+            if isinstance(arg, (int, float, str, bool)):
+                return {"type": "primitive", "value": arg}
+            elif isinstance(arg, np.generic):
+                return {"type": "primitive", "value": arg.item()}
+            elif isinstance(arg, (list, dict, tuple)):
+                return {"type": "json", "value": arg}
+            elif isinstance(arg, np.ndarray):
+                if arg.ndim == 0:
+                    # Zero-dimensional array (NumPy scalar)
+                    return {"type": "primitive", "value": arg.item()}
+                elif arg.dtype.kind == "O":
+                    return {"type": "ndarray_list", "value": arg.tolist()}
+                else:
+                    data_bytes = arg.tobytes()
+                    data_b64 = base64.b64encode(data_bytes).decode("utf-8")
+                    return {
+                        "type": "ndarray",
+                        "data": data_b64,
+                        "dtype": arg.dtype.str,
+                        "shape": arg.shape,
+                    }
+            elif isinstance(arg, RemoteObjectProxy):
+                return {"type": "object", "obj_id": arg.obj_id}
+            else:
+                raise Exception(f"Unsupported argument type: {type(arg)}")
+
+        serialized_args = [serialize_arg(arg) for arg in args]
+        serialized_kwargs = {key: serialize_arg(value) for key, value in kwargs.items()}
+
+        request_data = {
+            "args": serialized_args,
+            "kwargs": serialized_kwargs,
+        }
+
+        response = requests.post(
+            f"{self.pod_manager_url}/run_module",
+            params={
+                "module_name": module_name,
+                "method_name": method_name,
+                "obj_id": obj_id,
+            },
+            json=request_data,
+        )
+        if response.status_code == 200:
+            return response.json()
+        else:
+            raise Exception(f"Failed to run module: {response.text}")
+
+
+class ModuleProxy:
+    def __init__(self, pod_manager_url: str):
+        self.pod_manager = PodManagerProxy(pod_manager_url)
+
+    def get_module_proxy(self, module_name, module_config):
+        """Creates a proxy object for the module running in the pod."""
+        self.pod_manager.create_pod(module_name, module_config)
+        return RemoteObjectProxy(module_name, self.pod_manager)
+
+
+class RemoteObjectProxy:
+    def __init__(self, module_name, pod_manager, obj_id=None):
+        self.module_name = module_name
+        self.pod_manager = pod_manager
+        self.obj_id = obj_id  # None for module-level
+
+    def __getattr__(self, method_name):
+        def method(*args, **kwargs):
+            result = self.pod_manager.run_module(
+                self.module_name,
+                method_name,
+                obj_id=self.obj_id,
+                args=args,
+                kwargs=kwargs,
+            )
+
+            if "obj_id" in result:
+                return RemoteObjectProxy(
+                    self.module_name, self.pod_manager, obj_id=result["obj_id"]
+                )
+            else:
+                result_data = result.get("result")
+                if isinstance(result_data, str):
+                    result_data = json.loads(result_data)
+
+                # Deserialize the result based on its type
+                if result_data["type"] == "primitive":
+                    return result_data["value"]
+                elif result_data["type"] == "json":
+                    return result_data["value"]
+                elif result_data["type"] == "ndarray":
+                    data_bytes = base64.b64decode(result_data["data"])
+                    array = np.frombuffer(data_bytes, dtype=result_data["dtype"])
+                    array = array.reshape(result_data["shape"])
+                    return array
+                elif result_data["type"] == "ndarray_list":
+                    value = result_data["value"]
+                    return np.array(value, dtype=object)
+                elif result_data["type"] == "object":
+                    return RemoteObjectProxy(
+                        self.module_name, self.pod_manager, obj_id=result_data["obj_id"]
+                    )
+                else:
+                    raise Exception("Unknown result type received from server")
+
+        return method
+
+    def __call__(self, *args, **kwargs):
+        return self.__getattr__("__call__")(*args, **kwargs)
diff --git a/jac-splice-orc/jac_splice_orc/plugin/__init__.py b/jac-splice-orc/jac_splice_orc/plugin/__init__.py
new file mode 100644
index 0000000000..697254dc6e
--- /dev/null
+++ b/jac-splice-orc/jac_splice_orc/plugin/__init__.py
@@ -0,0 +1,1 @@
+"""Importing required modules and classes."""
diff --git a/jac-splice-orc/jac_splice_orc/plugin/splice_plugin.py b/jac-splice-orc/jac_splice_orc/plugin/splice_plugin.py
new file mode 100644
index 0000000000..c8bae73165
--- /dev/null
+++ b/jac-splice-orc/jac_splice_orc/plugin/splice_plugin.py
@@ -0,0 +1,447 @@
+"""JAC Splice-Orchestrator Plugin."""
+
+import time
+import types
+from typing import Optional, Union
+
+from kubernetes import client, config
+from jaclang.cli.cmdreg import cmd_registry
+from jac_splice_orc.managers.proxy_manager import ModuleProxy
+from jac_splice_orc.config.config_loader import ConfigLoader
+
+import pluggy
+import logging
+
+logging.basicConfig(level=logging.INFO)
+
+hookimpl = pluggy.HookimplMarker("jac")
+
+# Initialize ConfigLoader
+config_loader = ConfigLoader()
+
+
+class SpliceOrcPlugin:
+    """JAC Splice-Orchestrator Plugin."""
+
+    @classmethod
+    def create_namespace(cls, namespace_name):
+        """Create a new namespace if it does not exist."""
+        logging.info(f"Creating namespace '{namespace_name}'")
+        try:
+            config.load_kube_config()
+        except config.ConfigException:
+            config.load_incluster_config()
+        v1 = client.CoreV1Api()
+
+        # Check if the namespace exists
+        namespaces = v1.list_namespace()
+        if any(ns.metadata.name == namespace_name for ns in namespaces.items):
+            logging.info(f"Namespace '{namespace_name}' already exists.")
+        else:
+            ns = client.V1Namespace(metadata=client.V1ObjectMeta(name=namespace_name))
+            v1.create_namespace(ns)
+            logging.info(f"Namespace '{namespace_name}' created.")
+
+    @classmethod
+    def create_service_account(cls, namespace):
+        v1 = client.CoreV1Api()
+        service_account_name = config_loader.get(
+            "kubernetes", "service_account_name", default="jac-orc-sa"
+        )
+
+        # Check if the ServiceAccount already exists
+        try:
+            v1.read_namespaced_service_account(
+                name=service_account_name, namespace=namespace
+            )
+            logging.info(
+                f"ServiceAccount '{service_account_name}' already exists in namespace '{namespace}'."
+            )
+        except client.exceptions.ApiException as e:
+            if e.status == 404:
+                # Create the ServiceAccount
+                sa = client.V1ServiceAccount(
+                    metadata=client.V1ObjectMeta(name=service_account_name)
+                )
+                v1.create_namespaced_service_account(namespace=namespace, body=sa)
+                logging.info(
+                    f"ServiceAccount '{service_account_name}' created in namespace '{namespace}'."
+                )
+            else:
+                logging.error(f"Error creating ServiceAccount: {e}")
+                raise
+
+        # Create the Role and RoleBinding
+        cls.create_role_and_binding(namespace, service_account_name)
+
+    @classmethod
+    def create_role_and_binding(cls, namespace, service_account_name):
+        rbac_api = client.RbacAuthorizationV1Api()
+
+        role_name = "smartimport-role"
+        role_binding_name = "smartimport-rolebinding"
+
+        # Define the Role with updated permissions
+        role = client.V1Role(
+            metadata=client.V1ObjectMeta(name=role_name, namespace=namespace),
+            rules=[
+                # Permissions for pods and services
+                client.V1PolicyRule(
+                    api_groups=[""],
+                    resources=[
+                        "pods",
+                        "services",
+                        "configmaps",
+                    ],
+                    verbs=["get", "watch", "list", "create", "update", "delete"],
+                ),
+                # Permissions for deployments
+                client.V1PolicyRule(
+                    api_groups=["apps"],
+                    resources=["deployments"],
+                    verbs=["get", "watch", "list", "create", "update", "delete"],
+                ),
+            ],
+        )
+        try:
+            rbac_api.read_namespaced_role(name=role_name, namespace=namespace)
+            logging.info(
+                f"Role '{role_name}' already exists in namespace '{namespace}'."
+            )
+        except client.exceptions.ApiException as e:
+            if e.status == 404:
+                # Create the Role
+                rbac_api.create_namespaced_role(namespace=namespace, body=role)
+                logging.info(f"Role '{role_name}' created in namespace '{namespace}'.")
+            else:
+                logging.error(f"Error creating Role: {e}")
+                raise
+
+        # Define the RoleBinding
+        role_binding = client.V1RoleBinding(
+            metadata=client.V1ObjectMeta(name=role_binding_name, namespace=namespace),
+            subjects=[
+                client.RbacV1Subject(
+                    kind="ServiceAccount",
+                    name=service_account_name,
+                    namespace=namespace,
+                )
+            ],
+            role_ref=client.V1RoleRef(
+                kind="Role",
+                name=role_name,
+                api_group="rbac.authorization.k8s.io",
+            ),
+        )
+
+        # Check if the RoleBinding exists
+        try:
+            rbac_api.read_namespaced_role_binding(
+                name=role_binding_name, namespace=namespace
+            )
+            logging.info(
+                f"RoleBinding '{role_binding_name}' already exists in namespace '{namespace}'."
+            )
+        except client.exceptions.ApiException as e:
+            if e.status == 404:
+                # Create the RoleBinding
+                rbac_api.create_namespaced_role_binding(
+                    namespace=namespace, body=role_binding
+                )
+                logging.info(
+                    f"RoleBinding '{role_binding_name}' created in namespace '{namespace}'."
+                )
+            else:
+                logging.error(f"Error creating RoleBinding: {e}")
+                raise
+
+    @classmethod
+    def apply_pod_manager_yaml(cls, namespace):
+        """Generate and apply the Pod Manager Deployment and Service."""
+        try:
+            config.load_kube_config()
+        except config.ConfigException:
+            config.load_incluster_config()
+
+        # Read configuration
+        kubernetes_config = config_loader.get("kubernetes")
+        pod_manager_config = kubernetes_config["pod_manager"]
+        service_account_name = kubernetes_config.get(
+            "service_account_name", "jac-orc-sa"
+        )
+        deployment_name = pod_manager_config.get(
+            "deployment_name", "pod-manager-deployment"
+        )
+        container_name = pod_manager_config.get("container_name", "pod-manager")
+        image_name = pod_manager_config.get("image_name")
+        container_port = pod_manager_config.get("container_port", 8000)
+        env_vars = pod_manager_config.get("env_vars", {})
+        resources = pod_manager_config.get("resources", {})
+        service_name = pod_manager_config.get("service_name", "pod-manager-service")
+        service_type = pod_manager_config.get("service_type", "LoadBalancer")
+
+        # Create the Deployment object
+        apps_v1 = client.AppsV1Api()
+
+        # Define container environment variables
+        env_list = [
+            client.V1EnvVar(name=key, value=str(value))
+            for key, value in env_vars.items()
+        ]
+
+        # Define container resources
+        resource_requirements = client.V1ResourceRequirements(
+            limits=resources.get("limits"), requests=resources.get("requests")
+        )
+
+        # Define the container
+        container = client.V1Container(
+            name=container_name,
+            image=image_name,
+            ports=[client.V1ContainerPort(container_port=container_port)],
+            env=env_list,
+            resources=resource_requirements,
+        )
+
+        # Define the Pod template spec
+        template = client.V1PodTemplateSpec(
+            metadata=client.V1ObjectMeta(labels={"app": container_name}),
+            spec=client.V1PodSpec(
+                containers=[container], service_account_name=service_account_name
+            ),
+        )
+
+        # Define the Deployment spec
+        spec = client.V1DeploymentSpec(
+            replicas=1,
+            selector=client.V1LabelSelector(match_labels={"app": container_name}),
+            template=template,
+        )
+
+        # Define the Deployment
+        deployment = client.V1Deployment(
+            api_version="apps/v1",
+            kind="Deployment",
+            metadata=client.V1ObjectMeta(name=deployment_name, namespace=namespace),
+            spec=spec,
+        )
+
+        # Create or update the Deployment
+        try:
+            existing_deployment = apps_v1.read_namespaced_deployment(
+                name=deployment_name, namespace=namespace
+            )
+            # Update the deployment if it exists
+            apps_v1.patch_namespaced_deployment(
+                name=deployment_name, namespace=namespace, body=deployment
+            )
+            logging.info(
+                f"Updated Deployment '{deployment_name}' in namespace '{namespace}'"
+            )
+        except client.exceptions.ApiException as e:
+            if e.status == 404:
+                # Create the Deployment
+                apps_v1.create_namespaced_deployment(
+                    namespace=namespace, body=deployment
+                )
+                logging.info(
+                    f"Created Deployment '{deployment_name}' in namespace '{namespace}'"
+                )
+            else:
+                logging.error(f"Error creating/updating Deployment: {e}")
+                raise
+
+        # Create the Service object
+        v1 = client.CoreV1Api()
+
+        service = client.V1Service(
+            api_version="v1",
+            kind="Service",
+            metadata=client.V1ObjectMeta(name=service_name, namespace=namespace),
+            spec=client.V1ServiceSpec(
+                selector={"app": container_name},
+                ports=[
+                    client.V1ServicePort(
+                        protocol="TCP", port=container_port, target_port=container_port
+                    )
+                ],
+                type=service_type,
+            ),
+        )
+
+        # Create or update the Service
+        try:
+            _ = v1.read_namespaced_service(name=service_name, namespace=namespace)
+            # Update the service if it exists
+            v1.patch_namespaced_service(
+                name=service_name, namespace=namespace, body=service
+            )
+            logging.info(f"Updated Service '{service_name}' in namespace '{namespace}'")
+        except client.exceptions.ApiException as e:
+            if e.status == 404:
+                # Create the Service
+                v1.create_namespaced_service(namespace=namespace, body=service)
+                logging.info(
+                    f"Created Service '{service_name}' in namespace '{namespace}'"
+                )
+            else:
+                logging.error(f"Error creating/updating Service: {e}")
+                raise
+
+    @classmethod
+    def configure_pod_manager_url(cls, namespace):
+        service_name = config_loader.get(
+            "kubernetes", "pod_manager", "service_name", default="pod-manager-service"
+        )
+        if not namespace:
+            namespace = config_loader.get(
+                "kubernetes", "namespace", default="jac-splice-orc"
+            )
+
+        url = cls.get_loadbalancer_url(service_name, namespace)
+        if url:
+            pod_manager_url_local = f"http://{url}:8000"
+
+            # Update the config file with the new pod_manager_url
+            config_loader.set(["environment", "POD_MANAGER_URL"], pod_manager_url_local)
+            config_loader.save_config()
+
+            logging.info(
+                f"Pod manager URL updated in config file: {pod_manager_url_local}"
+            )
+        else:
+            logging.error("Failed to retrieve the pod_manager_url.")
+
+    @classmethod
+    def get_loadbalancer_url(cls, service_name, namespace, timeout=60, interval=5):
+        try:
+            config.load_kube_config()
+        except config.ConfigException:
+            config.load_incluster_config()
+
+        v1 = client.CoreV1Api()
+        start_time = time.time()
+        while True:
+            try:
+                service = v1.read_namespaced_service(
+                    name=service_name, namespace=namespace
+                )
+                ingress = service.status.load_balancer.ingress
+                if ingress:
+                    ip = ingress[0].ip
+                    hostname = ingress[0].hostname
+                    logging.info(f"ip: {ip}, host: {hostname}")
+                    if ip:
+                        return ip
+                    elif hostname:
+                        return hostname
+                    else:
+                        logging.info("Waiting for external IP to be assigned...")
+            except client.exceptions.ApiException as e:
+                logging.error(f"Error retrieving LoadBalancer URL: {e}")
+                return None
+            if (time.time() - start_time) > timeout:
+                logging.error(
+                    f"Timed out after {timeout} seconds waiting for external IP."
+                )
+                return None
+
+            time.sleep(interval)
+
+    @staticmethod
+    @hookimpl
+    def create_cmd() -> None:
+        """Creating Jac CLI commands."""
+
+        @cmd_registry.register
+        def orc_initialize(namespace: str) -> None:
+            """Initialize the Pod Manager and Kubernetes system.
+
+            :param namespace: Kubernetes namespace to use.
+            """
+            # Use the provided namespace if given, else read from config
+            if not namespace:
+                namespace = config_loader.get(
+                    "kubernetes", "namespace", default="jac-splice-orc"
+                )
+            else:
+                # Update the namespace in the config
+                config_loader.set(
+                    ["kubernetes", "pod_manager", "env_vars", "NAMESPACE"], namespace
+                )
+                config_loader.set(["kubernetes", "namespace"], namespace)
+                config_loader.save_config()
+
+            logging.info(f"Initializing Pod Manager in namespace '{namespace}'")
+
+            # Call the class methods to perform initialization
+            SpliceOrcPlugin.create_namespace(namespace)
+            SpliceOrcPlugin.create_service_account(namespace)
+            SpliceOrcPlugin.apply_pod_manager_yaml(namespace)
+            SpliceOrcPlugin.configure_pod_manager_url(namespace)
+
+            logging.info("Initialization complete.")
+
+    @staticmethod
+    @hookimpl
+    def jac_import(
+        target: str,
+        base_path: str,
+        absorb: bool,
+        cachable: bool,
+        mdl_alias: Optional[str],
+        override_name: Optional[str],
+        lng: Optional[str],
+        items: Optional[dict[str, Union[str, Optional[str]]]],
+        reload_module: Optional[bool],
+    ) -> tuple[types.ModuleType, ...]:
+        """Core Import Process with Kubernetes Pod Integration."""
+        from jaclang.runtimelib.importer import (
+            ImportPathSpec,
+            JacImporter,
+            PythonImporter,
+        )
+        from jaclang.runtimelib.machine import JacMachine, JacProgram
+
+        module_config = config_loader.get("module_config", default={})
+        if target in module_config and module_config[target]["load_type"] == "remote":
+            pod_manager_url = config_loader.get("environment", "POD_MANAGER_URL")
+            if not pod_manager_url:
+                logging.error(
+                    "POD_MANAGER_URL is not set in the config file. Please run 'jac orc_initialize' to initialize the system."
+                )
+                raise Exception("POD_MANAGER_URL is not set.")
+            proxy = ModuleProxy(pod_manager_url)
+            remote_module_proxy = proxy.get_module_proxy(
+                module_name=target, module_config=module_config[target]
+            )
+            return (remote_module_proxy,)
+        spec = ImportPathSpec(
+            target,
+            base_path,
+            absorb,
+            cachable,
+            mdl_alias,
+            override_name,
+            lng,
+            items,
+        )
+
+        jac_machine = JacMachine.get(base_path)
+        if not jac_machine.jac_program:
+            jac_machine.attach_program(
+                JacProgram(mod_bundle=None, bytecode=None, sem_ir=None)
+            )
+
+        if lng == "py":
+            import_result = PythonImporter(JacMachine.get()).run_import(spec)
+        else:
+            import_result = JacImporter(JacMachine.get()).run_import(
+                spec, reload_module
+            )
+
+        return (
+            (import_result.ret_mod,)
+            if absorb or not items
+            else tuple(import_result.ret_items)
+        )
diff --git a/jac-splice-orc/jac_splice_orc/server/__init__.py b/jac-splice-orc/jac_splice_orc/server/__init__.py
new file mode 100644
index 0000000000..697254dc6e
--- /dev/null
+++ b/jac-splice-orc/jac_splice_orc/server/__init__.py
@@ -0,0 +1,1 @@
+"""Importing required modules and classes."""
diff --git a/jac-splice-orc/jac_splice_orc/server/server.py b/jac-splice-orc/jac_splice_orc/server/server.py
new file mode 100644
index 0000000000..a295586205
--- /dev/null
+++ b/jac-splice-orc/jac_splice_orc/server/server.py
@@ -0,0 +1,204 @@
+# server.py
+
+import grpc
+from concurrent import futures
+import importlib
+import threading
+import uuid
+from grpc_local import module_service_pb2_grpc
+from grpc_local import module_service_pb2
+import logging
+import traceback
+
+logging.basicConfig(level=logging.DEBUG, format="%(asctime)s %(levelname)s %(message)s")
+
+
+class ObjectRegistry:
+    """Thread-safe registry for storing objects with unique IDs."""
+
+    def __init__(self):
+        self.lock = threading.Lock()
+        self.objects = {}
+        logging.debug("ObjectRegistry initialized.")
+
+    def add(self, obj):
+        obj_id = str(uuid.uuid4())
+        with self.lock:
+            self.objects[obj_id] = obj
+            logging.debug(f"Object added with ID {obj_id}: {obj}")
+        return obj_id
+
+    def get(self, obj_id):
+        with self.lock:
+            obj = self.objects.get(obj_id)
+            logging.debug(f"Object retrieved with ID {obj_id}: {obj}")
+            return obj
+
+    def remove(self, obj_id):
+        with self.lock:
+            if obj_id in self.objects:
+                del self.objects[obj_id]
+                logging.debug(f"Object with ID {obj_id} removed.")
+
+
+object_registry = ObjectRegistry()
+
+
+class ModuleService(module_service_pb2_grpc.ModuleServiceServicer):
+    def __init__(self, module_name):
+        logging.debug(f"Initializing ModuleService with module '{module_name}'")
+        try:
+            self.module = importlib.import_module(module_name)
+            logging.info(f"Module '{module_name}' imported successfully.")
+        except Exception as e:
+            logging.error(f"Failed to import module '{module_name}': {e}")
+            traceback.print_exc()
+            raise e
+
+    def ExecuteMethod(self, request, context):
+        try:
+            logging.debug(f"Received ExecuteMethod request: {request}")
+            if request.obj_id:
+                # Method call on an object instance
+                obj = object_registry.get(request.obj_id)
+                if obj is None:
+                    error_msg = f"Object with ID {request.obj_id} not found"
+                    logging.error(error_msg)
+                    raise Exception(error_msg)
+            else:
+                # Method call on the module
+                obj = self.module
+                logging.debug(
+                    f"Using module '{self.module.__name__}' for method execution."
+                )
+
+            # Get the attribute or method
+            attr = getattr(obj, request.method_name, None)
+            if attr is None:
+                error_msg = f"Attribute '{request.method_name}' not found in '{obj}'"
+                logging.error(error_msg)
+                raise AttributeError(error_msg)
+
+            logging.debug(f"Executing method '{request.method_name}' on '{obj}'")
+
+            # Deserialize arguments
+            import json
+
+            def deserialize_arg(arg):
+                import numpy as np
+                import base64
+
+                if arg["type"] == "primitive":
+                    return arg["value"]
+                elif arg["type"] == "json":
+                    return arg["value"]
+                elif arg["type"] == "ndarray":
+                    data_bytes = base64.b64decode(arg["data"])
+                    array = np.frombuffer(data_bytes, dtype=arg["dtype"])
+                    array = array.reshape(arg["shape"])
+                    return array
+                elif arg["type"] == "ndarray_list":
+                    value = arg["value"]
+                    return np.array(value, dtype=object)
+                elif arg["type"] == "object":
+                    obj = object_registry.get(arg["obj_id"])
+                    if obj is None:
+                        raise Exception(f"Object with ID {arg['obj_id']} not found")
+                    return obj
+                else:
+                    raise Exception(f"Unknown argument type: {arg.get('type')}")
+
+            args = [deserialize_arg(json.loads(arg)) for arg in request.args]
+            kwargs = {
+                key: deserialize_arg(json.loads(value))
+                for key, value in request.kwargs.items()
+            }
+
+            logging.debug(
+                f"Arguments after deserialization: args={args}, kwargs={kwargs}"
+            )
+
+            if callable(attr):
+                result = attr(*args, **kwargs)
+            else:
+                result = attr
+
+            logging.debug(f"Execution result: {result}")
+
+            def serialize_result(res):
+                import numpy as np
+                import base64
+
+                if isinstance(res, (int, float, str, bool)):
+                    logging.debug(f"Serializing primitive: {res}")
+                    return {"type": "primitive", "value": res}
+                elif isinstance(res, (np.integer, np.floating)):
+                    logging.debug(f"Serializing NumPy scalar: {res}")
+                    return {"type": "primitive", "value": res.item()}
+                elif isinstance(res, (list, dict, tuple)):
+                    logging.debug(f"Serializing JSON serializable object: {res}")
+                    return {"type": "json", "value": res}
+                elif isinstance(res, np.ndarray):
+                    logging.debug(
+                        f"Serializing ndarray with dtype: {res.dtype}, shape: {res.shape}"
+                    )
+                    if res.dtype.kind == "O":
+                        logging.debug(
+                            "Array has dtype 'object'; converting to list with 'ndarray_list' type."
+                        )
+                        return {"type": "ndarray_list", "value": res.tolist()}
+                    else:
+                        data_bytes = res.tobytes()
+                        data_b64 = base64.b64encode(data_bytes).decode("utf-8")
+                        return {
+                            "type": "ndarray",
+                            "data": data_b64,
+                            "dtype": str(res.dtype),
+                            "shape": res.shape,
+                        }
+                else:
+                    logging.debug(f"Serializing object instance: {res}")
+                    obj_id = object_registry.add(res)
+                    return {"type": "object", "obj_id": obj_id}
+
+            serialized_result = serialize_result(result)
+            response = module_service_pb2.MethodResponse(
+                result=json.dumps(serialized_result), is_callable=callable(result)
+            )
+            logging.debug(f"Returning serialized result: {response}")
+            return response
+        except Exception as e:
+            error_msg = f"Error during method execution: {str(e)}"
+            logging.error(error_msg)
+            traceback.print_exc()
+            context.set_details(error_msg)
+            context.set_code(grpc.StatusCode.INTERNAL)
+            return module_service_pb2.MethodResponse()
+
+
+def serve(module_name):
+    logging.info(f"Starting gRPC server for module '{module_name}'")
+    server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
+    module_service_pb2_grpc.add_ModuleServiceServicer_to_server(
+        ModuleService(module_name), server
+    )
+    server.add_insecure_port("[::]:50051")
+    server.start()
+    logging.info("gRPC server started and listening on port 50051")
+    server.wait_for_termination()
+
+
+if __name__ == "__main__":
+    import sys
+
+    if len(sys.argv) < 2:
+        print("Usage: python server.py <module_name>")
+        sys.exit(1)
+
+    module_name = sys.argv[1]
+    try:
+        serve(module_name)
+    except Exception as e:
+        logging.error(f"Server failed to start: {e}")
+        traceback.print_exc()
+        sys.exit(1)
diff --git a/jac-splice-orc/jac_splice_orc/utils/__init__.py b/jac-splice-orc/jac_splice_orc/utils/__init__.py
new file mode 100644
index 0000000000..697254dc6e
--- /dev/null
+++ b/jac-splice-orc/jac_splice_orc/utils/__init__.py
@@ -0,0 +1,1 @@
+"""Importing required modules and classes."""
diff --git a/jac-splice-orc/jac_splice_orc/utils/startup.sh b/jac-splice-orc/jac_splice_orc/utils/startup.sh
new file mode 100644
index 0000000000..255b43a1e3
--- /dev/null
+++ b/jac-splice-orc/jac_splice_orc/utils/startup.sh
@@ -0,0 +1,31 @@
+#!/bin/sh
+
+if [ "$SERVICE_TYPE" = "pod_manager" ]; then
+  echo "Starting Pod Manager with FastAPI..."
+  export PYTHONPATH=$PYTHONPATH:/app/grpc_local
+  echo "PYTHONPATH is set to $PYTHONPATH"
+  uvicorn pod_manager:app --host 0.0.0.0 --port 8000
+
+elif [ "$SERVICE_TYPE" = "module_service" ]; then
+  echo "Starting gRPC Module Service..."
+
+  # Check if a custom requirements.txt exists for the module
+  if [ -f "/app/requirements/$MODULE_NAME/requirements.txt" ]; then
+    echo "Found requirements.txt for $MODULE_NAME, installing dependencies..."
+    pip install -r "/app/requirements/$MODULE_NAME/requirements.txt"
+  else
+    # If no requirements.txt, attempt to install by module name
+    echo "No requirements.txt found, attempting to install module directly: $MODULE_NAME"
+    pip install "$MODULE_NAME"
+  fi
+
+  export PYTHONPATH=/app
+  export PYTHONPATH=$PYTHONPATH:/app/grpc_local
+
+  echo "Starting the module service with module: $MODULE_NAME"
+  python server/server.py "$MODULE_NAME"
+
+else
+  echo "Unknown service type: $SERVICE_TYPE"
+  exit 1
+fi
diff --git a/jac-splice-orc/requirements.txt b/jac-splice-orc/requirements.txt
new file mode 100644
index 0000000000..94432e77c9
--- /dev/null
+++ b/jac-splice-orc/requirements.txt
@@ -0,0 +1,6 @@
+kubernetes==26.1.0
+grpcio==1.57.0
+grpcio-tools==1.57.0
+protobuf==4.23.4
+pluggy==1.2.0
+jaclang
diff --git a/jac-splice-orc/setup.py b/jac-splice-orc/setup.py
new file mode 100644
index 0000000000..3306e8b701
--- /dev/null
+++ b/jac-splice-orc/setup.py
@@ -0,0 +1,31 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="jac-splice-orc",
+    version="0.1.0",
+    description="JAC Splice-Orchestrator: Kubernetes-based dynamic remote module management for JacLang",
+    author="Jason Mars",
+    author_email="jason@jaseci.org",
+    packages=find_packages(),
+    include_package_data=True,
+    package_data={
+        "jac_splice_orc.managers": ["pod_manager_deployment.yml"],
+    },
+    install_requires=[
+        "jaclang~=0.7.17",
+        "fastapi",
+        "uvicorn",
+        "grpcio",
+        "grpcio-tools",
+        "kubernetes",
+        "pydantic",
+        "requests",
+        "python-dotenv",
+    ],
+    entry_points={
+        "jac": [
+            "splice_orc = jac_splice_orc.plugin.splice_plugin:SpliceOrcPlugin",
+        ],
+    },
+    python_requires=">=3.11",
+)
diff --git a/jac/examples/micro/jac_cli.jac b/jac/examples/micro/jac_cli.jac
index 488ac29b73..a97cfdc4cf 100644
--- a/jac/examples/micro/jac_cli.jac
+++ b/jac/examples/micro/jac_cli.jac
@@ -19,8 +19,8 @@ obj Interface {
 }
 
 obj ShellCmd :cmd.Cmd: {
-    has prompt: str = "> ",
-        reg: Interface;
+    has reg: Interface,
+        prompt: str = "> ";
 
     can init(registry: Interface, *args: list, **kwargs: dict);
     can default(line: str);
diff --git a/jac/examples/reference/connect_expressions.py b/jac/examples/reference/connect_expressions.py
index 27e398239a..ebfeb0027d 100644
--- a/jac/examples/reference/connect_expressions.py
+++ b/jac/examples/reference/connect_expressions.py
@@ -1,59 +1,69 @@
 from __future__ import annotations
 from jaclang.plugin.feature import JacFeature as Jac
+from jaclang.plugin.builtin import *
 from dataclasses import dataclass
 
 
 @Jac.make_node(on_entry=[], on_exit=[])
 @dataclass(eq=False)
-class node_a:
+class node_a(Jac.Node):
     value: int
 
 
-@Jac.make_walker(
-    on_entry=[
-        Jac.DSFunc("create", Jac.get_root_type()),
-        Jac.DSFunc("travel", Jac.get_root_type() | node_a),
-    ],
-    on_exit=[],
-)
+@Jac.make_walker(on_entry=[Jac.DSFunc("create"), Jac.DSFunc("travel")], on_exit=[])
 @dataclass(eq=False)
-class Creator:
-
-    def create(self, here: Jac.get_root_type()) -> None:
-        end = here
+class Creator(Jac.Walker):
+    def create(self, _jac_here_: Jac.RootType) -> None:
+        end = _jac_here_
         i = 0
         while i < 7:
             if i % 2 == 0:
                 Jac.connect(
-                    end, (end := node_a(value=i)), Jac.build_edge(False, None, None)
+                    left=end,
+                    right=(end := node_a(value=i)),
+                    edge_spec=Jac.build_edge(
+                        is_undirected=False, conn_type=None, conn_assign=None
+                    ),
                 )
             else:
                 Jac.connect(
-                    end,
-                    (end := node_a(value=i + 10)),
-                    Jac.build_edge(False, MyEdge, (("val",), (i,))),
+                    left=end,
+                    right=(end := node_a(value=i + 10)),
+                    edge_spec=Jac.build_edge(
+                        is_undirected=False,
+                        conn_type=MyEdge,
+                        conn_assign=(("val",), (i,)),
+                    ),
                 )
             i += 1
 
-    def travel(self, here: Jac.get_root_type() | node_a) -> None:
+    def travel(self, _jac_here_: Jac.RootType | node_a) -> None:
         for i in Jac.edge_ref(
-            here,
-            None,
-            Jac.EdgeDir.OUT,
+            _jac_here_,
+            target_obj=None,
+            dir=Jac.EdgeDir.OUT,
             filter_func=lambda x: [i for i in x if isinstance(i, MyEdge) if i.val <= 6],
+            edges_only=False,
         ):
             print(i.value)
         if Jac.visit_node(
             self,
-            Jac.edge_ref(here, None, Jac.EdgeDir.OUT, filter_func=None),
+            Jac.edge_ref(
+                _jac_here_,
+                target_obj=None,
+                dir=Jac.EdgeDir.OUT,
+                filter_func=None,
+                edges_only=False,
+            ),
         ):
             pass
 
 
 @Jac.make_edge(on_entry=[], on_exit=[])
 @dataclass(eq=False)
-class MyEdge:
+class MyEdge(Jac.Edge):
     val: int = Jac.has_instance_default(gen_func=lambda: 5)
 
 
-Jac.spawn_call(Jac.get_root(), Creator())
+if __name__ == "__main__":
+    Jac.spawn_call(Jac.get_root(), Creator())
diff --git a/jac/examples/reference/data_spatial_calls.py b/jac/examples/reference/data_spatial_calls.py
index 79a1b16f0f..7280607ddf 100644
--- a/jac/examples/reference/data_spatial_calls.py
+++ b/jac/examples/reference/data_spatial_calls.py
@@ -1,37 +1,53 @@
 from __future__ import annotations
 from jaclang.plugin.feature import JacFeature as Jac
+from jaclang.plugin.builtin import *
 from dataclasses import dataclass
 
 
-@Jac.make_walker(on_entry=[Jac.DSFunc("func2", Jac.get_root_type())], on_exit=[])
+@Jac.make_walker(on_entry=[Jac.DSFunc("func2")], on_exit=[])
 @dataclass(eq=False)
-class Creator:
-
-    def func2(self, here: Jac.get_root_type()) -> None:
-        end = here
+class Creator(Jac.Walker):
+    def func2(self, _jac_here_: Jac.RootType) -> None:
+        end = _jac_here_
         i = 0
         while i < 5:
             Jac.connect(
-                end, (end := node_1(val=i + 1)), Jac.build_edge(False, None, None)
+                left=end,
+                right=(end := node_1(val=i + 1)),
+                edge_spec=Jac.build_edge(
+                    is_undirected=False, conn_type=None, conn_assign=None
+                ),
             )
             i += 1
         if Jac.visit_node(
             self,
-            Jac.edge_ref(here, None, Jac.EdgeDir.OUT, filter_func=None),
+            Jac.edge_ref(
+                _jac_here_,
+                target_obj=None,
+                dir=Jac.EdgeDir.OUT,
+                filter_func=None,
+                edges_only=False,
+            ),
         ):
             pass
 
 
-@Jac.make_node(on_entry=[Jac.DSFunc("func_1", Creator)], on_exit=[])
+@Jac.make_node(on_entry=[Jac.DSFunc("func_1")], on_exit=[])
 @dataclass(eq=False)
-class node_1:
+class node_1(Jac.Node):
     val: int
 
-    def func_1(self, here: Creator) -> None:
+    def func_1(self, _jac_here_: Creator) -> None:
         print("visiting ", self)
         if Jac.visit_node(
-            here,
-            Jac.edge_ref(self, None, Jac.EdgeDir.OUT, filter_func=None),
+            _jac_here_,
+            Jac.edge_ref(
+                self,
+                target_obj=None,
+                dir=Jac.EdgeDir.OUT,
+                filter_func=None,
+                edges_only=False,
+            ),
         ):
             pass
 
diff --git a/jac/examples/reference/data_spatial_references.py b/jac/examples/reference/data_spatial_references.py
index dad4d40dbf..05f40f5ef8 100644
--- a/jac/examples/reference/data_spatial_references.py
+++ b/jac/examples/reference/data_spatial_references.py
@@ -1,41 +1,57 @@
 from __future__ import annotations
 from jaclang.plugin.feature import JacFeature as Jac
+from jaclang.plugin.builtin import *
 from dataclasses import dataclass
 
 
-@Jac.make_walker(on_entry=[Jac.DSFunc("create", Jac.get_root_type())], on_exit=[])
+@Jac.make_walker(on_entry=[Jac.DSFunc("create")], on_exit=[])
 @dataclass(eq=False)
-class Creator:
-
-    def create(self, here: Jac.get_root_type()) -> None:
-        end = here
+class Creator(Jac.Walker):
+    def create(self, _jac_here_: Jac.RootType) -> None:
+        end = _jac_here_
         i = 0
         while i < 3:
-            Jac.connect(end, (end := node_a(val=i)), Jac.build_edge(False, None, None))
+            Jac.connect(
+                left=end,
+                right=(end := node_a(val=i)),
+                edge_spec=Jac.build_edge(
+                    is_undirected=False, conn_type=None, conn_assign=None
+                ),
+            )
             i += 1
         Jac.connect(
-            end,
-            (end := node_a(val=i + 10)),
-            Jac.build_edge(False, connector, (("value",), (i,))),
+            left=end,
+            right=(end := node_a(val=i + 10)),
+            edge_spec=Jac.build_edge(
+                is_undirected=False, conn_type=connector, conn_assign=(("value",), (i,))
+            ),
         )
         Jac.connect(
-            (end := node_a(val=i + 10)),
-            Jac.get_root(),
-            Jac.build_edge(False, connector, (("value",), (i,))),
+            left=(end := node_a(val=i + 10)),
+            right=Jac.get_root(),
+            edge_spec=Jac.build_edge(
+                is_undirected=False, conn_type=connector, conn_assign=(("value",), (i,))
+            ),
         )
         if Jac.visit_node(
             self,
-            Jac.edge_ref(here, None, Jac.EdgeDir.OUT, filter_func=None),
+            Jac.edge_ref(
+                _jac_here_,
+                target_obj=None,
+                dir=Jac.EdgeDir.OUT,
+                filter_func=None,
+                edges_only=False,
+            ),
         ):
             pass
 
 
-@Jac.make_node(on_entry=[Jac.DSFunc("make_something", Creator)], on_exit=[])
+@Jac.make_node(on_entry=[Jac.DSFunc("make_something")], on_exit=[])
 @dataclass(eq=False)
-class node_a:
+class node_a(Jac.Node):
     val: int
 
-    def make_something(self, here: Creator) -> None:
+    def make_something(self, _jac_here_: Creator) -> None:
         i = 0
         while i < 5:
             print(f"wlecome to {self}")
@@ -44,7 +60,7 @@ def make_something(self, here: Creator) -> None:
 
 @Jac.make_edge(on_entry=[], on_exit=[])
 @dataclass(eq=False)
-class connector:
+class connector(Jac.Edge):
     value: int = Jac.has_instance_default(gen_func=lambda: 10)
 
 
diff --git a/jac/examples/reference/data_spatial_spawn_expressions.py b/jac/examples/reference/data_spatial_spawn_expressions.py
index 0c1c57b7d6..1ed77bb2d6 100644
--- a/jac/examples/reference/data_spatial_spawn_expressions.py
+++ b/jac/examples/reference/data_spatial_spawn_expressions.py
@@ -1,25 +1,43 @@
-from jaclang.plugin.feature import JacFeature as jac
+from __future__ import annotations
+from jaclang.plugin.feature import JacFeature as Jac
+from jaclang.plugin.builtin import *
+from dataclasses import dataclass
 
 
-@jac.make_walker(on_entry=[jac.DSFunc("do", jac.get_root_type())], on_exit=[])
-class Adder:
-    def do(self, jac_here_: jac.get_root_type()) -> None:
-        jac.connect(jac_here_, node_a(), jac.build_edge(jac.EdgeDir.OUT, None, None))
-        if jac.visit_node(
-            self, jac.edge_ref(jac_here_, None, jac.EdgeDir.OUT, None, None)
+@Jac.make_walker(on_entry=[Jac.DSFunc("do")], on_exit=[])
+@dataclass(eq=False)
+class Adder(Jac.Walker):
+    def do(self, _jac_here_: Jac.RootType) -> None:
+        Jac.connect(
+            left=_jac_here_,
+            right=node_a(),
+            edge_spec=Jac.build_edge(
+                is_undirected=False, conn_type=None, conn_assign=None
+            ),
+        )
+        if Jac.visit_node(
+            self,
+            Jac.edge_ref(
+                _jac_here_,
+                target_obj=None,
+                dir=Jac.EdgeDir.OUT,
+                filter_func=None,
+                edges_only=False,
+            ),
         ):
             pass
 
 
-@jac.make_node(on_entry=[jac.DSFunc("add", Adder)], on_exit=[])
-class node_a:
-    x: int = jac.has_instance_default(gen_func=lambda: 0)
-    y: int = jac.has_instance_default(gen_func=lambda: 0)
+@Jac.make_node(on_entry=[Jac.DSFunc("add")], on_exit=[])
+@dataclass(eq=False)
+class node_a(Jac.Node):
+    x: int = Jac.has_instance_default(gen_func=lambda: 0)
+    y: int = Jac.has_instance_default(gen_func=lambda: 0)
 
-    def add(self, jac_here_: Adder) -> None:
+    def add(self, _jac_here_: Adder) -> None:
         self.x = 550
         self.y = 450
         print(int(self.x) + int(self.y))
 
 
-jac.spawn_call(Adder(), jac.get_root())
+Jac.spawn_call(Adder(), Jac.get_root())
diff --git a/jac/examples/reference/data_spatial_typed_context_blocks.py b/jac/examples/reference/data_spatial_typed_context_blocks.py
index b6a4bc4642..a313adee2c 100644
--- a/jac/examples/reference/data_spatial_typed_context_blocks.py
+++ b/jac/examples/reference/data_spatial_typed_context_blocks.py
@@ -1,37 +1,54 @@
 from __future__ import annotations
 from jaclang.plugin.feature import JacFeature as Jac
-from dataclasses import dataclass as dataclass
+from jaclang.plugin.builtin import *
+from dataclasses import dataclass
 
 
-@Jac.make_walker(on_entry=[Jac.DSFunc("produce", Jac.get_root_type())], on_exit=[])
+@Jac.make_walker(on_entry=[Jac.DSFunc("produce")], on_exit=[])
 @dataclass(eq=False)
-class Producer:
+class Producer(Jac.Walker):
 
-    def produce(self, here: Jac.get_root_type()) -> None:
-        end = here
+    def produce(self, _jac_here_: Jac.RootType) -> None:
+        end = _jac_here_
         i = 0
         while i <= 2:
             Jac.connect(
-                end, (end := Product(number=i + 1)), Jac.build_edge(False, None, None)
+                left=end,
+                right=(end := Product(number=i + 1)),
+                edge_spec=Jac.build_edge(
+                    is_undirected=False, conn_type=None, conn_assign=None
+                ),
             )
             i += 1
         if Jac.visit_node(
             self,
-            Jac.edge_ref(here, None, Jac.EdgeDir.OUT, filter_func=None),
+            Jac.edge_ref(
+                _jac_here_,
+                target_obj=None,
+                dir=Jac.EdgeDir.OUT,
+                filter_func=None,
+                edges_only=False,
+            ),
         ):
             pass
 
 
-@Jac.make_node(on_entry=[Jac.DSFunc("make", Producer)], on_exit=[])
+@Jac.make_node(on_entry=[Jac.DSFunc("make")], on_exit=[])
 @dataclass(eq=False)
-class Product:
+class Product(Jac.Node):
     number: int
 
-    def make(self, here: Producer) -> None:
+    def make(self, _jac_here_: Producer) -> None:
         print(f"Hi, I am {self} returning a String")
         if Jac.visit_node(
-            here,
-            Jac.edge_ref(self, None, Jac.EdgeDir.OUT, filter_func=None),
+            _jac_here_,
+            Jac.edge_ref(
+                self,
+                target_obj=None,
+                dir=Jac.EdgeDir.OUT,
+                filter_func=None,
+                edges_only=False,
+            ),
         ):
             pass
 
diff --git a/jac/examples/reference/ignore_statements.py b/jac/examples/reference/ignore_statements.py
index ac8394f782..a9c59af3b0 100644
--- a/jac/examples/reference/ignore_statements.py
+++ b/jac/examples/reference/ignore_statements.py
@@ -1,27 +1,53 @@
 from __future__ import annotations
-from jaclang.plugin.feature import JacFeature as jac
+from jaclang.plugin.feature import JacFeature as Jac
+from jaclang.plugin.builtin import *
+from dataclasses import dataclass
 
 
-@jac.make_walker(on_entry=[jac.DSFunc("travel", jac.get_root_type())], on_exit=[])
-class Visitor:
-    def travel(self, jac_here_: jac.get_root_type()) -> None:
-        jac.ignore(self, jac.edge_ref(jac_here_, None, jac.EdgeDir.OUT, None, None)[0])
-        if jac.visit_node(
-            self, jac.edge_ref(jac_here_, None, jac.EdgeDir.OUT, None, None)
+@Jac.make_walker(on_entry=[Jac.DSFunc("travel")], on_exit=[])
+@dataclass(eq=False)
+class Visitor(Jac.Walker):
+
+    def travel(self, _jac_here_: Jac.RootType) -> None:
+        Jac.ignore(
+            self,
+            Jac.edge_ref(
+                _jac_here_,
+                target_obj=None,
+                dir=Jac.EdgeDir.OUT,
+                filter_func=None,
+                edges_only=False,
+            )[0],
+        )
+        if Jac.visit_node(
+            self,
+            Jac.edge_ref(
+                _jac_here_,
+                target_obj=None,
+                dir=Jac.EdgeDir.OUT,
+                filter_func=None,
+                edges_only=False,
+            ),
         ):
             pass
-        elif jac.visit_node(self, jac.get_root()):
+        elif Jac.visit_node(self, Jac.get_root()):
             pass
 
 
-@jac.make_node(on_entry=[jac.DSFunc("speak", Visitor)], on_exit=[])
-class item:
-    def speak(self, jac_here_: Visitor) -> None:
+@Jac.make_node(on_entry=[Jac.DSFunc("speak")], on_exit=[])
+@dataclass(eq=False)
+class item(Jac.Node):
+
+    def speak(self, _jac_here_: Visitor) -> None:
         print("Hey There!!!")
 
 
 i = 0
 while i < 5:
-    jac.connect(jac.get_root(), item(), jac.build_edge(jac.EdgeDir.OUT, None, None))
+    Jac.connect(
+        left=Jac.get_root(),
+        right=item(),
+        edge_spec=Jac.build_edge(is_undirected=False, conn_type=None, conn_assign=None),
+    )
     i += 1
-jac.spawn_call(jac.get_root(), Visitor())
+Jac.spawn_call(Jac.get_root(), Visitor())
diff --git a/jac/jaclang/cli/cli.py b/jac/jaclang/cli/cli.py
index 25826958bb..a16c288443 100644
--- a/jac/jaclang/cli/cli.py
+++ b/jac/jaclang/cli/cli.py
@@ -106,7 +106,7 @@ def run(
         try:
             with open(filename, "rb") as f:
                 JacMachine(base).attach_program(
-                    JacProgram(mod_bundle=pickle.load(f), bytecode=None)
+                    JacProgram(mod_bundle=pickle.load(f), bytecode=None, sem_ir=None)
                 )
                 jac_import(
                     target=mod,
@@ -156,7 +156,7 @@ def get_object(
     elif filename.endswith(".jir"):
         with open(filename, "rb") as f:
             JacMachine(base).attach_program(
-                JacProgram(mod_bundle=pickle.load(f), bytecode=None)
+                JacProgram(mod_bundle=pickle.load(f), bytecode=None, sem_ir=None)
             )
             jac_import(
                 target=mod,
@@ -273,7 +273,7 @@ def enter(
     elif filename.endswith(".jir"):
         with open(filename, "rb") as f:
             JacMachine(base).attach_program(
-                JacProgram(mod_bundle=pickle.load(f), bytecode=None)
+                JacProgram(mod_bundle=pickle.load(f), bytecode=None, sem_ir=None)
             )
             ret_module = jac_import(
                 target=mod,
diff --git a/jac/jaclang/compiler/absyntree.py b/jac/jaclang/compiler/absyntree.py
index c0bacc3558..519b58dd33 100644
--- a/jac/jaclang/compiler/absyntree.py
+++ b/jac/jaclang/compiler/absyntree.py
@@ -5,6 +5,7 @@
 import ast as ast3
 import builtins
 import os
+from dataclasses import dataclass
 from hashlib import md5
 from types import EllipsisType
 from typing import (
@@ -3401,18 +3402,22 @@ def normalize(self, deep: bool = True) -> bool:
 class IndexSlice(AtomExpr):
     """IndexSlice node type for Jac Ast."""
 
+    @dataclass
+    class Slice:
+        """Slice node for index slice."""
+
+        start: Optional[Expr]
+        stop: Optional[Expr]
+        step: Optional[Expr]
+
     def __init__(
         self,
-        start: Optional[Expr],
-        stop: Optional[Expr],
-        step: Optional[Expr],
+        slices: list[Slice],
         is_range: bool,
         kid: Sequence[AstNode],
     ) -> None:
         """Initialize index slice expression node."""
-        self.start = start
-        self.stop = stop
-        self.step = step
+        self.slices = slices
         self.is_range = is_range
         AstNode.__init__(self, kid=kid)
         Expr.__init__(self)
@@ -3422,22 +3427,26 @@ def normalize(self, deep: bool = True) -> bool:
         """Normalize ast node."""
         res = True
         if deep:
-            res = self.start.normalize(deep) if self.start else res
-            res = res and self.stop.normalize(deep) if self.stop else res
-            res = res and self.step.normalize(deep) if self.step else res
+            for slice in self.slices:
+                res = slice.start.normalize(deep) if slice.start else res
+                res = res and slice.stop.normalize(deep) if slice.stop else res
+                res = res and slice.step.normalize(deep) if slice.step else res
         new_kid: list[AstNode] = []
         new_kid.append(self.gen_token(Tok.LSQUARE))
         if self.is_range:
-            if self.start:
-                new_kid.append(self.start)
-            if self.stop:
+            for i, slice in enumerate(self.slices):
+                if i > 0:
+                    new_kid.append(self.gen_token(Tok.COMMA))
+                if slice.start:
+                    new_kid.append(slice.start)
                 new_kid.append(self.gen_token(Tok.COLON))
-                new_kid.append(self.stop)
-            if self.step:
-                new_kid.append(self.gen_token(Tok.COLON))
-                new_kid.append(self.step)
-        elif self.start:
-            new_kid.append(self.start)
+                if slice.stop:
+                    new_kid.append(slice.stop)
+                if slice.step:
+                    new_kid.append(self.gen_token(Tok.COLON))
+                    new_kid.append(slice.step)
+        elif len(self.slices) == 1 and self.slices[0].start:
+            new_kid.append(self.slices[0].start)
         else:
             res = False
         new_kid.append(self.gen_token(Tok.RSQUARE))
diff --git a/jac/jaclang/compiler/jac.lark b/jac/jaclang/compiler/jac.lark
index 2a31e4f88a..7d16b8c0cb 100644
--- a/jac/jaclang/compiler/jac.lark
+++ b/jac/jaclang/compiler/jac.lark
@@ -358,7 +358,10 @@ atomic_chain: atomic_chain NULL_OK? (filter_compr | assign_compr | index_slice)
             | atomic_chain NULL_OK? (DOT_BKWD | DOT_FWD | DOT) named_ref
             | (atomic_call | atom | edge_ref_chain)
 
-index_slice: LSQUARE expression? COLON expression? (COLON expression?)? RSQUARE
+index_slice: LSQUARE                                                             \
+                     expression? COLON expression? (COLON expression?)?          \
+                     (COMMA expression? COLON expression? (COLON expression?)?)* \
+              RSQUARE
            | list_val
 
 // Function calls
diff --git a/jac/jaclang/compiler/parser.py b/jac/jaclang/compiler/parser.py
index 894605fabb..14d3cdeb76 100644
--- a/jac/jaclang/compiler/parser.py
+++ b/jac/jaclang/compiler/parser.py
@@ -2436,8 +2436,11 @@ def atomic_call(self, kid: list[ast.AstNode]) -> ast.FuncCall:
         def index_slice(self, kid: list[ast.AstNode]) -> ast.IndexSlice:
             """Grammar rule.
 
-            index_slice: LSQUARE expression? COLON expression? (COLON expression?)? RSQUARE
-                    | list_val
+            index_slice: LSQUARE                                                        \
+                            expression? COLON expression? (COLON expression?)?          \
+                            (COMMA expression? COLON expression? (COLON expression?)?)* \
+                         RSQUARE
+                        | list_val
             """
             if len(kid) == 1:
                 index = kid[0]
@@ -2454,9 +2457,9 @@ def index_slice(self, kid: list[ast.AstNode]) -> ast.IndexSlice:
                         kid = [expr]
                     return self.nu(
                         ast.IndexSlice(
-                            start=expr,
-                            stop=None,
-                            step=None,
+                            slices=[
+                                ast.IndexSlice.Slice(start=expr, stop=None, step=None)
+                            ],
                             is_range=False,
                             kid=kid,
                         )
@@ -2464,25 +2467,39 @@ def index_slice(self, kid: list[ast.AstNode]) -> ast.IndexSlice:
                 else:
                     raise self.ice()
             else:
-                expr1 = expr2 = expr3 = None
+                slices: list[ast.IndexSlice.Slice] = []
                 chomp = kid[1:]
-                if isinstance(chomp[0], ast.Expr):
-                    expr1 = chomp[0]
-                    chomp = chomp[1:]
-                chomp = chomp[1:]
-                if isinstance(chomp[0], ast.Expr):
-                    expr2 = chomp[0]
-                    chomp = chomp[1:]
-                if isinstance(chomp[0], ast.Token) and chomp[0].name == Tok.COLON:
-                    chomp = chomp[1:]
+
+                while not (
+                    isinstance(chomp[0], ast.Token) and chomp[0].name == Tok.RSQUARE
+                ):
+                    expr1 = expr2 = expr3 = None
+
                     if isinstance(chomp[0], ast.Expr):
-                        expr3 = chomp[0]
-                        chomp = chomp[1:]
+                        expr1 = chomp[0]
+                        chomp.pop(0)
+                    chomp.pop(0)
+
+                    if isinstance(chomp[0], ast.Expr):
+                        expr2 = chomp[0]
+                        chomp.pop(0)
+
+                    if isinstance(chomp[0], ast.Token) and chomp[0].name == Tok.COLON:
+                        chomp.pop(0)
+                        if isinstance(chomp[0], ast.Expr):
+                            expr3 = chomp[0]
+                            chomp.pop(0)
+
+                    if isinstance(chomp[0], ast.Token) and chomp[0].name == Tok.COMMA:
+                        chomp.pop(0)
+
+                    slices.append(
+                        ast.IndexSlice.Slice(start=expr1, stop=expr2, step=expr3)
+                    )
+
                 return self.nu(
                     ast.IndexSlice(
-                        start=expr1,
-                        stop=expr2,
-                        step=expr3,
+                        slices=slices,
                         is_range=True,
                         kid=kid,
                     )
@@ -2800,25 +2817,14 @@ def kw_expr(self, kid: list[ast.AstNode]) -> ast.KWPair:
         def name_list(self, kid: list[ast.AstNode]) -> ast.SubNodeList[ast.Name]:
             """Grammar rule.
 
-            name_list: (name_list COMMA)? NAME
+            name_list: (named_ref COMMA)* named_ref
             """
-            consume = None
-            name = None
-            comma = None
-            if isinstance(kid[0], ast.SubNodeList):
-                consume = kid[0]
-                comma = kid[1]
-                name = kid[2]
-                new_kid = [*consume.kid, comma, name]
-            else:
-                name = kid[0]
-                new_kid = [name]
-            valid_kid = [i for i in new_kid if isinstance(i, ast.Name)]
+            valid_kid = [i for i in kid if isinstance(i, ast.Name)]
             return self.nu(
                 ast.SubNodeList[ast.Name](
                     items=valid_kid,
                     delim=Tok.COMMA,
-                    kid=new_kid,
+                    kid=kid,
                 )
             )
 
diff --git a/jac/jaclang/compiler/passes/main/def_impl_match_pass.py b/jac/jaclang/compiler/passes/main/def_impl_match_pass.py
index 76e703091a..9a3d2b0caa 100644
--- a/jac/jaclang/compiler/passes/main/def_impl_match_pass.py
+++ b/jac/jaclang/compiler/passes/main/def_impl_match_pass.py
@@ -7,6 +7,7 @@
 """
 
 import jaclang.compiler.absyntree as ast
+from jaclang.compiler.constant import Tokens as Tok
 from jaclang.compiler.passes import Pass
 from jaclang.compiler.passes.main import SubNodeTabPass
 from jaclang.compiler.symtable import Symbol, SymbolTable
@@ -129,19 +130,55 @@ def validate_params_match(self, sym: Symbol, valid_decl: ast.AstSymbolNode) -> N
                         valid_decl.name_spec,
                     )
                 else:
+                    # Copy the parameter names from the declaration to the definition.
                     for idx in range(len(params_defn.items)):
-                        # Check if all the parameter names are matched.
-                        # TODO: This shouldn't be an issue however if the names are not matched, it doesn't
-                        # work as expected like in C++, for now I'm adding this validation, however this
-                        # needs to be fixed to have a C++ style.
-                        param_name_decl = params_decl.items[idx].name.value
-                        param_name_defn = params_defn.items[idx].name.value
-                        if param_name_defn != param_name_decl:
-                            self.error(
-                                f"Parameter name mismatch for ability {sym.sym_name}.",
-                                params_defn.items[idx].name,
-                            )
+                        params_decl.items[idx] = params_defn.items[idx]
+                    for idx in range(len(params_defn.kid)):
+                        params_decl.kid[idx] = params_defn.kid[idx]
+
+    def exit_architype(self, node: ast.Architype) -> None:
+        """Exit Architype."""
+        if node.arch_type.name == Tok.KW_OBJECT and isinstance(
+            node.body, ast.SubNodeList
+        ):
+
+            found_default_init = False
+            for stmnt in node.body.items:
+                if not isinstance(stmnt, ast.ArchHas):
+                    continue
+                for var in stmnt.vars.items:
+                    if (var.value is not None) or (var.defer):
+                        found_default_init = True
+                    else:
+                        if found_default_init:
                             self.error(
-                                f"From the declaration of {valid_decl.name_spec.sym_name}.",
-                                params_decl.items[idx].name,
+                                f"Non default attribute '{var.name.value}' follows default attribute",
+                                node_override=var.name,
                             )
+                            break
+
+            post_init_vars: list[ast.HasVar] = []
+            postinit_method: ast.Ability | None = None
+
+            for item in node.body.items:
+
+                if isinstance(item, ast.ArchHas):
+                    for var in item.vars.items:
+                        if var.defer:
+                            post_init_vars.append(var)
+
+                elif isinstance(item, ast.Ability):
+                    if item.is_abstract:
+                        continue
+                    if (
+                        isinstance(item.name_ref, ast.SpecialVarRef)
+                        and item.name_ref.name == "KW_POST_INIT"
+                    ):
+                        postinit_method = item
+
+            # Check if postinit needed and not provided.
+            if len(post_init_vars) != 0 and (postinit_method is None):
+                self.error(
+                    'Missing "postinit" method required by un initialized attribute(s).',
+                    node_override=post_init_vars[0].name_spec,
+                )  # We show the error on the first uninitialized var.
diff --git a/jac/jaclang/compiler/passes/main/def_use_pass.py b/jac/jaclang/compiler/passes/main/def_use_pass.py
index 741a426224..86283e5db7 100644
--- a/jac/jaclang/compiler/passes/main/def_use_pass.py
+++ b/jac/jaclang/compiler/passes/main/def_use_pass.py
@@ -156,8 +156,7 @@ def enter_func_call(self, node: ast.FuncCall) -> None:
     def enter_index_slice(self, node: ast.IndexSlice) -> None:
         """Sub objects.
 
-        start: Optional[ExprType],
-        stop: Optional[ExprType],
+        slices: list[Slice],
         is_range: bool,
         """
 
diff --git a/jac/jaclang/compiler/passes/main/pyast_gen_pass.py b/jac/jaclang/compiler/passes/main/pyast_gen_pass.py
index f1f6f0fef7..d8c9dc8f7a 100644
--- a/jac/jaclang/compiler/passes/main/pyast_gen_pass.py
+++ b/jac/jaclang/compiler/passes/main/pyast_gen_pass.py
@@ -1055,14 +1055,7 @@ def collect_events(
                                 ctx=ast3.Load(),
                             )
                         ),
-                        args=[
-                            self.sync(ast3.Constant(value=i.sym_name)),
-                            (
-                                i.signature.arch_tag_info.gen.py_ast[0]
-                                if i.signature.arch_tag_info
-                                else self.sync(ast3.Constant(value=None))
-                            ),
-                        ],
+                        args=[self.sync(ast3.Constant(value=i.sym_name))],
                         keywords=[],
                     )
                 )
@@ -3081,23 +3074,56 @@ def exit_func_call(self, node: ast.FuncCall) -> None:
     def exit_index_slice(self, node: ast.IndexSlice) -> None:
         """Sub objects.
 
-        start: Optional[ExprType],
-        stop: Optional[ExprType],
-        step: Optional[ExprType],
+        slices: list[IndexSlice.Slice],
         is_range: bool,
         """
         if node.is_range:
-            node.gen.py_ast = [
-                self.sync(
-                    ast3.Slice(
-                        lower=node.start.gen.py_ast[0] if node.start else None,
-                        upper=node.stop.gen.py_ast[0] if node.stop else None,
-                        step=node.step.gen.py_ast[0] if node.step else None,
+            if len(node.slices) > 1:  # Multiple slices. Example arr[a:b, c:d]
+                node.gen.py_ast = [
+                    self.sync(
+                        ast3.Tuple(
+                            elts=[
+                                self.sync(
+                                    ast3.Slice(
+                                        lower=(
+                                            slice.start.gen.py_ast[0]
+                                            if slice.start
+                                            else None
+                                        ),
+                                        upper=(
+                                            slice.stop.gen.py_ast[0]
+                                            if slice.stop
+                                            else None
+                                        ),
+                                        step=(
+                                            slice.step.gen.py_ast[0]
+                                            if slice.step
+                                            else None
+                                        ),
+                                    )
+                                )
+                                for slice in node.slices
+                            ],
+                            ctx=ast3.Load(),
+                        )
                     )
-                )
-            ]
+                ]
+            elif len(node.slices) == 1:  # Single slice. Example arr[a]
+                slice = node.slices[0]
+                node.gen.py_ast = [
+                    self.sync(
+                        ast3.Slice(
+                            lower=slice.start.gen.py_ast[0] if slice.start else None,
+                            upper=slice.stop.gen.py_ast[0] if slice.stop else None,
+                            step=slice.step.gen.py_ast[0] if slice.step else None,
+                        )
+                    )
+                ]
         else:
-            node.gen.py_ast = node.start.gen.py_ast if node.start else []
+            if len(node.slices) > 0 and node.slices[0].start is not None:
+                node.gen.py_ast = node.slices[0].start.gen.py_ast
+            else:
+                node.gen.py_ast = []
 
     def exit_special_var_ref(self, node: ast.SpecialVarRef) -> None:
         """Sub objects.
diff --git a/jac/jaclang/compiler/passes/main/pyast_load_pass.py b/jac/jaclang/compiler/passes/main/pyast_load_pass.py
index 31e4e5c3a3..457af7ca27 100644
--- a/jac/jaclang/compiler/passes/main/pyast_load_pass.py
+++ b/jac/jaclang/compiler/passes/main/pyast_load_pass.py
@@ -2026,9 +2026,7 @@ class Slice(_Slice):
             and (isinstance(step, ast.Expr) or step is None)
         ):
             return ast.IndexSlice(
-                start=lower,
-                stop=upper,
-                step=step,
+                slices=[ast.IndexSlice.Slice(lower, upper, step)],
                 is_range=True,
                 kid=valid_kid,
             )
@@ -2061,12 +2059,28 @@ class Subscript(expr):
         slice = self.convert(node.slice)
         if not isinstance(slice, ast.IndexSlice) and isinstance(slice, ast.Expr):
             slice = ast.IndexSlice(
-                start=slice,
-                stop=None,
-                step=None,
+                slices=[ast.IndexSlice.Slice(slice, None, None)],
                 is_range=False,
                 kid=[slice],
             )
+        if (
+            not isinstance(slice, ast.IndexSlice)
+            and isinstance(slice, ast.TupleVal)
+            and slice.values is not None
+        ):
+
+            slices: list[ast.IndexSlice.Slice] = []
+            for index_slice in slice.values.items:
+                if not isinstance(index_slice, ast.IndexSlice):
+                    raise self.ice()
+                slices.append(index_slice.slices[0])
+
+            slice = ast.IndexSlice(
+                slices=slices,
+                is_range=True,
+                kid=[slice],
+            )
+
         if isinstance(value, ast.Expr) and isinstance(slice, ast.IndexSlice):
             return ast.AtomTrailer(
                 target=value,
diff --git a/jac/jaclang/compiler/passes/main/registry_pass.py b/jac/jaclang/compiler/passes/main/registry_pass.py
index 3bca24f544..94d33e96d0 100644
--- a/jac/jaclang/compiler/passes/main/registry_pass.py
+++ b/jac/jaclang/compiler/passes/main/registry_pass.py
@@ -6,11 +6,7 @@
 each module
 """
 
-import os
-import pickle
-
 import jaclang.compiler.absyntree as ast
-from jaclang.compiler.constant import Constants as Con
 from jaclang.compiler.passes import Pass
 from jaclang.compiler.semtable import SemInfo, SemRegistry
 from jaclang.runtimelib.utils import get_sem_scope
@@ -33,15 +29,10 @@ def enter_module(self, node: ast.Module) -> None:
     def exit_module(self, node: ast.Module) -> None:
         """Save registry for each module."""
         module_name = node.name
-        module_dir = os.path.join(
-            os.path.abspath(os.path.dirname(node.source.file_path)), Con.JAC_GEN_DIR
-        )
         try:
-            os.makedirs(module_dir, exist_ok=True)
-            with open(
-                os.path.join(module_dir, f"{module_name}.registry.pkl"), "wb"
-            ) as f:
-                pickle.dump(node.registry, f)
+            from jaclang.runtimelib.machine import JacMachine
+
+            JacMachine.get().get_sem_ir(node.registry)
         except Exception as e:
             self.warning(f"Can't save registry for {module_name}: {e}")
         self.modules_visited.pop()
diff --git a/jac/jaclang/compiler/passes/main/sym_tab_build_pass.py b/jac/jaclang/compiler/passes/main/sym_tab_build_pass.py
index f3c70baac7..943182d90d 100644
--- a/jac/jaclang/compiler/passes/main/sym_tab_build_pass.py
+++ b/jac/jaclang/compiler/passes/main/sym_tab_build_pass.py
@@ -995,8 +995,7 @@ def enter_func_call(self, node: ast.FuncCall) -> None:
     def enter_index_slice(self, node: ast.IndexSlice) -> None:
         """Sub objects.
 
-        start: Optional[ExprType],
-        stop: Optional[ExprType],
+        slices: list[Slice],
         is_range: bool,
         """
         self.sync_node_to_scope(node)
diff --git a/jac/jaclang/compiler/passes/tool/jac_formatter_pass.py b/jac/jaclang/compiler/passes/tool/jac_formatter_pass.py
index 86ddede47c..c52a6f1197 100644
--- a/jac/jaclang/compiler/passes/tool/jac_formatter_pass.py
+++ b/jac/jaclang/compiler/passes/tool/jac_formatter_pass.py
@@ -1640,8 +1640,8 @@ def exit_edge_op_ref(self, node: ast.EdgeOpRef) -> None:
     def exit_index_slice(self, node: ast.IndexSlice) -> None:
         """Sub objects.
 
-        start: ExprType,
-        stop: Optional[ExprType],
+        slices: list[Slice],
+        is_range: bool,
         """
         for i in node.kid:
             self.emit(node, i.gen.jac)
diff --git a/jac/jaclang/plugin/default.py b/jac/jaclang/plugin/default.py
index 2f706698c1..5a730a0ea4 100644
--- a/jac/jaclang/plugin/default.py
+++ b/jac/jaclang/plugin/default.py
@@ -6,13 +6,12 @@
 import fnmatch
 import html
 import os
-import pickle
 import types
 from collections import OrderedDict
 from dataclasses import field
 from functools import wraps
 from logging import getLogger
-from typing import Any, Callable, Mapping, Optional, Sequence, Type, Union
+from typing import Any, Callable, Mapping, Optional, Sequence, Type, Union, cast
 from uuid import UUID
 
 from jaclang.compiler.constant import colors
@@ -42,6 +41,7 @@
 )
 from jaclang.runtimelib.importer import ImportPathSpec, JacImporter, PythonImporter
 from jaclang.runtimelib.machine import JacMachine, JacProgram
+from jaclang.runtimelib.memory import Shelf, ShelfStorage
 from jaclang.runtimelib.utils import collect_node_connections, traverse_graph
 
 
@@ -54,6 +54,13 @@
 class JacAccessValidationImpl:
     """Jac Access Validation Implementations."""
 
+    @staticmethod
+    @hookimpl
+    def elevate_root() -> None:
+        """Elevate context root to system_root."""
+        jctx = Jac.get_context()
+        jctx.root = jctx.system_root
+
     @staticmethod
     @hookimpl
     def allow_root(
@@ -380,7 +387,8 @@ def spawn_call(op1: Architype, op2: Architype) -> WalkerArchitype:
         if walker.next:
             current_node = walker.next[-1].architype
             for i in warch._jac_entry_funcs_:
-                if not i.trigger:
+                trigger = i.get_funcparam_annotations(i.func)
+                if not trigger:
                     if i.func:
                         i.func(warch, current_node)
                     else:
@@ -388,7 +396,8 @@ def spawn_call(op1: Architype, op2: Architype) -> WalkerArchitype:
         while len(walker.next):
             if current_node := walker.next.pop(0).architype:
                 for i in current_node._jac_entry_funcs_:
-                    if not i.trigger or isinstance(warch, i.trigger):
+                    trigger = i.get_funcparam_annotations(i.func)
+                    if not trigger or isinstance(warch, trigger):
                         if i.func:
                             i.func(current_node, warch)
                         else:
@@ -396,27 +405,30 @@ def spawn_call(op1: Architype, op2: Architype) -> WalkerArchitype:
                     if walker.disengaged:
                         return warch
                 for i in warch._jac_entry_funcs_:
-                    if not i.trigger or isinstance(current_node, i.trigger):
-                        if i.func and i.trigger:
+                    trigger = i.get_funcparam_annotations(i.func)
+                    if not trigger or isinstance(current_node, trigger):
+                        if i.func and trigger:
                             i.func(warch, current_node)
-                        elif not i.trigger:
+                        elif not trigger:
                             continue
                         else:
                             raise ValueError(f"No function {i.name} to call.")
                     if walker.disengaged:
                         return warch
                 for i in warch._jac_exit_funcs_:
-                    if not i.trigger or isinstance(current_node, i.trigger):
-                        if i.func and i.trigger:
+                    trigger = i.get_funcparam_annotations(i.func)
+                    if not trigger or isinstance(current_node, trigger):
+                        if i.func and trigger:
                             i.func(warch, current_node)
-                        elif not i.trigger:
+                        elif not trigger:
                             continue
                         else:
                             raise ValueError(f"No function {i.name} to call.")
                     if walker.disengaged:
                         return warch
                 for i in current_node._jac_exit_funcs_:
-                    if not i.trigger or isinstance(warch, i.trigger):
+                    trigger = i.get_funcparam_annotations(i.func)
+                    if not trigger or isinstance(warch, trigger):
                         if i.func:
                             i.func(current_node, warch)
                         else:
@@ -424,7 +436,8 @@ def spawn_call(op1: Architype, op2: Architype) -> WalkerArchitype:
                     if walker.disengaged:
                         return warch
         for i in warch._jac_exit_funcs_:
-            if not i.trigger:
+            trigger = i.get_funcparam_annotations(i.func)
+            if not trigger:
                 if i.func:
                     i.func(warch, current_node)
                 else:
@@ -561,6 +574,29 @@ def get_context() -> ExecutionContext:
         """Get current execution context."""
         return ExecutionContext.get()
 
+    @staticmethod
+    @hookimpl
+    def reset_graph(root: Optional[Root] = None) -> int:
+        """Purge current or target graph."""
+        ctx = Jac.get_context()
+        mem = cast(ShelfStorage, ctx.mem)
+        ranchor = root.__jac__ if root else ctx.root
+
+        deleted_count = 0
+        for anchor in (
+            anchors.values()
+            if isinstance(anchors := mem.__shelf__, Shelf)
+            else mem.__mem__.values()
+        ):
+            if anchor == ranchor or anchor.root != ranchor.id:
+                continue
+
+            if loaded_anchor := mem.find_by_id(anchor.id):
+                deleted_count += 1
+                Jac.destroy(loaded_anchor)
+
+        return deleted_count
+
     @staticmethod
     @hookimpl
     def get_object(id: str) -> Architype | None:
@@ -752,7 +788,9 @@ def jac_import(
 
         jac_machine = JacMachine.get(base_path)
         if not jac_machine.jac_program:
-            jac_machine.attach_program(JacProgram(mod_bundle=None, bytecode=None))
+            jac_machine.attach_program(
+                JacProgram(mod_bundle=None, bytecode=None, sem_ir=None)
+            )
 
         if lng == "py":
             import_result = PythonImporter(JacMachine.get()).run_import(spec)
@@ -801,7 +839,7 @@ def run_test(
                 if mod_name.endswith(".test"):
                     mod_name = mod_name[:-5]
                 JacTestCheck.reset()
-                Jac.jac_import(target=mod_name, base_path=base)
+                Jac.jac_import(target=mod_name, base_path=base, cachable=False)
                 JacTestCheck.run_test(xit, maxfail, verbose)
                 ret_count = JacTestCheck.failcount
             else:
@@ -1065,16 +1103,14 @@ def get_semstr_type(
         file_loc: str, scope: str, attr: str, return_semstr: bool
     ) -> Optional[str]:
         """Jac's get_semstr_type feature."""
+        from jaclang.compiler.semtable import SemInfo, SemScope, SemRegistry
+        from jaclang.runtimelib.machine import JacMachine
+
         _scope = SemScope.get_scope_from_str(scope)
-        with open(
-            os.path.join(
-                os.path.dirname(file_loc),
-                "__jac_gen__",
-                os.path.basename(file_loc).replace(".jac", ".registry.pkl"),
-            ),
-            "rb",
-        ) as f:
-            mod_registry: SemRegistry = pickle.load(f)
+        jac_program = JacMachine.get().jac_program
+        mod_registry: SemRegistry = (
+            jac_program.sem_ir if jac_program is not None else SemRegistry()
+        )
         _, attr_seminfo = mod_registry.lookup(_scope, attr)
         if attr_seminfo and isinstance(attr_seminfo, SemInfo):
             return attr_seminfo.semstr if return_semstr else attr_seminfo.type
@@ -1084,15 +1120,12 @@ def get_semstr_type(
     @hookimpl
     def obj_scope(file_loc: str, attr: str) -> str:
         """Jac's gather_scope feature."""
-        with open(
-            os.path.join(
-                os.path.dirname(file_loc),
-                "__jac_gen__",
-                os.path.basename(file_loc).replace(".jac", ".registry.pkl"),
-            ),
-            "rb",
-        ) as f:
-            mod_registry: SemRegistry = pickle.load(f)
+        from jaclang.runtimelib.machine import JacMachine
+
+        jac_program = JacMachine.get().jac_program
+        mod_registry: SemRegistry = (
+            jac_program.sem_ir if jac_program is not None else SemRegistry()
+        )
 
         attr_scope = None
         for x in attr.split("."):
@@ -1125,15 +1158,13 @@ def obj_scope(file_loc: str, attr: str) -> str:
     @hookimpl
     def get_sem_type(file_loc: str, attr: str) -> tuple[str | None, str | None]:
         """Jac's get_semstr_type implementation."""
-        with open(
-            os.path.join(
-                os.path.dirname(file_loc),
-                "__jac_gen__",
-                os.path.basename(file_loc).replace(".jac", ".registry.pkl"),
-            ),
-            "rb",
-        ) as f:
-            mod_registry: SemRegistry = pickle.load(f)
+        from jaclang.runtimelib.machine import JacMachine
+        from jaclang.compiler.semtable import SemInfo, SemScope
+
+        jac_program = JacMachine.get().jac_program
+        mod_registry: SemRegistry = (
+            jac_program.sem_ir if jac_program is not None else SemRegistry()
+        )
 
         attr_scope = None
         for x in attr.split("."):
diff --git a/jac/jaclang/plugin/feature.py b/jac/jaclang/plugin/feature.py
index b88c4edfc7..821c8f19d5 100644
--- a/jac/jaclang/plugin/feature.py
+++ b/jac/jaclang/plugin/feature.py
@@ -41,6 +41,11 @@
 class JacAccessValidation:
     """Jac Access Validation Specs."""
 
+    @staticmethod
+    def elevate_root() -> None:
+        """Elevate context root to system_root."""
+        plugin_manager.hook.elevate_root()
+
     @staticmethod
     def allow_root(
         architype: Architype,
@@ -254,6 +259,11 @@ def get_context() -> ExecutionContext:
         """Get current execution context."""
         return plugin_manager.hook.get_context()
 
+    @staticmethod
+    def reset_graph(root: Optional[Root] = None) -> int:
+        """Purge current or target graph."""
+        return plugin_manager.hook.reset_graph(root=root)
+
     @staticmethod
     def get_object(id: str) -> Architype | None:
         """Get object given id."""
diff --git a/jac/jaclang/plugin/spec.py b/jac/jaclang/plugin/spec.py
index fc455b8237..e210467596 100644
--- a/jac/jaclang/plugin/spec.py
+++ b/jac/jaclang/plugin/spec.py
@@ -46,6 +46,12 @@
 class JacAccessValidationSpec:
     """Jac Access Validation Specs."""
 
+    @staticmethod
+    @hookspec(firstresult=True)
+    def elevate_root() -> None:
+        """Elevate context root to system_root."""
+        raise NotImplementedError
+
     @staticmethod
     @hookspec(firstresult=True)
     def allow_root(
@@ -244,6 +250,12 @@ def get_context() -> ExecutionContext:
         """Get current execution context."""
         raise NotImplementedError
 
+    @staticmethod
+    @hookspec(firstresult=True)
+    def reset_graph(root: Optional[Root]) -> int:
+        """Purge current or target graph."""
+        raise NotImplementedError
+
     @staticmethod
     @hookspec(firstresult=True)
     def get_object(id: str) -> Architype | None:
diff --git a/jac/jaclang/runtimelib/architype.py b/jac/jaclang/runtimelib/architype.py
index 6c1ad9a55c..082065fc9f 100644
--- a/jac/jaclang/runtimelib/architype.py
+++ b/jac/jaclang/runtimelib/architype.py
@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import inspect
 from dataclasses import asdict, dataclass, field, fields, is_dataclass
 from enum import IntEnum
 from logging import getLogger
@@ -291,9 +292,19 @@ class DSFunc:
     """Data Spatial Function."""
 
     name: str
-    trigger: type | UnionType | tuple[type | UnionType, ...] | None
     func: Callable[[Any, Any], Any] | None = None
 
     def resolve(self, cls: type) -> None:
         """Resolve the function."""
         self.func = getattr(cls, self.name)
+
+    def get_funcparam_annotations(
+        self, func: Callable[[Any, Any], Any] | None
+    ) -> type | UnionType | tuple[type | UnionType, ...] | None:
+        """Get function parameter annotations."""
+        if not func:
+            return None
+        annotation = (
+            inspect.signature(func, eval_str=True).parameters["_jac_here_"].annotation
+        )
+        return annotation if annotation != inspect._empty else None
diff --git a/jac/jaclang/runtimelib/machine.py b/jac/jaclang/runtimelib/machine.py
index f90c3fc138..81d0256e69 100644
--- a/jac/jaclang/runtimelib/machine.py
+++ b/jac/jaclang/runtimelib/machine.py
@@ -1,5 +1,7 @@
 """Jac Machine module."""
 
+from __future__ import annotations
+
 import inspect
 import marshal
 import os
@@ -12,6 +14,7 @@
 from jaclang.compiler.absyntree import Module
 from jaclang.compiler.compile import compile_jac
 from jaclang.compiler.constant import Constants as Con
+from jaclang.compiler.semtable import SemRegistry
 from jaclang.runtimelib.architype import (
     Architype,
     EdgeArchitype,
@@ -70,6 +73,14 @@ def get_bytecode(
             )
         return None
 
+    def get_sem_ir(self, mod_sem_ir: SemRegistry | None) -> None:
+        """Update semtable on the attached JacProgram."""
+        if self.jac_program and mod_sem_ir:
+            if self.jac_program.sem_ir:
+                self.jac_program.sem_ir.registry.update(mod_sem_ir.registry)
+            else:
+                self.jac_program.sem_ir = mod_sem_ir
+
     def load_module(self, module_name: str, module: types.ModuleType) -> None:
         """Load a module into the machine."""
         self.loaded_modules[module_name] = module
@@ -263,14 +274,18 @@ def detach() -> None:
 
 
 class JacProgram:
-    """Class to hold the mod_bundle and bytecode for Jac modules."""
+    """Class to hold the mod_bundle bytecode and sem_ir for Jac modules."""
 
     def __init__(
-        self, mod_bundle: Optional[Module], bytecode: Optional[dict[str, bytes]]
+        self,
+        mod_bundle: Optional[Module],
+        bytecode: Optional[dict[str, bytes]],
+        sem_ir: Optional[SemRegistry],
     ) -> None:
         """Initialize the JacProgram object."""
         self.mod_bundle = mod_bundle
         self.bytecode = bytecode or {}
+        self.sem_ir = sem_ir if sem_ir else SemRegistry()
 
     def get_bytecode(
         self,
diff --git a/jac/jaclang/runtimelib/memory.py b/jac/jaclang/runtimelib/memory.py
index 86773ed162..5cd5b88525 100644
--- a/jac/jaclang/runtimelib/memory.py
+++ b/jac/jaclang/runtimelib/memory.py
@@ -25,6 +25,10 @@ def close(self) -> None:
         self.__mem__.clear()
         self.__gc__.clear()
 
+    def is_cached(self, id: ID) -> bool:
+        """Check if id if already cached."""
+        return id in self.__mem__
+
     def find(
         self,
         ids: ID | Iterable[ID],
@@ -96,7 +100,7 @@ def close(self) -> None:
                             and p_d.edges != d.edges
                             and Jac.check_connect_access(d)
                         ):
-                            if not d.edges:
+                            if not d.edges and not isinstance(d.architype, Root):
                                 self.__shelf__.pop(_id, None)
                                 continue
                             p_d.edges = d.edges
diff --git a/jac/pyproject.toml b/jac/pyproject.toml
index be91619267..ba56fc2472 100644
--- a/jac/pyproject.toml
+++ b/jac/pyproject.toml
@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "jaclang"
-version = "0.7.24"
+version = "0.7.26"
 description = "Jac is a unique and powerful programming language that runs on top of Python, offering an unprecedented level of intelligence and intuitive understanding."
 authors = ["Jason Mars <jason@jaseci.org>"]
 maintainers = ["Jason Mars <jason@jaseci.org>"]
diff --git a/jac/support/jac-lang.org/docs/learn/coders/jac-cloud/docs/permission.md b/jac/support/jac-lang.org/docs/learn/coders/jac-cloud/docs/permission.md
index 936672b9e9..20e85c6af0 100644
--- a/jac/support/jac-lang.org/docs/learn/coders/jac-cloud/docs/permission.md
+++ b/jac/support/jac-lang.org/docs/learn/coders/jac-cloud/docs/permission.md
@@ -1,1 +1,292 @@
-### Permission Management (Work in progress)
\ No newline at end of file
+# Permission Management
+
+This document provides a guide on managing graph-based access permissions on the cloud using a structure of architypes. Each user has their own root graph, and access between users' architypes is restricted by default.
+
+# Anchors vs Architypes
+- Architypes are Jaclang class representation
+- Anchors are database class representation
+
+| type | Anchors | Architypes |
+| ---- | ---- | ---- |
+| Node | NodeAnchor | NodeArchitype |
+| Edge | EdgeAnchor | EdgeArchitype |
+| Walker | WalkerAnchor | WalkerArchitype |
+| Object | ObjectAnchor | ObjectArchitype |
+| Root | NodeAnchor | Root(NodeArchitype) |
+| GenericEdge | EdgeAnchor | GenericEdge(EdgeArchitype) |
+
+```python
+node Human {
+    has gender: str;
+}
+
+# DB NodeAnchor Representation
+{
+    _id: ObjectId('6735b60656e82d6799dc9772'),
+    name: 'Human',
+    root: ObjectId('6735b5e456e82d6799dc976e'),
+    access: { all: 'NO_ACCESS', roots: { anchors: {} } },
+    edges: [ 'e::6735b60656e82d6799dc9775', 'e:Friend:6735b60656e82d6799dc9776' ],
+
+    # the actual NodeArchitype and it's context or `has attributes`
+    architype: {
+        gender: "boy"
+    },
+}
+
+edge Friend {
+    has best: bool;
+}
+
+# DB EdgeAnchor Representation
+{
+    _id: ObjectId('6735b60656e82d6799dc9776'),
+    name: 'Friend',
+    root: ObjectId('6735b5e456e82d6799dc976e'),
+    access: { all: 'NO_ACCESS', roots: { anchors: {} } },
+    source: 'n:B:6735b60656e82d6799dc9771',
+    target: 'n:C:6735b60656e82d6799dc9772',
+    is_undirected: false
+
+    # the actual EdgeArchitype and it's context or `has attributes`
+    architype: {
+        best: true
+    },
+  }
+```
+
+## Access Levels
+* `NO_ACCESS`: No other user can access current architype.
+* `READ`: Other user have Read-Only access to current architype.
+* `CONNECT`: Other user's node can connect to current node.
+* `WRITE`: Other user can do anything to current architype.
+
+## Default User Graph Structure
+In this setup, each user's architype (node, edge, walker) is isolated with default permissions as follows:
+```python
+{
+    "all": "NO_ACCESS",
+    "roots": {
+        "anchors": {}
+    }
+}
+```
+
+* `all`: Non specific access (Given to all users)
+* `roots`: Root specific access (specific to user)
+    ```python
+    "roots": {
+        "anchors": {
+            "{{root_jid}}": "NO_ACCESS"
+        }
+    }
+    ```
+
+## Example Structure in DB perspective
+Consider the following structure:
+
+```
+User1 -> Root1 -> Node1
+User2 -> Root2 -> Node2
+```
+
+By default, `User2` cannot access `Node1` owns by `Root1`. To allow `User2` access to `node1`, we need to explicitly add a permission mapping in `Root2`.
+
+## Example of Granting Access
+To grant `READ` access to `User2` for `Node1` owns by `Root1`, we modify Node1’s access permissions:
+```python
+# Node1 is the architype
+# Node1.__jac__ is the anchor
+
+Node1.__jac__.access = {
+    "all": "READ",
+    "roots": {
+        "anchors": {}
+    }
+}
+```
+If `User1` wants to give only `READ` access to `User2`, we set permissions as follows:
+```python
+# Node1 is the architype
+# Node1.__jac__ is the anchor
+
+Node1.__jac__.access = {
+    "all": "NO_ACCESS",
+    "roots": {
+        "anchors": {
+            "n::123445673 User2's Root JID": "READ"
+        }
+    }
+}
+```
+
+## Permission Management Walkers
+Consider this scenario:
+```python
+User1 -> Root1 -> Node:boy1
+User2 -> Root2 -> Node:boy2
+User3 -> Root3 -> Node:boy3
+```
+### Granting Access
+
+To grant `boy1` in `User1`’s graph access to `User2`, we can use a walker.
+#### Granting Access in jac-lang
+```python
+# Run the walker in user1
+walker set_access {
+    has access: str;            # "READ", "WRITE", "CONNECT"
+    has root_uuid: str;
+
+    can give_access with boy entry {
+        # here = boy1
+        Jac.allow_root(here, UUID(self.root_ref_jid), self.access);
+    }
+}
+```
+
+#### Granting Access in jac-cloud
+```python
+# Run the walker in user1
+walker set_access {
+    has access: str;            # "READ", "WRITE", "CONNECT"
+    has root_ref_jid: str;
+
+    can give_access with boy entry {
+        # here = boy1
+        Jac.allow_root(here, NodeAnchor.ref(self.root_ref_jid), self.access);
+    }
+}
+```
+This is equivalent to setting boy1’s access in database:
+```python
+boy1.access = {
+    "all": "NO_ACCESS",
+    "roots": {
+        "anchors": {
+            "n::123445673 User2's Root JID": "READ"
+        }
+    }
+}
+```
+## Removing Access
+To remove access, use the walker below.
+
+#### Removing Access in jac-lang
+```python
+# Run the walker in user1
+walker remove_access {
+    has root_uuid: str;
+
+    can remove_access with boy entry {
+        # here = boy1
+        Jac.disallow_root(here, UUID(self.root_uuid));
+    }
+}
+```
+#### Removing Access in jac-cloud
+```python
+# Run the walker in user1
+walker remove_access {
+    has root_ref_jid: str;
+
+    can remove_access with boy entry {
+        # here = boy1
+        Jac.disallow_root(here, NodeAnchor.ref(self.root_ref_jid));
+    }
+}
+```
+This is equivalent to resetting boy1’s access:
+```python
+boy1.access = {
+    "all": "NO_ACCESS",
+    "roots": {
+        "anchors": {}
+    }
+}
+```
+
+## Global Access Control
+To grant read access to all, use the following syntax:
+```python
+Jac.unrestrict(here, "READ")
+```
+Equivalent structure:
+```python
+{
+    "all": "READ",
+    "roots": {
+        "anchors": {}
+    }
+}
+```
+
+To remove access to all, use the following syntax:
+```python
+Jac.restrict(here)
+```
+Equivalent structure:
+```python
+{
+    "all": "NO_ACCESS",
+    "roots": {
+        "anchors": {}
+    }
+}
+```
+
+## Manual Access Management
+
+In some cases, you may need to manually verify, filter, or update access permissions on nodes. The following Python examples demonstrate how to handle these tasks.
+
+### Checking Access Manually
+
+To manually check access levels on a collection of nodes, you can use the following code. This script filters nodes by type and checks for `READ`, `WRITE`, and `CONNECT` access permissions.
+
+```python
+for nodeanchor in NodeArchitype.Collection.find(
+    {
+        "type": "<type of the node>",
+        "context.public": true
+    }
+):
+    # Check read access
+    if not Jac.check_read_access(nodeanchor):
+        continue
+
+    # Check write access
+    if not Jac.check_write_access(nodeanchor):
+        continue
+
+    # Check connect access
+    if not Jac.check_connect_access(nodeanchor):
+        continue
+```
+
+### Filtering Nodes by Type
+To retrieve a specific node based on its type, use the following code snippet. This will find a node of the specified type that is also public in context.
+
+```python
+node = NodeArchitype.Collection.find_one(
+    {
+        "type": "<type of the node>",
+        "context.public": true
+    }
+)
+```
+
+### Updating Access Permissions Manually
+To manually update access permissions for multiple nodes, use the following code. This example sets the `access.all` permission to `CONNECT` for all nodes of a specific type that are publicly accessible.
+```python
+NodeArchitype.Collection.update_many(
+    {
+        "type": "<type of the node>",
+        "context.public": true
+    },
+    {
+        "$set": {
+            "access.all": "CONNECT"
+        }
+    }
+)
+```
+
diff --git a/jac/support/jac-lang.org/docs/learn/jac_ref.md b/jac/support/jac-lang.org/docs/learn/jac_ref.md
index 9e48477aff..a3972cf392 100644
--- a/jac/support/jac-lang.org/docs/learn/jac_ref.md
+++ b/jac/support/jac-lang.org/docs/learn/jac_ref.md
@@ -1040,7 +1040,7 @@
     ```
 ??? example "Jac Grammar Snippet"
     ```yaml linenums="357"
-    --8<-- "jaclang/compiler/jac.lark:357:362"
+    --8<-- "jaclang/compiler/jac.lark:357:365"
     ```
 **Description**
 
@@ -1057,8 +1057,8 @@
     --8<-- "examples/reference/function_calls.py"
     ```
 ??? example "Jac Grammar Snippet"
-    ```yaml linenums="365"
-    --8<-- "jaclang/compiler/jac.lark:365:369"
+    ```yaml linenums="368"
+    --8<-- "jaclang/compiler/jac.lark:368:372"
     ```
 **Description**
 
@@ -1075,8 +1075,8 @@
     --8<-- "examples/reference/atom.py"
     ```
 ??? example "Jac Grammar Snippet"
-    ```yaml linenums="372"
-    --8<-- "jaclang/compiler/jac.lark:372:397"
+    ```yaml linenums="375"
+    --8<-- "jaclang/compiler/jac.lark:375:400"
     ```
 **Description**
 
@@ -1093,8 +1093,8 @@
     --8<-- "examples/reference/collection_values.py"
     ```
 ??? example "Jac Grammar Snippet"
-    ```yaml linenums="400"
-    --8<-- "jaclang/compiler/jac.lark:400:421"
+    ```yaml linenums="403"
+    --8<-- "jaclang/compiler/jac.lark:403:424"
     ```
 **Description**
 
@@ -1111,8 +1111,8 @@
     --8<-- "examples/reference/tuples_and_jac_tuples.py"
     ```
 ??? example "Jac Grammar Snippet"
-    ```yaml linenums="424"
-    --8<-- "jaclang/compiler/jac.lark:424:431"
+    ```yaml linenums="427"
+    --8<-- "jaclang/compiler/jac.lark:427:434"
     ```
 **Description**
 
@@ -1129,8 +1129,8 @@
     --8<-- "examples/reference/data_spatial_references.py"
     ```
 ??? example "Jac Grammar Snippet"
-    ```yaml linenums="434"
-    --8<-- "jaclang/compiler/jac.lark:434:443"
+    ```yaml linenums="437"
+    --8<-- "jaclang/compiler/jac.lark:437:446"
     ```
 **Description**
 
@@ -1147,8 +1147,8 @@
     --8<-- "examples/reference/special_comprehensions.py"
     ```
 ??? example "Jac Grammar Snippet"
-    ```yaml linenums="446"
-    --8<-- "jaclang/compiler/jac.lark:446:451"
+    ```yaml linenums="449"
+    --8<-- "jaclang/compiler/jac.lark:449:454"
     ```
 **Description**
 
@@ -1165,8 +1165,8 @@
     --8<-- "examples/reference/names_and_references.py"
     ```
 ??? example "Jac Grammar Snippet"
-    ```yaml linenums="454"
-    --8<-- "jaclang/compiler/jac.lark:454:463"
+    ```yaml linenums="457"
+    --8<-- "jaclang/compiler/jac.lark:457:466"
     ```
 **Description**
 
@@ -1183,8 +1183,8 @@
     --8<-- "examples/reference/builtin_types.py"
     ```
 ??? example "Jac Grammar Snippet"
-    ```yaml linenums="466"
-    --8<-- "jaclang/compiler/jac.lark:466:476"
+    ```yaml linenums="469"
+    --8<-- "jaclang/compiler/jac.lark:469:479"
     ```
 **Description**
 
@@ -1201,8 +1201,8 @@
     --8<-- "examples/reference/lexer_tokens.py"
     ```
 ??? example "Jac Grammar Snippet"
-    ```yaml linenums="479"
-    --8<-- "jaclang/compiler/jac.lark:479:651"
+    ```yaml linenums="482"
+    --8<-- "jaclang/compiler/jac.lark:482:654"
     ```
 **Description**
 
@@ -1219,8 +1219,8 @@
     --8<-- "examples/reference/f_string_tokens.py"
     ```
 ??? example "Jac Grammar Snippet"
-    ```yaml linenums="654"
-    --8<-- "jaclang/compiler/jac.lark:654:665"
+    ```yaml linenums="657"
+    --8<-- "jaclang/compiler/jac.lark:657:668"
     ```
 **Description**
 
diff --git a/jac/support/jac-lang.org/docs/learn/tutorial/1_setting-up-jac-cloud.md b/jac/support/jac-lang.org/docs/learn/tutorial/1_setting-up-jac-cloud.md
index cdffb1b8ea..054a6c23bd 100644
--- a/jac/support/jac-lang.org/docs/learn/tutorial/1_setting-up-jac-cloud.md
+++ b/jac/support/jac-lang.org/docs/learn/tutorial/1_setting-up-jac-cloud.md
@@ -5,72 +5,6 @@ Jac Cloud is a jaclang plugin that bootstraps your jac application into a runnin
 pip install jaclang==0.7.19 jac-cloud==0.1.1
 ```
 
-## Setting Up Your Database
-Like most API servers, jac-cloud requires a database to store data persistently. Jac-cloud uses mongoDB as the database engine. You will need to have a running mongodb service. You can do this in several ways:
-
-- Setup MongoDB manually on your local maching
-- Using a container service like docker
-- Using a free cloud service like [MongoDB Atlas](https://www.mongodb.com/products/platform/atlas-database).
-
-In this tutorial we will show you how to do this manually and also using Docker (recommended).
-
-### Running a Mongodb Replica Set Manually
-To set up a mongodb replica set, follow these steps:
-
-- Running a mongoDB replica set locally.
-    - mongoDB community edition is free to use and run locally. Follow the installation and starting instructions from the mongoDB documentation [here](https://www.mongodb.com/docs/manual/installation/). Select the right one based on your OS.
-    - After installing, start the mongoDB service by running the following command:
-    ```bash
-    mongod --dbpath DB_DATA_PATH --replSet my-rs
-    ```
-    Replace `DB_DATA_PATH` with the path to your database data directory. It can be any directory. It will be used to store the files for the database. This will start the mongoDB service with a replica set named `my-rs`.
-    - **First time only**: The first time you start the mongodb, do the following two quick steps
-        - Run the command `mongosh` in another terminal to open the mongo shell.
-        - In the mongo shell, run the following command to initiate the replica set:
-        ```bash
-        rs.initiate()
-        ```
-        This command will initiate the replica set with the default configuration. You can customize the configuration as needed.
-        - Run `Exit` to exit the mongo shell.
-
-### Running a Mongodb Replica Set using Docker
-To set up a mongodb replica set using Docker, follow these steps:
-
-- Ensure you have Docker installed on your machine. You can download and install Docker from the official website [here](https://www.docker.com/products/docker-desktop).
-- Pull the mongoDB image from Docker Hub:
-```bash
-docker pull mongodb/mongodb-community-server:latest
-```
-- Run the image as a container:
-```bash
-docker run --name mongodb -p 27017:27017 -d mongodb/mongodb-community-server:latest --replSet my-rs
-```
-This command will start a mongoDB container with the name `mongodb` and expose port `27017` to the host machine.
-
-To check that the docker is up and running, run `docker ps` to get the lists of running container and you should see the following:
-```
-CONTAINER ID   IMAGE                                     COMMAND                  CREATED          STATUS              PORTS                       NAMES
-d289c01c3f1c   mongodb/mongodb-community-server:latest   "python3 /usr/local/…"   12 seconds ago   Up 11 seconds       0.0.0.0:27017->27017/tcp    mongodb
-```
-- Install the mongo shell to connect to the mongoDB container. You can install the mongo shell by following the instructions [here](https://www.mongodb.com/docs/mongodb-shell/install/).
-- Connect to the MongoDB Deployment with mongosh
-```bash
-mongosh --port 27017
-```
-- **First time only**: The first time you start the mongodb, do the following two quick steps
-    - Run the command `mongosh` in another terminal to open the mongo shell.
-    - In the mongo shell, run the following command to initiate the replica set. This command will initiate the replica set with the default configuration. Feel free to learn more about mongodb replica set [here](https://docs.mongodb.com/manual/tutorial/deploy-replica-set/).
-    ```bash
-    rs.initiate({_id: "my-rs", members: [{_id: 0, host: "localhost"}]})
-    ```
-    We should see the following output:
-    ```
-    { ok: 1 }
-    ```
-    - Run `exit` to exit the mongo shell.
-
-You have successfully set up a running MongoDB service our application can use as the database.
-
 ## Installing your VSCode Extension
 To make your development experience easier, you should install the jac extension for Visual Studio Code. This extension provides syntax highlighting, code snippets, and other features to help you write Jac Cloud code more efficiently. You can install the extension from the Visual Studio Code marketplace [here](https://marketplace.visualstudio.com/items?itemName=jaseci-labs.jaclang-extension).
 
@@ -104,10 +38,10 @@ This code defines two walkers, `hello_world_no_body` and `hello_world_with_body`
 Now, let's serve this code using Jac Cloud by running the following command:
 
 ```bash
-DATABASE_HOST=mongodb://localhost:27017/?replicaSet=my-rs jac serve server.jac
+jac serve server.jac
 ```
 
-This command starts the Jac Cloud server with the database host set to `mongodb://localhost:27017/?replicaSet=my-rs`. The server will serve the code in `server.jac` as an API. You can now access the API at `http://localhost:8000`. Go to `http://localhost:8000/docs` to see the Swagger documentation for the API. It should look something like this:
+This command starts the Jac Cloud server. The server will serve the code in `server.jac` as an API. You can now access the API at `http://localhost:8000`. Go to `http://localhost:8000/docs` to see the Swagger documentation for the API. It should look something like this:
 
 ![Swagger Docs](images/1_swagger.png)
 


Test patch:
diff --git a/.github/workflows/test-cloud.yml b/.github/workflows/test-cloud.yml
index bfb3510081..66159dc5f8 100644
--- a/.github/workflows/test-cloud.yml
+++ b/.github/workflows/test-cloud.yml
@@ -18,7 +18,6 @@ jobs:
         working-directory: jac-cloud
     env:
         SHOW_ENDPOINT_RETURNS: true
-        REDIS_HOST: redis://localhost
     services:
       redis:
         image: redis
@@ -52,13 +51,11 @@ jobs:
         pip install -e .
         pip install pytest
 
-    - name: Run tests
-      run: |
-        jac clean && jac tool gen_parser
-        jac serve jac_cloud/tests/simple_graph_mini.jac --port 8001 &
-        sleep 3 && pytest -s jac_cloud/tests/test_simple_graph_mini.py
-
-        export DATABASE_HOST="mongodb://localhost/?retryWrites=true&w=majority"
-        jac clean && jac tool gen_parser
-        jac serve jac_cloud/tests/simple_graph.jac --port 8000 &
-        sleep 3 && pytest -s jac_cloud/tests/test_simple_graph.py
+    - name: Run tests without mongodb and redis
+      run: pytest -sx
+    - name: Run tests with mongodb and redis
+      run: pytest -sx
+      env:
+        SHOW_ENDPOINT_RETURNS: true
+        DATABASE_HOST: mongodb://localhost/?retryWrites=true&w=majority
+        REDIS_HOST: redis://localhost
diff --git a/.github/workflows/test-mtllm.yml b/.github/workflows/test-mtllm.yml
index b4984ae109..130d9dadc3 100644
--- a/.github/workflows/test-mtllm.yml
+++ b/.github/workflows/test-mtllm.yml
@@ -28,6 +28,9 @@ jobs:
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip
+        cd ../jac
+        pip install -e .
+        cd ../jac-mtllm
         pip install -e .
         pip install pytest opencv-python-headless pillow
 
diff --git a/.github/workflows/test-orc.yml b/.github/workflows/test-orc.yml
new file mode 100644
index 0000000000..2f298dab59
--- /dev/null
+++ b/.github/workflows/test-orc.yml
@@ -0,0 +1,38 @@
+name: Run tests for jac-splice-orc
+
+on:
+  pull_request:
+    paths:
+      - "jac-splice-orc/**"
+  push:
+    branches:
+      - main
+    paths:
+      - "jac-splice-orc/**"
+
+jobs:
+  test-jaclang:
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: jac-splice-orc
+    steps:
+    - name: Check out code
+      uses: actions/checkout@v3
+
+    - name: Set up Python 3.12
+      uses: actions/setup-python@v3
+      with:
+        python-version: 3.12
+
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install -e .
+        pip install grpcio-tools pytest httpx
+
+    - name: Set environment for testing
+      run: |
+        echo "TEST_ENV=true" >> $GITHUB_ENV
+    - name: Run tests
+      run: pytest -x
diff --git a/jac-cloud/jac_cloud/tests/openapi_specs.yaml b/jac-cloud/jac_cloud/tests/openapi_specs.yaml
index a7fa6a14a1..7881a6fd12 100644
--- a/jac-cloud/jac_cloud/tests/openapi_specs.yaml
+++ b/jac-cloud/jac_cloud/tests/openapi_specs.yaml
@@ -841,6 +841,59 @@ paths:
       tags:
       - walker
       - walker
+  /walker/check_populated_graph:
+    post:
+      operationId: api_root_walker_check_populated_graph_post
+      responses:
+        '200':
+          content:
+            application/json:
+              schema:
+                anyOf:
+                - $ref: '#/components/schemas/ContextResponse_NoneType_'
+                - {}
+                title: Response Api Root Walker Check Populated Graph Post
+          description: Successful Response
+      security:
+      - HTTPBearer: []
+      summary: /check_populated_graph
+      tags:
+      - walker
+      - walker
+  /walker/check_populated_graph/{node}:
+    post:
+      operationId: api_entry_walker_check_populated_graph__node__post
+      parameters:
+      - in: path
+        name: node
+        required: true
+        schema:
+          anyOf:
+          - type: string
+          - type: 'null'
+          title: Node
+      responses:
+        '200':
+          content:
+            application/json:
+              schema:
+                anyOf:
+                - $ref: '#/components/schemas/ContextResponse_NoneType_'
+                - {}
+                title: Response Api Entry Walker Check Populated Graph  Node  Post
+          description: Successful Response
+        '422':
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/HTTPValidationError'
+          description: Validation Error
+      security:
+      - HTTPBearer: []
+      summary: /check_populated_graph/{node}
+      tags:
+      - walker
+      - walker
   /walker/combination1:
     get:
       operationId: api_root_walker_combination1_get
@@ -2789,6 +2842,59 @@ paths:
       tags:
       - walker
       - walker
+  /walker/populate_graph:
+    post:
+      operationId: api_root_walker_populate_graph_post
+      responses:
+        '200':
+          content:
+            application/json:
+              schema:
+                anyOf:
+                - $ref: '#/components/schemas/ContextResponse_NoneType_'
+                - {}
+                title: Response Api Root Walker Populate Graph Post
+          description: Successful Response
+      security:
+      - HTTPBearer: []
+      summary: /populate_graph
+      tags:
+      - walker
+      - walker
+  /walker/populate_graph/{node}:
+    post:
+      operationId: api_entry_walker_populate_graph__node__post
+      parameters:
+      - in: path
+        name: node
+        required: true
+        schema:
+          anyOf:
+          - type: string
+          - type: 'null'
+          title: Node
+      responses:
+        '200':
+          content:
+            application/json:
+              schema:
+                anyOf:
+                - $ref: '#/components/schemas/ContextResponse_NoneType_'
+                - {}
+                title: Response Api Entry Walker Populate Graph  Node  Post
+          description: Successful Response
+        '422':
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/HTTPValidationError'
+          description: Validation Error
+      security:
+      - HTTPBearer: []
+      summary: /populate_graph/{node}
+      tags:
+      - walker
+      - walker
   /walker/post_all_excluded:
     post:
       operationId: api_root_walker_post_all_excluded_post
@@ -3313,6 +3419,59 @@ paths:
       tags:
       - walker
       - walker
+  /walker/purge_populated_graph:
+    post:
+      operationId: api_root_walker_purge_populated_graph_post
+      responses:
+        '200':
+          content:
+            application/json:
+              schema:
+                anyOf:
+                - $ref: '#/components/schemas/ContextResponse_NoneType_'
+                - {}
+                title: Response Api Root Walker Purge Populated Graph Post
+          description: Successful Response
+      security:
+      - HTTPBearer: []
+      summary: /purge_populated_graph
+      tags:
+      - walker
+      - walker
+  /walker/purge_populated_graph/{node}:
+    post:
+      operationId: api_entry_walker_purge_populated_graph__node__post
+      parameters:
+      - in: path
+        name: node
+        required: true
+        schema:
+          anyOf:
+          - type: string
+          - type: 'null'
+          title: Node
+      responses:
+        '200':
+          content:
+            application/json:
+              schema:
+                anyOf:
+                - $ref: '#/components/schemas/ContextResponse_NoneType_'
+                - {}
+                title: Response Api Entry Walker Purge Populated Graph  Node  Post
+          description: Successful Response
+        '422':
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/HTTPValidationError'
+          description: Validation Error
+      security:
+      - HTTPBearer: []
+      summary: /purge_populated_graph/{node}
+      tags:
+      - walker
+      - walker
   /walker/traverse_graph:
     post:
       operationId: api_root_walker_traverse_graph_post
@@ -3366,6 +3525,59 @@ paths:
       tags:
       - walker
       - walker
+  /walker/traverse_populated_graph:
+    post:
+      operationId: api_root_walker_traverse_populated_graph_post
+      responses:
+        '200':
+          content:
+            application/json:
+              schema:
+                anyOf:
+                - $ref: '#/components/schemas/ContextResponse_NoneType_'
+                - {}
+                title: Response Api Root Walker Traverse Populated Graph Post
+          description: Successful Response
+      security:
+      - HTTPBearer: []
+      summary: /traverse_populated_graph
+      tags:
+      - walker
+      - walker
+  /walker/traverse_populated_graph/{node}:
+    post:
+      operationId: api_entry_walker_traverse_populated_graph__node__post
+      parameters:
+      - in: path
+        name: node
+        required: true
+        schema:
+          anyOf:
+          - type: string
+          - type: 'null'
+          title: Node
+      responses:
+        '200':
+          content:
+            application/json:
+              schema:
+                anyOf:
+                - $ref: '#/components/schemas/ContextResponse_NoneType_'
+                - {}
+                title: Response Api Entry Walker Traverse Populated Graph  Node  Post
+          description: Successful Response
+        '422':
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/HTTPValidationError'
+          description: Validation Error
+      security:
+      - HTTPBearer: []
+      summary: /traverse_populated_graph/{node}
+      tags:
+      - walker
+      - walker
   /walker/update_graph:
     post:
       operationId: api_root_walker_update_graph_post
diff --git a/jac-cloud/jac_cloud/tests/openapi_specs_mini.yaml b/jac-cloud/jac_cloud/tests/openapi_specs_mini.yaml
deleted file mode 100644
index b42cda0c7b..0000000000
--- a/jac-cloud/jac_cloud/tests/openapi_specs_mini.yaml
+++ /dev/null
@@ -1,1531 +0,0 @@
-components:
-  schemas:
-    Body_api_entry_walker_post_with_body_and_file__node__post:
-      properties:
-        body:
-          format: binary
-          title: Body
-          type: string
-        multiple:
-          items:
-            format: binary
-            type: string
-          title: Multiple
-          type: array
-        single:
-          format: binary
-          title: Single
-          type: string
-      required:
-      - body
-      - single
-      - multiple
-      title: Body_api_entry_walker_post_with_body_and_file__node__post
-      type: object
-    Body_api_entry_walker_post_with_file__node__post:
-      properties:
-        multiple:
-          items:
-            format: binary
-            type: string
-          title: Multiple
-          type: array
-        single:
-          format: binary
-          title: Single
-          type: string
-        singleOptional:
-          anyOf:
-          - format: binary
-            type: string
-          - type: 'null'
-          title: Singleoptional
-      required:
-      - single
-      - multiple
-      title: Body_api_entry_walker_post_with_file__node__post
-      type: object
-    Body_api_root_walker_post_with_body_and_file_post:
-      properties:
-        body:
-          format: binary
-          title: Body
-          type: string
-        multiple:
-          items:
-            format: binary
-            type: string
-          title: Multiple
-          type: array
-        single:
-          format: binary
-          title: Single
-          type: string
-      required:
-      - body
-      - single
-      - multiple
-      title: Body_api_root_walker_post_with_body_and_file_post
-      type: object
-    Body_api_root_walker_post_with_file_post:
-      properties:
-        multiple:
-          items:
-            format: binary
-            type: string
-          title: Multiple
-          type: array
-        single:
-          format: binary
-          title: Single
-          type: string
-        singleOptional:
-          anyOf:
-          - format: binary
-            type: string
-          - type: 'null'
-          title: Singleoptional
-      required:
-      - single
-      - multiple
-      title: Body_api_root_walker_post_with_file_post
-      type: object
-    HTTPValidationError:
-      properties:
-        detail:
-          items:
-            $ref: '#/components/schemas/ValidationError'
-          title: Detail
-          type: array
-      title: HTTPValidationError
-      type: object
-    ValidationError:
-      properties:
-        loc:
-          items:
-            anyOf:
-            - type: string
-            - type: integer
-          title: Location
-          type: array
-        msg:
-          title: Message
-          type: string
-        type:
-          title: Error Type
-          type: string
-      required:
-      - loc
-      - msg
-      - type
-      title: ValidationError
-      type: object
-    allow_other_root_access_body_model:
-      properties:
-        level:
-          anyOf:
-          - type: integer
-          - type: string
-          title: Level
-        root_id:
-          title: Root Id
-          type: string
-        via_all:
-          title: Via All
-          type: boolean
-      required:
-      - root_id
-      title: allow_other_root_access_body_model
-      type: object
-    combination1_body_model:
-      properties:
-        a:
-          title: A
-          type: string
-        b:
-          title: B
-          type: string
-        c:
-          title: C
-          type: string
-        d:
-          title: D
-          type: string
-      required:
-      - a
-      - b
-      - c
-      title: combination1_body_model
-      type: object
-    combination2_body_model:
-      properties:
-        a:
-          title: A
-          type: string
-        b:
-          title: B
-          type: string
-        c:
-          title: C
-          type: string
-        d:
-          title: D
-          type: string
-        e:
-          title: E
-          type: string
-      required:
-      - a
-      - b
-      - c
-      title: combination2_body_model
-      type: object
-    custom_status_code_body_model:
-      properties:
-        status:
-          title: Status
-          type: integer
-      required:
-      - status
-      title: custom_status_code_body_model
-      type: object
-    disallow_other_root_access_body_model:
-      properties:
-        root_id:
-          title: Root Id
-          type: string
-        via_all:
-          title: Via All
-          type: boolean
-      required:
-      - root_id
-      title: disallow_other_root_access_body_model
-      type: object
-    get_all_query_body_model:
-      properties:
-        a:
-          title: A
-          type: string
-        b:
-          title: B
-          type: string
-      required:
-      - a
-      - b
-      title: get_all_query_body_model
-      type: object
-    get_with_query_body_model:
-      properties:
-        a:
-          title: A
-          type: string
-      required:
-      - a
-      title: get_with_query_body_model
-      type: object
-    post_all_excluded_body_model:
-      properties:
-        a:
-          title: A
-          type: string
-        b:
-          title: B
-          type: string
-      title: post_all_excluded_body_model
-      type: object
-    post_partial_excluded_body_model:
-      properties:
-        a:
-          title: A
-          type: string
-        b:
-          title: B
-          type: string
-      required:
-      - a
-      title: post_partial_excluded_body_model
-      type: object
-    post_path_var_body_model:
-      properties:
-        a:
-          title: A
-          type: string
-      required:
-      - a
-      title: post_path_var_body_model
-      type: object
-    post_with_body_body_model:
-      properties:
-        a:
-          title: A
-          type: string
-      required:
-      - a
-      title: post_with_body_body_model
-      type: object
-info:
-  title: FastAPI
-  version: 0.1.0
-openapi: 3.1.0
-paths:
-  /healthz:
-    get:
-      description: Healthz API.
-      operationId: healthz_healthz_get
-      responses:
-        '200':
-          content:
-            application/json:
-              schema: {}
-          description: Successful Response
-      summary: Healthz
-      tags:
-      - monitoring
-  /walker/allow_other_root_access:
-    post:
-      operationId: api_root_walker_allow_other_root_access_post
-      requestBody:
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/allow_other_root_access_body_model'
-        required: true
-      responses:
-        '200':
-          content:
-            application/json:
-              schema: {}
-          description: Successful Response
-        '422':
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/HTTPValidationError'
-          description: Validation Error
-      summary: /allow_other_root_access
-      tags:
-      - walker
-  /walker/allow_other_root_access/{node}:
-    post:
-      operationId: api_entry_walker_allow_other_root_access__node__post
-      parameters:
-      - in: path
-        name: node
-        required: true
-        schema:
-          anyOf:
-          - type: string
-          - type: 'null'
-          title: Node
-      requestBody:
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/allow_other_root_access_body_model'
-        required: true
-      responses:
-        '200':
-          content:
-            application/json:
-              schema: {}
-          description: Successful Response
-        '422':
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/HTTPValidationError'
-          description: Validation Error
-      summary: /allow_other_root_access/{node}
-      tags:
-      - walker
-  /walker/combination1:
-    post:
-      operationId: api_root_walker_combination1_post
-      requestBody:
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/combination1_body_model'
-        required: true
-      responses:
-        '200':
-          content:
-            application/json:
-              schema: {}
-          description: Successful Response
-        '422':
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/HTTPValidationError'
-          description: Validation Error
-      summary: /combination1
-      tags:
-      - walker
-  /walker/combination1/{node}:
-    post:
-      operationId: api_entry_walker_combination1__node__post
-      parameters:
-      - in: path
-        name: node
-        required: true
-        schema:
-          anyOf:
-          - type: string
-          - type: 'null'
-          title: Node
-      requestBody:
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/combination1_body_model'
-        required: true
-      responses:
-        '200':
-          content:
-            application/json:
-              schema: {}
-          description: Successful Response
-        '422':
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/HTTPValidationError'
-          description: Validation Error
-      summary: /combination1/{node}
-      tags:
-      - walker
-  /walker/combination2:
-    post:
-      operationId: api_root_walker_combination2_post
-      requestBody:
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/combination2_body_model'
-        required: true
-      responses:
-        '200':
-          content:
-            application/json:
-              schema: {}
-          description: Successful Response
-        '422':
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/HTTPValidationError'
-          description: Validation Error
-      summary: /combination2
-      tags:
-      - walker
-  /walker/combination2/{node}:
-    post:
-      operationId: api_entry_walker_combination2__node__post
-      parameters:
-      - in: path
-        name: node
-        required: true
-        schema:
-          anyOf:
-          - type: string
-          - type: 'null'
-          title: Node
-      requestBody:
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/combination2_body_model'
-        required: true
-      responses:
-        '200':
-          content:
-            application/json:
-              schema: {}
-          description: Successful Response
-        '422':
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/HTTPValidationError'
-          description: Validation Error
-      summary: /combination2/{node}
-      tags:
-      - walker
-  /walker/create_graph:
-    post:
-      operationId: api_root_walker_create_graph_post
-      responses:
-        '200':
-          content:
-            application/json:
-              schema: {}
-          description: Successful Response
-      summary: /create_graph
-      tags:
-      - walker
-  /walker/create_graph/{node}:
-    post:
-      operationId: api_entry_walker_create_graph__node__post
-      parameters:
-      - in: path
-        name: node
-        required: true
-        schema:
-          anyOf:
-          - type: string
-          - type: 'null'
-          title: Node
-      responses:
-        '200':
-          content:
-            application/json:
-              schema: {}
-          description: Successful Response
-        '422':
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/HTTPValidationError'
-          description: Validation Error
-      summary: /create_graph/{node}
-      tags:
-      - walker
-  /walker/create_nested_node:
-    post:
-      operationId: api_root_walker_create_nested_node_post
-      responses:
-        '200':
-          content:
-            application/json:
-              schema: {}
-          description: Successful Response
-      summary: /create_nested_node
-      tags:
-      - walker
-  /walker/create_nested_node/{node}:
-    post:
-      operationId: api_entry_walker_create_nested_node__node__post
-      parameters:
-      - in: path
-        name: node
-        required: true
-        schema:
-          anyOf:
-          - type: string
-          - type: 'null'
-          title: Node
-      responses:
-        '200':
-          content:
-            application/json:
-              schema: {}
-          description: Successful Response
-        '422':
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/HTTPValidationError'
-          description: Validation Error
-      summary: /create_nested_node/{node}
-      tags:
-      - walker
-  /walker/custom_status_code:
-    post:
-      operationId: api_root_walker_custom_status_code_post
-      requestBody:
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/custom_status_code_body_model'
-        required: true
-      responses:
-        '200':
-          content:
-            application/json:
-              schema: {}
-          description: Successful Response
-        '422':
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/HTTPValidationError'
-          description: Validation Error
-      summary: /custom_status_code
-      tags:
-      - walker
-  /walker/custom_status_code/{node}:
-    post:
-      operationId: api_entry_walker_custom_status_code__node__post
-      parameters:
-      - in: path
-        name: node
-        required: true
-        schema:
-          anyOf:
-          - type: string
-          - type: 'null'
-          title: Node
-      requestBody:
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/custom_status_code_body_model'
-        required: true
-      responses:
-        '200':
-          content:
-            application/json:
-              schema: {}
-          description: Successful Response
-        '422':
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/HTTPValidationError'
-          description: Validation Error
-      summary: /custom_status_code/{node}
-      tags:
-      - walker
-  /walker/delete_nested_edge:
-    post:
-      operationId: api_root_walker_delete_nested_edge_post
-      responses:
-        '200':
-          content:
-            application/json:
-              schema: {}
-          description: Successful Response
-      summary: /delete_nested_edge
-      tags:
-      - walker
-  /walker/delete_nested_edge/{node}:
-    post:
-      operationId: api_entry_walker_delete_nested_edge__node__post
-      parameters:
-      - in: path
-        name: node
-        required: true
-        schema:
-          anyOf:
-          - type: string
-          - type: 'null'
-          title: Node
-      responses:
-        '200':
-          content:
-            application/json:
-              schema: {}
-          description: Successful Response
-        '422':
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/HTTPValidationError'
-          description: Validation Error
-      summary: /delete_nested_edge/{node}
-      tags:
-      - walker
-  /walker/delete_nested_node:
-    post:
-      operationId: api_root_walker_delete_nested_node_post
-      responses:
-        '200':
-          content:
-            application/json:
-              schema: {}
-          description: Successful Response
-      summary: /delete_nested_node
-      tags:
-      - walker
-  /walker/delete_nested_node/{node}:
-    post:
-      operationId: api_entry_walker_delete_nested_node__node__post
-      parameters:
-      - in: path
-        name: node
-        required: true
-        schema:
-          anyOf:
-          - type: string
-          - type: 'null'
-          title: Node
-      responses:
-        '200':
-          content:
-            application/json:
-              schema: {}
-          description: Successful Response
-        '422':
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/HTTPValidationError'
-          description: Validation Error
-      summary: /delete_nested_node/{node}
-      tags:
-      - walker
-  /walker/detach_nested_node:
-    post:
-      operationId: api_root_walker_detach_nested_node_post
-      responses:
-        '200':
-          content:
-            application/json:
-              schema: {}
-          description: Successful Response
-      summary: /detach_nested_node
-      tags:
-      - walker
-  /walker/detach_nested_node/{node}:
-    post:
-      operationId: api_entry_walker_detach_nested_node__node__post
-      parameters:
-      - in: path
-        name: node
-        required: true
-        schema:
-          anyOf:
-          - type: string
-          - type: 'null'
-          title: Node
-      responses:
-        '200':
-          content:
-            application/json:
-              schema: {}
-          description: Successful Response
-        '422':
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/HTTPValidationError'
-          description: Validation Error
-      summary: /detach_nested_node/{node}
-      tags:
-      - walker
-  /walker/detach_node:
-    post:
-      operationId: api_root_walker_detach_node_post
-      responses:
-        '200':
-          content:
-            application/json:
-              schema: {}
-          description: Successful Response
-      summary: /detach_node
-      tags:
-      - walker
-  /walker/detach_node/{node}:
-    post:
-      operationId: api_entry_walker_detach_node__node__post
-      parameters:
-      - in: path
-        name: node
-        required: true
-        schema:
-          anyOf:
-          - type: string
-          - type: 'null'
-          title: Node
-      responses:
-        '200':
-          content:
-            application/json:
-              schema: {}
-          description: Successful Response
-        '422':
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/HTTPValidationError'
-          description: Validation Error
-      summary: /detach_node/{node}
-      tags:
-      - walker
-  /walker/different_return:
-    post:
-      operationId: api_root_walker_different_return_post
-      responses:
-        '200':
-          content:
-            application/json:
-              schema: {}
-          description: Successful Response
-      summary: /different_return
-      tags:
-      - walker
-  /walker/different_return/{node}:
-    post:
-      operationId: api_entry_walker_different_return__node__post
-      parameters:
-      - in: path
-        name: node
-        required: true
-        schema:
-          anyOf:
-          - type: string
-          - type: 'null'
-          title: Node
-      responses:
-        '200':
-          content:
-            application/json:
-              schema: {}
-          description: Successful Response
-        '422':
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/HTTPValidationError'
-          description: Validation Error
-      summary: /different_return/{node}
-      tags:
-      - walker
-  /walker/disallow_other_root_access:
-    post:
-      operationId: api_root_walker_disallow_other_root_access_post
-      requestBody:
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/disallow_other_root_access_body_model'
-        required: true
-      responses:
-        '200':
-          content:
-            application/json:
-              schema: {}
-          description: Successful Response
-        '422':
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/HTTPValidationError'
-          description: Validation Error
-      summary: /disallow_other_root_access
-      tags:
-      - walker
-  /walker/disallow_other_root_access/{node}:
-    post:
-      operationId: api_entry_walker_disallow_other_root_access__node__post
-      parameters:
-      - in: path
-        name: node
-        required: true
-        schema:
-          anyOf:
-          - type: string
-          - type: 'null'
-          title: Node
-      requestBody:
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/disallow_other_root_access_body_model'
-        required: true
-      responses:
-        '200':
-          content:
-            application/json:
-              schema: {}
-          description: Successful Response
-        '422':
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/HTTPValidationError'
-          description: Validation Error
-      summary: /disallow_other_root_access/{node}
-      tags:
-      - walker
-  /walker/get_all_query:
-    post:
-      operationId: api_root_walker_get_all_query_post
-      requestBody:
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/get_all_query_body_model'
-        required: true
-      responses:
-        '200':
-          content:
-            application/json:
-              schema: {}
-          description: Successful Response
-        '422':
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/HTTPValidationError'
-          description: Validation Error
-      summary: /get_all_query
-      tags:
-      - walker
-  /walker/get_all_query/{node}:
-    post:
-      operationId: api_entry_walker_get_all_query__node__post
-      parameters:
-      - in: path
-        name: node
-        required: true
-        schema:
-          anyOf:
-          - type: string
-          - type: 'null'
-          title: Node
-      requestBody:
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/get_all_query_body_model'
-        required: true
-      responses:
-        '200':
-          content:
-            application/json:
-              schema: {}
-          description: Successful Response
-        '422':
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/HTTPValidationError'
-          description: Validation Error
-      summary: /get_all_query/{node}
-      tags:
-      - walker
-  /walker/get_no_body:
-    post:
-      operationId: api_root_walker_get_no_body_post
-      responses:
-        '200':
-          content:
-            application/json:
-              schema: {}
-          description: Successful Response
-      summary: /get_no_body
-      tags:
-      - walker
-  /walker/get_no_body/{node}:
-    post:
-      operationId: api_entry_walker_get_no_body__node__post
-      parameters:
-      - in: path
-        name: node
-        required: true
-        schema:
-          anyOf:
-          - type: string
-          - type: 'null'
-          title: Node
-      responses:
-        '200':
-          content:
-            application/json:
-              schema: {}
-          description: Successful Response
-        '422':
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/HTTPValidationError'
-          description: Validation Error
-      summary: /get_no_body/{node}
-      tags:
-      - walker
-  /walker/get_with_query:
-    post:
-      operationId: api_root_walker_get_with_query_post
-      requestBody:
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/get_with_query_body_model'
-        required: true
-      responses:
-        '200':
-          content:
-            application/json:
-              schema: {}
-          description: Successful Response
-        '422':
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/HTTPValidationError'
-          description: Validation Error
-      summary: /get_with_query
-      tags:
-      - walker
-  /walker/get_with_query/{node}:
-    post:
-      operationId: api_entry_walker_get_with_query__node__post
-      parameters:
-      - in: path
-        name: node
-        required: true
-        schema:
-          anyOf:
-          - type: string
-          - type: 'null'
-          title: Node
-      requestBody:
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/get_with_query_body_model'
-        required: true
-      responses:
-        '200':
-          content:
-            application/json:
-              schema: {}
-          description: Successful Response
-        '422':
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/HTTPValidationError'
-          description: Validation Error
-      summary: /get_with_query/{node}
-      tags:
-      - walker
-  /walker/post_all_excluded:
-    post:
-      operationId: api_root_walker_post_all_excluded_post
-      requestBody:
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/post_all_excluded_body_model'
-        required: true
-      responses:
-        '200':
-          content:
-            application/json:
-              schema: {}
-          description: Successful Response
-        '422':
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/HTTPValidationError'
-          description: Validation Error
-      summary: /post_all_excluded
-      tags:
-      - walker
-  /walker/post_all_excluded/{node}:
-    post:
-      operationId: api_entry_walker_post_all_excluded__node__post
-      parameters:
-      - in: path
-        name: node
-        required: true
-        schema:
-          anyOf:
-          - type: string
-          - type: 'null'
-          title: Node
-      requestBody:
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/post_all_excluded_body_model'
-        required: true
-      responses:
-        '200':
-          content:
-            application/json:
-              schema: {}
-          description: Successful Response
-        '422':
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/HTTPValidationError'
-          description: Validation Error
-      summary: /post_all_excluded/{node}
-      tags:
-      - walker
-  /walker/post_no_body:
-    post:
-      operationId: api_root_walker_post_no_body_post
-      responses:
-        '200':
-          content:
-            application/json:
-              schema: {}
-          description: Successful Response
-      summary: /post_no_body
-      tags:
-      - walker
-  /walker/post_no_body/{node}:
-    post:
-      operationId: api_entry_walker_post_no_body__node__post
-      parameters:
-      - in: path
-        name: node
-        required: true
-        schema:
-          anyOf:
-          - type: string
-          - type: 'null'
-          title: Node
-      responses:
-        '200':
-          content:
-            application/json:
-              schema: {}
-          description: Successful Response
-        '422':
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/HTTPValidationError'
-          description: Validation Error
-      summary: /post_no_body/{node}
-      tags:
-      - walker
-  /walker/post_partial_excluded:
-    post:
-      operationId: api_root_walker_post_partial_excluded_post
-      requestBody:
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/post_partial_excluded_body_model'
-        required: true
-      responses:
-        '200':
-          content:
-            application/json:
-              schema: {}
-          description: Successful Response
-        '422':
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/HTTPValidationError'
-          description: Validation Error
-      summary: /post_partial_excluded
-      tags:
-      - walker
-  /walker/post_partial_excluded/{node}:
-    post:
-      operationId: api_entry_walker_post_partial_excluded__node__post
-      parameters:
-      - in: path
-        name: node
-        required: true
-        schema:
-          anyOf:
-          - type: string
-          - type: 'null'
-          title: Node
-      requestBody:
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/post_partial_excluded_body_model'
-        required: true
-      responses:
-        '200':
-          content:
-            application/json:
-              schema: {}
-          description: Successful Response
-        '422':
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/HTTPValidationError'
-          description: Validation Error
-      summary: /post_partial_excluded/{node}
-      tags:
-      - walker
-  /walker/post_path_var:
-    post:
-      operationId: api_root_walker_post_path_var_post
-      requestBody:
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/post_path_var_body_model'
-        required: true
-      responses:
-        '200':
-          content:
-            application/json:
-              schema: {}
-          description: Successful Response
-        '422':
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/HTTPValidationError'
-          description: Validation Error
-      summary: /post_path_var
-      tags:
-      - walker
-  /walker/post_path_var/{node}:
-    post:
-      operationId: api_entry_walker_post_path_var__node__post
-      parameters:
-      - in: path
-        name: node
-        required: true
-        schema:
-          anyOf:
-          - type: string
-          - type: 'null'
-          title: Node
-      requestBody:
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/post_path_var_body_model'
-        required: true
-      responses:
-        '200':
-          content:
-            application/json:
-              schema: {}
-          description: Successful Response
-        '422':
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/HTTPValidationError'
-          description: Validation Error
-      summary: /post_path_var/{node}
-      tags:
-      - walker
-  /walker/post_with_body:
-    post:
-      operationId: api_root_walker_post_with_body_post
-      requestBody:
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/post_with_body_body_model'
-        required: true
-      responses:
-        '200':
-          content:
-            application/json:
-              schema: {}
-          description: Successful Response
-        '422':
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/HTTPValidationError'
-          description: Validation Error
-      summary: /post_with_body
-      tags:
-      - walker
-  /walker/post_with_body/{node}:
-    post:
-      operationId: api_entry_walker_post_with_body__node__post
-      parameters:
-      - in: path
-        name: node
-        required: true
-        schema:
-          anyOf:
-          - type: string
-          - type: 'null'
-          title: Node
-      requestBody:
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/post_with_body_body_model'
-        required: true
-      responses:
-        '200':
-          content:
-            application/json:
-              schema: {}
-          description: Successful Response
-        '422':
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/HTTPValidationError'
-          description: Validation Error
-      summary: /post_with_body/{node}
-      tags:
-      - walker
-  /walker/post_with_body_and_file:
-    post:
-      operationId: api_root_walker_post_with_body_and_file_post
-      requestBody:
-        content:
-          multipart/form-data:
-            schema:
-              $ref: '#/components/schemas/Body_api_root_walker_post_with_body_and_file_post'
-        required: true
-      responses:
-        '200':
-          content:
-            application/json:
-              schema: {}
-          description: Successful Response
-        '422':
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/HTTPValidationError'
-          description: Validation Error
-      summary: /post_with_body_and_file
-      tags:
-      - walker
-  /walker/post_with_body_and_file/{node}:
-    post:
-      operationId: api_entry_walker_post_with_body_and_file__node__post
-      parameters:
-      - in: path
-        name: node
-        required: true
-        schema:
-          anyOf:
-          - type: string
-          - type: 'null'
-          title: Node
-      requestBody:
-        content:
-          multipart/form-data:
-            schema:
-              $ref: '#/components/schemas/Body_api_entry_walker_post_with_body_and_file__node__post'
-        required: true
-      responses:
-        '200':
-          content:
-            application/json:
-              schema: {}
-          description: Successful Response
-        '422':
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/HTTPValidationError'
-          description: Validation Error
-      summary: /post_with_body_and_file/{node}
-      tags:
-      - walker
-  /walker/post_with_file:
-    post:
-      operationId: api_root_walker_post_with_file_post
-      requestBody:
-        content:
-          multipart/form-data:
-            schema:
-              $ref: '#/components/schemas/Body_api_root_walker_post_with_file_post'
-        required: true
-      responses:
-        '200':
-          content:
-            application/json:
-              schema: {}
-          description: Successful Response
-        '422':
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/HTTPValidationError'
-          description: Validation Error
-      summary: /post_with_file
-      tags:
-      - walker
-  /walker/post_with_file/{node}:
-    post:
-      operationId: api_entry_walker_post_with_file__node__post
-      parameters:
-      - in: path
-        name: node
-        required: true
-        schema:
-          anyOf:
-          - type: string
-          - type: 'null'
-          title: Node
-      requestBody:
-        content:
-          multipart/form-data:
-            schema:
-              $ref: '#/components/schemas/Body_api_entry_walker_post_with_file__node__post'
-        required: true
-      responses:
-        '200':
-          content:
-            application/json:
-              schema: {}
-          description: Successful Response
-        '422':
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/HTTPValidationError'
-          description: Validation Error
-      summary: /post_with_file/{node}
-      tags:
-      - walker
-  /walker/traverse_graph:
-    post:
-      operationId: api_root_walker_traverse_graph_post
-      responses:
-        '200':
-          content:
-            application/json:
-              schema: {}
-          description: Successful Response
-      summary: /traverse_graph
-      tags:
-      - walker
-  /walker/traverse_graph/{node}:
-    post:
-      operationId: api_entry_walker_traverse_graph__node__post
-      parameters:
-      - in: path
-        name: node
-        required: true
-        schema:
-          anyOf:
-          - type: string
-          - type: 'null'
-          title: Node
-      responses:
-        '200':
-          content:
-            application/json:
-              schema: {}
-          description: Successful Response
-        '422':
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/HTTPValidationError'
-          description: Validation Error
-      summary: /traverse_graph/{node}
-      tags:
-      - walker
-  /walker/update_graph:
-    post:
-      operationId: api_root_walker_update_graph_post
-      responses:
-        '200':
-          content:
-            application/json:
-              schema: {}
-          description: Successful Response
-      summary: /update_graph
-      tags:
-      - walker
-  /walker/update_graph/{node}:
-    post:
-      operationId: api_entry_walker_update_graph__node__post
-      parameters:
-      - in: path
-        name: node
-        required: true
-        schema:
-          anyOf:
-          - type: string
-          - type: 'null'
-          title: Node
-      responses:
-        '200':
-          content:
-            application/json:
-              schema: {}
-          description: Successful Response
-        '422':
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/HTTPValidationError'
-          description: Validation Error
-      summary: /update_graph/{node}
-      tags:
-      - walker
-  /walker/update_nested_node:
-    post:
-      operationId: api_root_walker_update_nested_node_post
-      responses:
-        '200':
-          content:
-            application/json:
-              schema: {}
-          description: Successful Response
-      summary: /update_nested_node
-      tags:
-      - walker
-  /walker/update_nested_node/{node}:
-    post:
-      operationId: api_entry_walker_update_nested_node__node__post
-      parameters:
-      - in: path
-        name: node
-        required: true
-        schema:
-          anyOf:
-          - type: string
-          - type: 'null'
-          title: Node
-      responses:
-        '200':
-          content:
-            application/json:
-              schema: {}
-          description: Successful Response
-        '422':
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/HTTPValidationError'
-          description: Validation Error
-      summary: /update_nested_node/{node}
-      tags:
-      - walker
-  /walker/visit_nested_node:
-    post:
-      operationId: api_root_walker_visit_nested_node_post
-      responses:
-        '200':
-          content:
-            application/json:
-              schema: {}
-          description: Successful Response
-      summary: /visit_nested_node
-      tags:
-      - walker
-  /walker/visit_nested_node/{node}:
-    post:
-      operationId: api_entry_walker_visit_nested_node__node__post
-      parameters:
-      - in: path
-        name: node
-        required: true
-        schema:
-          anyOf:
-          - type: string
-          - type: 'null'
-          title: Node
-      responses:
-        '200':
-          content:
-            application/json:
-              schema: {}
-          description: Successful Response
-        '422':
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/HTTPValidationError'
-          description: Validation Error
-      summary: /visit_nested_node/{node}
-      tags:
-      - walker
\ No newline at end of file
diff --git a/jac-cloud/jac_cloud/tests/simple_graph.jac b/jac-cloud/jac_cloud/tests/simple_graph.jac
index 3fcc4753b9..1a8fb913b6 100644
--- a/jac-cloud/jac_cloud/tests/simple_graph.jac
+++ b/jac-cloud/jac_cloud/tests/simple_graph.jac
@@ -5,8 +5,6 @@ import:py from jac_cloud.jaseci.utils {SendGridEmailer}
 import:py from dataclasses {dataclass}
 import:py from fastapi {UploadFile}
 
-include:jac simple_graph_mini;
-
 class User:BaseUser: {
     has name: str;
 
@@ -45,65 +43,423 @@ class User:BaseUser: {
     }
 }
 
+enum Enum {
+    A = "a",
+    B = "b",
+    C = "c"
+}
+
+node A {
+    has val: int;
+}
+
+node B {
+    has val: int;
+}
+
+node C {
+    has val: int;
+}
+
+obj Child {
+    has val: int, arr: list[int], json: dict[str, int], enum_field: Enum;
+}
+
+obj Parent:Child: {
+    has child: Child;
+}
+
+node Nested {
+    has val: int, arr: list[int], json: dict[str, int], parent: Parent, enum_field: Enum;
+}
+
+walker create_graph {
+    can enter_root with `root entry {
+        a = A(val=0);
+        b = B(val=1);
+        c = C(val=2);
+        here ++> a;
+        a ++> b;
+        b ++> c;
+
+        report here;
+        report a;
+        report b;
+        report c;
+    }
+}
+
+walker traverse_graph {
+    can enter with `root entry {
+        report here;
+        visit [-->];
+    }
+
+    can enter_A with A entry {
+        report here;
+        visit [-->];
+    }
+
+    can enter_B with B entry {
+        report here;
+        visit [-->];
+    }
+
+    can enter_C with C entry {
+        report here;
+    }
+}
+
+walker detach_node {
+    can enter with `root entry {
+        visit [-->];
+    }
+
+    can enter_A with A entry {
+        visit [-->];
+    }
+
+    can enter_B with B entry {
+        return here del --> [-->];
+    }
+}
+
+walker update_graph {
+    can enter with `root entry {
+        report here;
+        visit [-->];
+    }
+
+    can enter_A with A entry {
+        here.val = 1;
+        report here;
+        visit [-->];
+    }
 
-:walker:detach_node:can:enter_B {
-    return here del --> [-->];
+    can enter_B with B entry {
+        here.val = 2;
+        report here;
+        visit [-->];
+    }
 }
 
-:walker:create_nested_node:can:enter_root {
-    n = Nested(
-        val=0,
-        arr=[],
-        json={},
-        parent=Parent(
-            val=1,
-            arr=[1],
-            json={"a": 1},
-            child=Child(
-                val=2,
-                arr=[1, 2],
-                json={"a": 1, "b": 2},
-                enum_field = Enum.C
+walker create_nested_node {
+    can enter_root with `root entry {
+        n = Nested(
+            val=0,
+            arr=[],
+            json={},
+            parent=Parent(
+                val=1,
+                arr=[1],
+                json={"a": 1},
+                child=Child(
+                    val=2,
+                    arr=[1, 2],
+                    json={"a": 1, "b": 2},
+                    enum_field = Enum.C
+                ),
+                enum_field = Enum.B
             ),
-            enum_field = Enum.B
-        ),
-        enum_field = Enum.A
-    );
-    here ++> n;
-    return n;
-}
-
-:walker:update_nested_node:can:enter_root {
-    nested = [-->(`?Nested)][0];
-    nested.parent.child.json["c"] = 3;
-    nested.parent.child.arr.append(3);
-    nested.parent.child.val = 3;
-    nested.parent.child.enum_field = Enum.A;
-    nested.parent.json["b"] = 2;
-    nested.parent.arr.append(2);
-    nested.parent.val = 2;
-    nested.parent.enum_field = Enum.C;
-    nested.json["a"] = 1;
-    nested.arr.append(1);
-    nested.val = 1;
-    nested.enum_field = Enum.B;
-    return nested;
-}
-
-:walker:update_nested_node:can:enter_nested {
-    here.parent.child.json["c"] = 3;
-    here.parent.child.arr.append(3);
-    here.parent.child.val = 3;
-    here.parent.child.enum_field = Enum.A;
-    here.parent.json["b"] = 2;
-    here.parent.arr.append(2);
-    here.parent.val = 2;
-    here.parent.enum_field = Enum.C;
-    here.json["a"] = 1;
-    here.arr.append(1);
-    here.val = 1;
-    here.enum_field = Enum.B;
-    return here;
+            enum_field = Enum.A
+        );
+        here ++> n;
+        return n;
+    }
+}
+
+walker update_nested_node {
+    can enter_root with `root entry {
+        nested = [-->(`?Nested)][0];
+        nested.parent.child.json["c"] = 3;
+        nested.parent.child.arr.append(3);
+        nested.parent.child.val = 3;
+        nested.parent.child.enum_field = Enum.A;
+        nested.parent.json["b"] = 2;
+        nested.parent.arr.append(2);
+        nested.parent.val = 2;
+        nested.parent.enum_field = Enum.C;
+        nested.json["a"] = 1;
+        nested.arr.append(1);
+        nested.val = 1;
+        nested.enum_field = Enum.B;
+        return nested;
+    }
+
+    can enter_nested with Nested entry {
+        here.parent.child.json["c"] = 3;
+        here.parent.child.arr.append(3);
+        here.parent.child.val = 3;
+        here.parent.child.enum_field = Enum.A;
+        here.parent.json["b"] = 2;
+        here.parent.arr.append(2);
+        here.parent.val = 2;
+        here.parent.enum_field = Enum.C;
+        here.json["a"] = 1;
+        here.arr.append(1);
+        here.val = 1;
+        here.enum_field = Enum.B;
+        return here;
+    }
+}
+
+walker detach_nested_node {
+    can enter_root with `root entry {
+        report here del--> [-->(`?Nested)];
+    }
+}
+
+walker visit_nested_node {
+    can enter_root with `root entry {
+        nesteds = [-->(`?Nested)];
+        if nesteds {
+            report [-->(`?Nested)][0];
+        } else {
+            report nesteds;
+        }
+    }
+
+    can enter_nested with Nested entry {
+        report here;
+    }
+}
+
+walker delete_nested_node {
+    can enter_root with `root entry {
+        nested = [-->(`?Nested)][0];
+        Jac.destroy(nested);
+        # nested.__jac__.apply();
+
+        report [-->(`?Nested)];
+    }
+}
+
+walker delete_nested_edge {
+    can enter_root with `root entry {
+        nested_edge = :e:[-->][0];
+        Jac.destroy(nested_edge);
+
+        report [-->(`?Nested)];
+    }
+}
+
+walker allow_other_root_access {
+    has root_id: str, level: int | str = 0, via_all: bool = False;
+
+    can enter_root with `root entry {
+        if self.via_all {
+            Jac.unrestrict(here, self.level);
+        } else {
+            import:py from jac_cloud.core.architype {BaseAnchor}
+            Jac.allow_root(here, BaseAnchor.ref(self.root_id), self.level);
+        }
+    }
+
+    can enter_nested with Nested entry {
+        if self.via_all {
+            Jac.unrestrict(here, self.level);
+        } else {
+            import:py from jac_cloud.core.architype {BaseAnchor}
+            Jac.allow_root(here, BaseAnchor.ref(self.root_id), self.level);
+        }
+    }
+}
+
+walker disallow_other_root_access {
+    has root_id: str, via_all: bool = False;
+
+    can enter_root with `root entry {
+        if self.via_all {
+            Jac.restrict(here);
+        } else {
+            import:py from jac_cloud.core.architype {BaseAnchor}
+            Jac.disallow_root(here, BaseAnchor.ref(self.root_id));
+        }
+    }
+
+    can enter_nested with Nested entry {
+        if self.via_all {
+            Jac.restrict(here);
+        } else {
+            import:py from jac_cloud.core.architype {BaseAnchor}
+            Jac.disallow_root(here, BaseAnchor.ref(self.root_id));
+        }
+    }
+}
+
+#################################################################
+#                    ENDPOINT CUSTOMIZATIONS                    #
+#################################################################
+
+walker post_no_body {}
+
+walker post_with_body {
+    has a: str;
+}
+
+walker get_no_body {
+    class __specs__ {
+        has methods: list = ["get"];
+    }
+}
+
+walker get_with_query {
+    has a: str;
+
+    class __specs__ {
+        has methods: list = ["get"], as_query: list = ["a"];
+    }
+}
+
+walker get_all_query {
+    has a: str;
+    has b: str;
+
+    class __specs__ {
+        has methods: list = ["get"], as_query: list = "*", auth: bool = False;
+    }
+}
+
+walker post_path_var {
+    has a: str;
+
+    class __specs__ {
+        has path: str = "/{a}", methods: list = ["post", "get"];
+    }
+}
+
+walker post_all_excluded {
+    has a: str = "";
+    has b: str = "";
+
+    class __specs__ {
+        has excluded: str = "*", auth: bool = False;
+    }
+}
+
+walker post_partial_excluded {
+    has a: str;
+    has b: str = "";
+
+    class __specs__ {
+        has excluded: str = "b";
+    }
+}
+
+walker combination1 {
+    has a: str;
+    has b: str;
+    has c: str;
+    has d: str = "";
+
+    class __specs__ {
+        has methods: list = ["post", "get"], as_query: list = ["a", "b"], excluded: str = "d";
+    }
+}
+
+
+walker combination2 {
+    has a: str;
+    has b: str;
+    has c: str;
+    has d: str = "";
+    has e: str = "";
+
+    class __specs__ {
+        has path: str = "/{a}",
+        methods: list = ["post", "get", "put", "patch", "delete", "head", "trace", "options"],
+        as_query: list = ["b"],
+        excluded: list = ["d", "e"];
+    }
+}
+
+walker post_with_file {
+    has single: UploadFile;
+    has multiple: list[UploadFile];
+    has singleOptional: UploadFile | None = None;
+
+
+    can enter with `root entry {
+        print(self.single);
+        print(self.multiple);
+        print(self.singleOptional);
+
+        multiple = [];
+        for file in self.multiple {
+            multiple.append({
+                "name": file.filename,
+                "content_type": file.content_type,
+                "size": file.size,
+            });
+        }
+
+        single = {
+            "single": {
+                "name": self.single.filename,
+                "content_type": self.single.content_type,
+                "size": self.single.size,
+            }
+        };
+
+        report {
+            "single": single,
+            "multiple": multiple,
+            "singleOptional": self.singleOptional
+        };
+    }
+
+    class __specs__ {}
+}
+
+walker post_with_body_and_file {
+    has val: int;
+    has single: UploadFile;
+    has multiple: list[UploadFile];
+    has optional_val: int = 0;
+
+    can enter with `root entry {
+        print(self.val);
+        print(self.optional_val);
+        print(self.single);
+        print(self.multiple);
+    }
+
+    class __specs__ {
+        has auth: bool = False;
+    }
+}
+
+walker custom_status_code {
+    has status: int;
+
+    can enter with `root entry {
+        Jac.get_context().status = self.status;
+    }
+}
+
+walker different_return {
+
+    can enter1 with `root entry {
+    }
+
+    can enter2 with A entry -> int {
+    }
+
+    can enter3 with B entry -> str {
+    }
+
+    can enter4 with C entry -> bool {
+    }
+
+    can enter5 with Nested entry -> Parent {
+    }
+
+    can enter6 with `root entry -> list | dict {
+    }
+
+    class __specs__ {
+        has auth: bool = False;
+    }
 }
 
 :walker:detach_nested_node:can:enter_root {
@@ -227,54 +583,131 @@ walker manual_delete_nested_edge {
     }
 }
 
-:walker:allow_other_root_access:can:enter_root {
-    if self.via_all {
-        Jac.unrestrict(here, self.level);
-    } else {
-        import:py from jac_cloud.core.architype {BaseAnchor}
-        Jac.allow_root(here, BaseAnchor.ref(self.root_id), self.level);
+walker custom_report {
+    can enter1 with `root entry {
+        report 1;
+        report 2;
+        report 3;
+
+        Jac.report({
+            "testing": 1
+        }, True);
     }
-}
 
-:walker:allow_other_root_access:can:enter_nested {
-    if self.via_all {
-        Jac.unrestrict(here, self.level);
-    } else {
-        import:py from jac_cloud.core.architype {BaseAnchor}
-        Jac.allow_root(here, BaseAnchor.ref(self.root_id), self.level);
+    class __specs__ {
+        has auth: bool = False;
     }
 }
 
-:walker:disallow_other_root_access:can:enter_root {
-    if self.via_all {
-        Jac.restrict(here);
-    } else {
-        import:py from jac_cloud.core.architype {BaseAnchor}
-        Jac.disallow_root(here, BaseAnchor.ref(self.root_id));
-    }
+##################################################################
+#                           FOR PURGER                           #
+##################################################################
+
+node D {
+    has id: int;
 }
 
-:walker:disallow_other_root_access:can:enter_nested {
-    if self.via_all {
-        Jac.restrict(here);
-    } else {
-        import:py from jac_cloud.core.architype {BaseAnchor}
-        Jac.disallow_root(here, BaseAnchor.ref(self.root_id));
+node E {
+    has id: int;
+}
+
+node F {
+    has id: int;
+}
+
+node G {
+    has id: int;
+}
+
+node H {
+    has id: int;
+}
+
+
+walker populate_graph {
+    can setup1 with `root entry {
+        for i in range(2) {
+            here ++> D(id=i);
+        }
+        visit [-->];
+    }
+
+    can setup2 with D entry {
+        for i in range(2) {
+            here ++> E(id=i);
+        }
+        visit [-->];
+    }
+
+    can setup3 with E entry {
+        for i in range(2) {
+            here ++> F(id=i);
+        }
+        visit [-->];
+    }
+
+    can setup4 with F entry {
+        for i in range(2) {
+            here ++> G(id=i);
+        }
+        visit [-->];
+    }
+
+    can setup5 with G entry {
+        for i in range(2) {
+            here ++> H(id=i);
+        }
+        visit [-->];
     }
 }
 
-walker custom_report {
+walker traverse_populated_graph {
     can enter1 with `root entry {
-        report 1;
-        report 2;
-        report 3;
+        report here;
+        visit [-->];
+    }
 
-        Jac.report({
-            "testing": 1
-        }, True);
+    can enter2 with D entry {
+        report here;
+        visit [-->];
     }
 
-    class __specs__ {
-        has auth: bool = False;
+    can enter3 with E entry {
+        report here;
+        visit [-->];
+    }
+
+    can enter4 with F entry {
+        report here;
+        visit [-->];
+    }
+
+    can enter5 with G entry {
+        report here;
+        visit [-->];
+    }
+
+    can enter6 with H entry {
+        report here;
+        visit [-->];
+    }
+}
+
+walker purge_populated_graph {
+    can purge with `root entry {
+        report Jac.reset_graph();
+    }
+}
+
+walker check_populated_graph {
+    can enter with `root entry {
+        import:py from jac_cloud.core.architype {NodeAnchor, EdgeAnchor, WalkerAnchor}
+
+        id = here.__jac__.id;
+        count = NodeAnchor.Collection.count({"$or": [{"_id": id}, {"root": id}]});
+        count += EdgeAnchor.Collection.count({"root": id});
+        count += WalkerAnchor.Collection.count({"root": id});
+
+        report count;
     }
 }
\ No newline at end of file
diff --git a/jac-cloud/jac_cloud/tests/simple_graph_mini.jac b/jac-cloud/jac_cloud/tests/simple_graph_mini.jac
deleted file mode 100644
index 70d5a5cb4a..0000000000
--- a/jac-cloud/jac_cloud/tests/simple_graph_mini.jac
+++ /dev/null
@@ -1,418 +0,0 @@
-"""Example of simple walker walking nodes."""
-import:py from fastapi {UploadFile}
-import:py from uuid {UUID}
-
-enum Enum {
-    A = "a",
-    B = "b",
-    C = "c"
-}
-
-node A {
-    has val: int;
-}
-
-node B {
-    has val: int;
-}
-
-node C {
-    has val: int;
-}
-
-obj Child {
-    has val: int, arr: list[int], json: dict[str, int], enum_field: Enum;
-}
-
-obj Parent:Child: {
-    has child: Child;
-}
-
-node Nested {
-    has val: int, arr: list[int], json: dict[str, int], parent: Parent, enum_field: Enum;
-}
-
-walker create_graph {
-    can enter_root with `root entry {
-        a = A(val=0);
-        b = B(val=1);
-        c = C(val=2);
-        here ++> a;
-        a ++> b;
-        b ++> c;
-
-        report here;
-        report a;
-        report b;
-        report c;
-    }
-}
-
-walker traverse_graph {
-    can enter with `root entry {
-        report here;
-        visit [-->];
-    }
-
-    can enter_A with A entry {
-        report here;
-        visit [-->];
-    }
-
-    can enter_B with B entry {
-        report here;
-        visit [-->];
-    }
-
-    can enter_C with C entry {
-        report here;
-    }
-}
-
-walker detach_node {
-    can enter with `root entry {
-        visit [-->];
-    }
-
-    can enter_A with A entry {
-        visit [-->];
-    }
-
-    can enter_B with B entry {
-        report here del --> [-->];
-    }
-}
-
-walker update_graph {
-    can enter with `root entry {
-        report here;
-        visit [-->];
-    }
-
-    can enter_A with A entry {
-        here.val = 1;
-        report here;
-        visit [-->];
-    }
-
-    can enter_B with B entry {
-        here.val = 2;
-        report here;
-        visit [-->];
-    }
-}
-
-walker create_nested_node {
-    can enter_root with `root entry {
-        n = Nested(
-            val=0,
-            arr=[],
-            json={},
-            parent=Parent(
-                val=1,
-                arr=[1],
-                json={"a": 1},
-                child=Child(
-                    val=2,
-                    arr=[1, 2],
-                    json={"a": 1, "b": 2},
-                    enum_field = Enum.C
-                ),
-                enum_field = Enum.B
-            ),
-            enum_field = Enum.A
-        );
-        here ++> n;
-        report n;
-    }
-}
-
-walker update_nested_node {
-    can enter_root with `root entry {
-        nested = [-->(`?Nested)][0];
-        nested.parent.child.json["c"] = 3;
-        nested.parent.child.arr.append(3);
-        nested.parent.child.val = 3;
-        nested.parent.child.enum_field = Enum.A;
-        nested.parent.json["b"] = 2;
-        nested.parent.arr.append(2);
-        nested.parent.val = 2;
-        nested.parent.enum_field = Enum.C;
-        nested.json["a"] = 1;
-        nested.arr.append(1);
-        nested.val = 1;
-        nested.enum_field = Enum.B;
-        report nested;
-    }
-
-    can enter_nested with Nested entry {
-        here.parent.child.json["c"] = 3;
-        here.parent.child.arr.append(3);
-        here.parent.child.val = 3;
-        here.parent.child.enum_field = Enum.A;
-        here.parent.json["b"] = 2;
-        here.parent.arr.append(2);
-        here.parent.val = 2;
-        here.parent.enum_field = Enum.C;
-        here.json["a"] = 1;
-        here.arr.append(1);
-        here.val = 1;
-        here.enum_field = Enum.B;
-        report here;
-    }
-}
-
-walker detach_nested_node {
-    can enter_root with `root entry {
-        report here del--> [-->(`?Nested)];
-    }
-}
-
-walker visit_nested_node {
-    can enter_root with `root entry {
-        nesteds = [-->(`?Nested)];
-        if nesteds {
-            report [-->(`?Nested)][0];
-        } else {
-            report nesteds;
-        }
-    }
-
-    can enter_nested with Nested entry {
-        report here;
-    }
-}
-
-walker delete_nested_node {
-    can enter_root with `root entry {
-        nested = [-->(`?Nested)][0];
-        Jac.destroy(nested);
-        # nested.__jac__.apply();
-
-        report [-->(`?Nested)];
-    }
-}
-
-walker delete_nested_edge {
-    can enter_root with `root entry {
-        nested_edge = :e:[-->][0];
-        Jac.destroy(nested_edge);
-
-        report [-->(`?Nested)];
-    }
-}
-
-walker allow_other_root_access {
-    has root_id: str, level: int | str = 0, via_all: bool = False;
-
-    can enter_root with `root entry {
-        if self.via_all {
-            Jac.unrestrict(here, self.level);
-        } else {
-            Jac.allow_root(here, UUID(self.root_id), self.level);
-        }
-    }
-
-    can enter_nested with Nested entry {
-        if self.via_all {
-            Jac.unrestrict(here, self.level);
-        } else {
-            Jac.allow_root(here, UUID(self.root_id), self.level);
-        }
-    }
-}
-
-walker disallow_other_root_access {
-    has root_id: str, via_all: bool = False;
-
-    can enter_root with `root entry {
-        if self.via_all {
-            Jac.restrict(here);
-        } else {
-            Jac.disallow_root(here, UUID(self.root_id));
-        }
-    }
-
-    can enter_nested with Nested entry {
-        if self.via_all {
-            Jac.restrict(here);
-        } else {
-            Jac.disallow_root(here, UUID(self.root_id));
-        }
-    }
-}
-
-#################################################################
-#                    ENDPOINT CUSTOMIZATIONS                    #
-#################################################################
-
-walker post_no_body {}
-
-walker post_with_body {
-    has a: str;
-}
-
-walker get_no_body {
-    class __specs__ {
-        has methods: list = ["get"];
-    }
-}
-
-walker get_with_query {
-    has a: str;
-
-    class __specs__ {
-        has methods: list = ["get"], as_query: list = ["a"];
-    }
-}
-
-walker get_all_query {
-    has a: str;
-    has b: str;
-
-    class __specs__ {
-        has methods: list = ["get"], as_query: list = "*", auth: bool = False;
-    }
-}
-
-walker post_path_var {
-    has a: str;
-
-    class __specs__ {
-        has path: str = "/{a}", methods: list = ["post", "get"];
-    }
-}
-
-walker post_all_excluded {
-    has a: str = "";
-    has b: str = "";
-
-    class __specs__ {
-        has excluded: str = "*", auth: bool = False;
-    }
-}
-
-walker post_partial_excluded {
-    has a: str;
-    has b: str = "";
-
-    class __specs__ {
-        has excluded: str = "b";
-    }
-}
-
-walker combination1 {
-    has a: str;
-    has b: str;
-    has c: str;
-    has d: str = "";
-
-    class __specs__ {
-        has methods: list = ["post", "get"], as_query: list = ["a", "b"], excluded: str = "d";
-    }
-}
-
-
-walker combination2 {
-    has a: str;
-    has b: str;
-    has c: str;
-    has d: str = "";
-    has e: str = "";
-
-    class __specs__ {
-        has path: str = "/{a}",
-        methods: list = ["post", "get", "put", "patch", "delete", "head", "trace", "options"],
-        as_query: list = ["b"],
-        excluded: list = ["d", "e"];
-    }
-}
-
-walker post_with_file {
-    has single: UploadFile;
-    has multiple: list[UploadFile];
-    has singleOptional: UploadFile | None = None;
-
-
-    can enter with `root entry {
-        print(self.single);
-        print(self.multiple);
-        print(self.singleOptional);
-
-        multiple = [];
-        for file in self.multiple {
-            multiple.append({
-                "name": file.filename,
-                "content_type": file.content_type,
-                "size": file.size,
-            });
-        }
-
-        single = {
-            "single": {
-                "name": self.single.filename,
-                "content_type": self.single.content_type,
-                "size": self.single.size,
-            }
-        };
-
-        report {
-            "single": single,
-            "multiple": multiple,
-            "singleOptional": self.singleOptional
-        };
-    }
-
-    class __specs__ {}
-}
-
-walker post_with_body_and_file {
-    has val: int;
-    has single: UploadFile;
-    has multiple: list[UploadFile];
-    has optional_val: int = 0;
-
-    can enter with `root entry {
-        print(self.val);
-        print(self.optional_val);
-        print(self.single);
-        print(self.multiple);
-    }
-
-    class __specs__ {
-        has auth: bool = False;
-    }
-}
-
-walker custom_status_code {
-    has status: int;
-
-    can enter with `root entry {
-        Jac.get_context().status = self.status;
-    }
-}
-
-walker different_return {
-
-    can enter1 with `root entry {
-    }
-
-    can enter2 with A entry -> int {
-    }
-
-    can enter3 with B entry -> str {
-    }
-
-    can enter4 with C entry -> bool {
-    }
-
-    can enter5 with Nested entry -> Parent {
-    }
-
-    can enter6 with `root entry -> list | dict {
-    }
-
-    class __specs__ {
-        has auth: bool = False;
-    }
-}
\ No newline at end of file
diff --git a/jac-cloud/jac_cloud/tests/test.json b/jac-cloud/jac_cloud/tests/test.json
deleted file mode 100644
index e9bdb8309b..0000000000
--- a/jac-cloud/jac_cloud/tests/test.json
+++ /dev/null
@@ -1,3 +0,0 @@
-{
-    "testing": 1
-}
\ No newline at end of file
diff --git a/jac-cloud/jac_cloud/tests/test_simple_graph.py b/jac-cloud/jac_cloud/tests/test_simple_graph.py
index 5cc1b82395..91ac9111f8 100644
--- a/jac-cloud/jac_cloud/tests/test_simple_graph.py
+++ b/jac-cloud/jac_cloud/tests/test_simple_graph.py
@@ -1,82 +1,30 @@
 """JacLang Jaseci Unit Test."""
 
-from contextlib import suppress
-from os import getenv
-from typing import Literal, overload
-from unittest.async_case import IsolatedAsyncioTestCase
-
 from httpx import get, post
 
 from yaml import safe_load
 
+from .test_utils import JacCloudTest
 from ..jaseci.datasources import Collection
 
 
-class SimpleGraphTest(IsolatedAsyncioTestCase):
+class SimpleGraphTest(JacCloudTest):
     """JacLang Jaseci Feature Tests."""
 
-    async def asyncSetUp(self) -> None:
-        """Reset DB and wait for server."""
-        self.host = "http://0.0.0.0:8000"
+    def setUp(self) -> None:
+        """Override setUp."""
+        self.run_server("jac_cloud/tests/simple_graph.jac")
+
         Collection.__client__ = None
         Collection.__database__ = None
         self.client = Collection.get_client()
         self.q_node = Collection.get_collection("node")
         self.q_edge = Collection.get_collection("edge")
-        self.users: list[dict] = []
-        self.database = getenv("DATABASE_NAME", "jaseci")
-        count = 0
-        while True:
-            if count > 5:
-                self.check_server()
-                break
-            else:
-                with suppress(Exception):
-                    self.check_server()
-                    break
-            count += 1
-
-    async def asyncTearDown(self) -> None:
-        """Clean up DB."""
-        self.client.drop_database(self.database)
-
-    @overload
-    def post_api(self, api: str, json: dict | None = None, user: int = 0) -> dict:
-        pass
-
-    @overload
-    def post_api(
-        self,
-        api: str,
-        json: dict | None = None,
-        user: int = 0,
-        expect_error: Literal[True] = True,
-    ) -> int:
-        pass
-
-    def post_api(
-        self,
-        api: str,
-        json: dict | None = None,
-        user: int = 0,
-        expect_error: bool = False,
-    ) -> dict | int:
-        """Call walker post API."""
-        res = post(
-            f"{self.host}/walker/{api}", json=json, headers=self.users[user]["headers"]
-        )
-
-        if not expect_error:
-            res.raise_for_status()
-            return res.json()
-        else:
-            return res.status_code
 
-    def check_server(self) -> None:
-        """Retrieve OpenAPI Specs JSON."""
-        res = get(f"{self.host}/healthz")
-        res.raise_for_status()
-        self.assertEqual(200, res.status_code)
+    def tearDown(self) -> None:
+        """Override tearDown."""
+        self.client.drop_database(self.database)
+        self.stop_server()
 
     def trigger_openapi_specs_test(self) -> None:
         """Test OpenAPI Specs."""
@@ -612,19 +560,19 @@ def trigger_upload_file(self) -> None:
                             "single": {
                                 "name": "simple_graph.jac",
                                 "content_type": "application/octet-stream",
-                                "size": 6992,
+                                "size": 15146,
                             }
                         },
                         "multiple": [
                             {
                                 "name": "simple_graph.jac",
                                 "content_type": "application/octet-stream",
-                                "size": 6992,
+                                "size": 15146,
                             },
                             {
                                 "name": "simple_graph.jac",
                                 "content_type": "application/octet-stream",
-                                "size": 6992,
+                                "size": 15146,
                             },
                         ],
                         "singleOptional": None,
@@ -633,12 +581,52 @@ def trigger_upload_file(self) -> None:
                 data["reports"],
             )
 
-    async def test_all_features(self) -> None:
+    def trigger_reset_graph(self) -> None:
+        """Test custom status code."""
+        res = self.post_api("populate_graph", user=2)
+        self.assertEqual(200, res["status"])
+        self.assertEqual([None] * 31, res["returns"])
+
+        res = self.post_api("traverse_populated_graph", user=2)
+        self.assertEqual(200, res["status"])
+        self.assertEqual([None] * 63, res["returns"])
+        reports = res["reports"]
+
+        root = reports.pop(0)
+        self.assertTrue(root["id"].startswith("n::"))
+        self.assertEqual({}, root["context"])
+
+        cur = 0
+        max = 2
+        for node in ["D", "E", "F", "G", "H"]:
+            for idx in range(cur, cur + max):
+                self.assertTrue(reports[idx]["id"].startswith(f"n:{node}:"))
+                self.assertEqual({"id": idx % 2}, reports[idx]["context"])
+                cur += 1
+            max = max * 2
+
+        res = self.post_api("check_populated_graph", user=2)
+        self.assertEqual(200, res["status"])
+        self.assertEqual([None], res["returns"])
+        self.assertEqual([125], res["reports"])
+
+        res = self.post_api("purge_populated_graph", user=2)
+        self.assertEqual(200, res["status"])
+        self.assertEqual([None], res["returns"])
+        self.assertEqual([124], res["reports"])
+
+        res = self.post_api("check_populated_graph", user=2)
+        self.assertEqual(200, res["status"])
+        self.assertEqual([None], res["returns"])
+        self.assertEqual([1], res["reports"])
+
+    def test_all_features(self) -> None:
         """Test Full Features."""
         self.trigger_openapi_specs_test()
 
         self.trigger_create_user_test()
         self.trigger_create_user_test(suffix="2")
+        self.trigger_create_user_test(suffix="3")
 
         self.trigger_create_graph_test()
         self.trigger_traverse_graph_test()
@@ -722,3 +710,9 @@ async def test_all_features(self) -> None:
         ###################################################
 
         self.trigger_upload_file()
+
+        ###################################################
+        #                   TEST PURGER                   #
+        ###################################################
+
+        self.trigger_reset_graph()
diff --git a/jac-cloud/jac_cloud/tests/test_simple_graph_mini.py b/jac-cloud/jac_cloud/tests/test_simple_graph_mini.py
deleted file mode 100644
index 9c24a23416..0000000000
--- a/jac-cloud/jac_cloud/tests/test_simple_graph_mini.py
+++ /dev/null
@@ -1,464 +0,0 @@
-"""JacLang Jaseci Unit Test."""
-
-from contextlib import suppress
-from os import getenv, path
-from shelve import open as shelf
-from typing import Literal, overload
-from unittest.async_case import IsolatedAsyncioTestCase
-
-from httpx import get, post
-
-from jaclang import jac_import
-from jaclang.runtimelib.context import ExecutionContext
-
-from yaml import safe_load
-
-
-class SimpleGraphTest(IsolatedAsyncioTestCase):
-    """JacLang Jaseci Feature Tests."""
-
-    def __init__(self, methodName: str = "runTest") -> None:  # noqa: N803
-        """Overide Init."""
-        super().__init__(methodName)
-
-        (base, ignored) = path.split(__file__)
-        base = base if base else "./"
-
-        jac_import(
-            target="simple_graph_mini",
-            base_path=base,
-            cachable=True,
-            override_name="__main__",
-        )
-
-    async def asyncSetUp(self) -> None:
-        """Reset DB and wait for server."""
-        self.host = "http://0.0.0.0:8001"
-        self.database = getenv("DATABASE", "database")
-        count = 0
-        while True:
-            if count > 5:
-                self.check_server()
-                break
-            else:
-                with suppress(Exception):
-                    self.check_server()
-                    break
-            count += 1
-
-    async def asyncTearDown(self) -> None:
-        """Clean up DB."""
-        self.clear_db()
-
-    def clear_db(self) -> None:
-        """Clean DB."""
-        with shelf(self.database) as sh:
-            sh.clear()
-            sh.sync()
-
-    @overload
-    def post_api(self, api: str, json: dict | None = None) -> dict:
-        pass
-
-    @overload
-    def post_api(
-        self,
-        api: str,
-        json: dict | None = None,
-        expect_error: Literal[True] = True,
-    ) -> int:
-        pass
-
-    def post_api(
-        self,
-        api: str,
-        json: dict | None = None,
-        expect_error: bool = False,
-    ) -> dict | int:
-        """Call walker post API."""
-        res = post(f"{self.host}/walker/{api}", json=json)
-
-        if not expect_error:
-            res.raise_for_status()
-            return res.json()
-        else:
-            return res.status_code
-
-    def check_server(self) -> None:
-        """Retrieve OpenAPI Specs JSON."""
-        res = get(f"{self.host}/healthz")
-        res.raise_for_status()
-        self.assertEqual(200, res.status_code)
-
-    def trigger_openapi_specs_test(self) -> None:
-        """Test OpenAPI Specs."""
-        res = get(f"{self.host}/openapi.yaml", timeout=1)
-        res.raise_for_status()
-
-        with open("jac_cloud/tests/openapi_specs_mini.yaml") as file:
-            self.assertEqual(safe_load(file), safe_load(res.text))
-
-    def trigger_create_graph_test(self) -> None:
-        """Test Graph Creation."""
-        res = self.post_api("create_graph")
-
-        self.assertEqual(200, res["status"])
-        self.assertEqual(4, len(res["reports"]))
-
-        root_node = res["reports"].pop(0)
-        self.assertEqual("00000000000000000000000000000000", root_node["id"])
-        self.assertEqual({}, root_node["context"])
-
-        for idx, report in enumerate(res["reports"]):
-            self.assertEqual({"val": idx}, report["context"])
-
-    def trigger_traverse_graph_test(self) -> None:
-        """Test Graph Traversion."""
-        res = self.post_api("traverse_graph")
-
-        self.assertEqual(200, res["status"])
-        self.assertEqual(4, len(res["reports"]))
-
-        root_node = res["reports"].pop(0)
-        self.assertEqual("00000000000000000000000000000000", root_node["id"])
-        self.assertEqual({}, root_node["context"])
-
-        for idx, report in enumerate(res["reports"]):
-            self.assertEqual({"val": idx}, report["context"])
-
-            res = self.post_api(f"traverse_graph/{report["id"]}")
-            self.assertEqual(200, res["status"])
-            for _idx, report in enumerate(res["reports"]):
-                self.assertEqual({"val": idx + _idx}, report["context"])
-
-    def trigger_detach_node_test(self) -> None:
-        """Test detach node."""
-        res = self.post_api("detach_node")
-
-        self.assertEqual(200, res["status"])
-        self.assertEqual([True], res["reports"])
-
-        res = self.post_api("traverse_graph")
-        self.assertEqual(200, res["status"])
-        self.assertEqual(3, len(res["reports"]))
-
-        root_node = res["reports"].pop(0)
-        self.assertEqual("00000000000000000000000000000000", root_node["id"])
-        self.assertEqual({}, root_node["context"])
-
-        for idx, report in enumerate(res["reports"]):
-            self.assertEqual({"val": idx}, report["context"])
-
-            res = self.post_api(f"traverse_graph/{report["id"]}")
-            self.assertEqual(200, res["status"])
-            for _idx, report in enumerate(res["reports"]):
-                self.assertEqual({"val": idx + _idx}, report["context"])
-
-    def trigger_update_graph_test(self) -> None:
-        """Test update graph."""
-        res = self.post_api("update_graph")
-
-        self.assertEqual(200, res["status"])
-        self.assertEqual(3, len(res["reports"]))
-
-        root_node = res["reports"].pop(0)
-        self.assertEqual("00000000000000000000000000000000", root_node["id"])
-        self.assertEqual({}, root_node["context"])
-
-        for idx, report in enumerate(res["reports"]):
-            self.assertEqual({"val": idx + 1}, report["context"])
-
-        res = self.post_api("traverse_graph")
-
-        self.assertEqual(200, res["status"])
-        self.assertEqual(3, len(res["reports"]))
-
-        root_node = res["reports"].pop(0)
-        self.assertEqual("00000000000000000000000000000000", root_node["id"])
-        self.assertEqual({}, root_node["context"])
-
-        for idx, report in enumerate(res["reports"]):
-            self.assertEqual({"val": idx + 1}, report["context"])
-
-            res = self.post_api(f"traverse_graph/{report["id"]}")
-            self.assertEqual(200, res["status"])
-            for _idx, report in enumerate(res["reports"]):
-                self.assertEqual({"val": idx + _idx + 1}, report["context"])
-
-    def trigger_create_nested_node_test(self, manual: bool = False) -> None:
-        """Test create nested node."""
-        res = self.post_api("create_nested_node")
-
-        self.assertEqual(200, res["status"])
-        self.assertEqual(
-            {
-                "val": 0,
-                "arr": [],
-                "json": {},
-                "parent": {
-                    "val": 1,
-                    "arr": [1],
-                    "json": {"a": 1},
-                    "child": {
-                        "val": 2,
-                        "arr": [1, 2],
-                        "json": {"a": 1, "b": 2},
-                        "enum_field": "c",
-                    },
-                    "enum_field": "b",
-                },
-                "enum_field": "a",
-            },
-            res["reports"][0]["context"],
-        )
-
-    def trigger_update_nested_node_test(self) -> None:
-        """Test update nested node."""
-        for walker in ["update_nested_node", "visit_nested_node"]:
-            res = self.post_api(walker)
-            self.assertEqual(200, res["status"])
-            self.assertEqual(
-                {
-                    "val": 1,
-                    "arr": [1],
-                    "json": {"a": 1},
-                    "parent": {
-                        "val": 2,
-                        "arr": [1, 2],
-                        "json": {"a": 1, "b": 2},
-                        "child": {
-                            "val": 3,
-                            "arr": [1, 2, 3],
-                            "json": {"a": 1, "b": 2, "c": 3},
-                            "enum_field": "a",
-                        },
-                        "enum_field": "c",
-                    },
-                    "enum_field": "b",
-                },
-                res["reports"][0]["context"],
-            )
-
-    def trigger_detach_nested_node_test(self, manual: bool = False) -> None:
-        """Test detach nested node."""
-        res = self.post_api("detach_nested_node")
-        self.assertEqual(200, res["status"])
-        self.assertEqual([True], res["reports"])
-
-        res = self.post_api("visit_nested_node")
-        self.assertEqual(200, res["status"])
-        self.assertEqual([[]], res["reports"])
-
-    def trigger_delete_nested_node_test(self, manual: bool = False) -> None:
-        """Test create nested node."""
-        res = self.post_api("delete_nested_node")
-        self.assertEqual(200, res["status"])
-        self.assertEqual([[]], res["reports"])
-
-        res = self.post_api("visit_nested_node")
-        self.assertEqual(200, res["status"])
-        self.assertEqual([[]], res["reports"])
-
-    def trigger_delete_nested_edge_test(self, manual: bool = False) -> None:
-        """Test create nested node."""
-        res = self.post_api("delete_nested_edge")
-        self.assertEqual(200, res["status"])
-        self.assertEqual([[]], res["reports"])
-
-        res = self.post_api("visit_nested_node")
-        self.assertEqual(200, res["status"])
-        self.assertEqual([[]], res["reports"])
-
-    def nested_count_should_be(self, node: int, edge: int) -> None:
-        """Test nested node count."""
-        jctx = ExecutionContext.create(session=self.database)
-
-        node_count = 0
-        edge_count = 0
-
-        for val in jctx.mem.__shelf__.values():
-            if val.architype.__class__.__name__ == "Nested":
-                node_count += 1
-            elif (
-                (source := getattr(val, "source", None))
-                and (target := getattr(val, "target", None))
-                and (
-                    source.architype.__class__.__name__ == "Nested"
-                    or target.architype.__class__.__name__ == "Nested"
-                )
-            ):
-                edge_count += 1
-
-        self.assertEqual(node, node_count)
-        self.assertEqual(edge, edge_count)
-
-        jctx.close()
-
-    def trigger_custom_status_code(self) -> None:
-        """Test custom status code."""
-        for acceptable_code in [200, 201, 202, 203, 205, 206, 207, 208, 226]:
-            res = self.post_api("custom_status_code", {"status": acceptable_code})
-            self.assertEqual(acceptable_code, res["status"])
-            self.assertEqual([], res["reports"])
-
-        for error_code in [
-            400,
-            401,
-            402,
-            403,
-            404,
-            405,
-            406,
-            407,
-            408,
-            409,
-            410,
-            411,
-            412,
-            413,
-            414,
-            415,
-            416,
-            417,
-            418,
-            421,
-            422,
-            423,
-            424,
-            425,
-            426,
-            428,
-            429,
-            431,
-            451,
-            500,
-            501,
-            502,
-            503,
-            504,
-            505,
-            506,
-            507,
-            508,
-            510,
-            511,
-        ]:
-            self.assertEqual(
-                error_code,
-                self.post_api(
-                    "custom_status_code", {"status": error_code}, expect_error=True
-                ),
-            )
-
-        for invalid_code in [
-            100,
-            101,
-            102,
-            103,
-            204,
-            300,
-            301,
-            302,
-            303,
-            304,
-            305,
-            306,
-            307,
-            308,
-        ]:
-            self.assertRaises(
-                Exception, self.post_api, "custom_status_code", {"status": invalid_code}
-            )
-
-    def trigger_upload_file(self) -> None:
-        """Test upload file."""
-        with open("jac_cloud/tests/simple_graph.jac", mode="br") as s:
-            files = [
-                ("single", ("simple_graph.jac", s)),
-                ("multiple", ("simple_graph.jac", s)),
-                ("multiple", ("simple_graph.jac", s)),
-            ]
-            res = post(f"{self.host}/walker/post_with_file", files=files)
-            res.raise_for_status()
-            data: dict = res.json()
-
-            self.assertEqual(200, data["status"])
-            self.assertEqual(
-                [
-                    {
-                        "single": {
-                            "single": {
-                                "name": "simple_graph.jac",
-                                "content_type": "application/octet-stream",
-                                "size": 6992,
-                            }
-                        },
-                        "multiple": [
-                            {
-                                "name": "simple_graph.jac",
-                                "content_type": "application/octet-stream",
-                                "size": 6992,
-                            },
-                            {
-                                "name": "simple_graph.jac",
-                                "content_type": "application/octet-stream",
-                                "size": 6992,
-                            },
-                        ],
-                        "singleOptional": None,
-                    }
-                ],
-                data["reports"],
-            )
-
-    async def test_all_features(self) -> None:
-        """Test Full Features."""
-        self.trigger_openapi_specs_test()
-
-        self.trigger_create_graph_test()
-        self.trigger_traverse_graph_test()
-        self.trigger_detach_node_test()
-        self.trigger_update_graph_test()
-
-        ###################################################
-        #                   VIA DETACH                    #
-        ###################################################
-
-        self.clear_db()
-
-        self.nested_count_should_be(node=0, edge=0)
-
-        self.trigger_create_nested_node_test()
-        self.nested_count_should_be(node=1, edge=1)
-
-        self.trigger_update_nested_node_test()
-        self.trigger_detach_nested_node_test()
-        self.nested_count_should_be(node=0, edge=0)
-
-        ###################################################
-        #                   VIA DESTROY                   #
-        ###################################################
-
-        self.trigger_create_nested_node_test()
-        self.nested_count_should_be(node=1, edge=1)
-
-        self.trigger_delete_nested_node_test()
-        self.nested_count_should_be(node=0, edge=0)
-
-        self.trigger_create_nested_node_test()
-        self.nested_count_should_be(node=1, edge=1)
-
-        self.trigger_delete_nested_edge_test()
-        self.nested_count_should_be(node=0, edge=0)
-
-        ###################################################
-        #                  CUSTOM STATUS                  #
-        ###################################################
-
-        self.trigger_custom_status_code()
-
-        ###################################################
-        #                   FILE UPLOAD                   #
-        ###################################################
-
-        self.trigger_upload_file()
diff --git a/jac-cloud/jac_cloud/tests/test_utils.py b/jac-cloud/jac_cloud/tests/test_utils.py
new file mode 100644
index 0000000000..6f50ecff2f
--- /dev/null
+++ b/jac-cloud/jac_cloud/tests/test_utils.py
@@ -0,0 +1,114 @@
+"""Test utils."""
+
+from contextlib import suppress
+from os import environ, getenv
+from subprocess import Popen, run
+from typing import Literal, overload
+from unittest import TestCase
+
+from fakeredis import FakeRedis
+
+from httpx import get, post
+
+from pymongo import MongoClient
+
+from redis import Redis as RedisClient
+
+from ..jaseci.datasources import Collection, MontyClient, Redis
+
+
+class JacCloudTest(TestCase):
+    """Test Utils."""
+
+    def run_server(
+        self,
+        file: str,
+        port: int = 8000,
+        database: str = "jaseci",
+        envs: dict | None = None,
+        wait: int = 5,
+        mini: bool = False,
+    ) -> None:
+        """Run server."""
+        run(["fuser", "-k", f"{port}/tcp"])
+        run(["jac", "clean"])
+        run(["jac", "tool", "gen_parser"])
+
+        base_envs = environ.copy()
+        base_envs["DATABASE_NAME"] = database
+        base_envs.update(envs or {"DATABASE_NAME": database})
+
+        self.server = Popen(
+            ["jac", "serve", f"{file}", "--port", f"{port}"], env=base_envs
+        )
+
+        run(["sleep", f"{wait}"])
+
+        self.host = f"http://0.0.0.0:{port}"
+        self.database = database
+        self.users: list[dict] = []
+
+        self.root_id_prefix = "" if mini else "n::"
+
+        count = 0
+        while True:
+            if count > 5:
+                self.check_server()
+                break
+            else:
+                with suppress(Exception):
+                    self.check_server()
+                    break
+            count += 1
+
+    def stop_server(self) -> None:
+        """Stop server."""
+        self.server.kill()
+
+    def check_server(self) -> None:
+        """Retrieve OpenAPI Specs JSON."""
+        res = get(f"{self.host}/healthz")
+        res.raise_for_status()
+        self.assertEqual(200, res.status_code)
+
+        if getenv("DATABASE_HOST"):
+            self.assertIsInstance(Collection.get_client(), MongoClient)
+        else:
+            self.assertIsInstance(Collection.get_client(), MontyClient)
+
+        if getenv("REDIS_HOST"):
+            self.assertIsInstance(Redis.get_rd(), RedisClient)
+        else:
+            self.assertIsInstance(Redis.get_rd(), FakeRedis)
+
+    @overload
+    def post_api(self, api: str, json: dict | None = None, user: int = 0) -> dict:
+        pass
+
+    @overload
+    def post_api(
+        self,
+        api: str,
+        json: dict | None = None,
+        user: int = 0,
+        expect_error: Literal[True] = True,
+    ) -> int:
+        pass
+
+    def post_api(
+        self,
+        api: str,
+        json: dict | None = None,
+        user: int = 0,
+        expect_error: bool = False,
+    ) -> dict | int:
+        """Call walker post API."""
+        res = post(
+            f"{self.host}/walker/{api}", json=json, headers=self.users[user]["headers"]
+        )
+
+        if not expect_error:
+            res.raise_for_status()
+            return res.json()
+        else:
+            return res.status_code
diff --git a/jac-splice-orc/jac_splice_orc/examples/numpy_test.jac b/jac-splice-orc/jac_splice_orc/examples/numpy_test.jac
new file mode 100644
index 0000000000..35fe979aac
--- /dev/null
+++ b/jac-splice-orc/jac_splice_orc/examples/numpy_test.jac
@@ -0,0 +1,8 @@
+with entry{
+    import:py numpy;
+    arr = numpy.array([1, 2, 3, 4]);
+    print(arr);
+    result = numpy.sum(arr); 
+    print(result);
+    
+}   
\ No newline at end of file
diff --git a/jac-splice-orc/jac_splice_orc/examples/transformer_test.jac b/jac-splice-orc/jac_splice_orc/examples/transformer_test.jac
new file mode 100644
index 0000000000..2aa69b3b39
--- /dev/null
+++ b/jac-splice-orc/jac_splice_orc/examples/transformer_test.jac
@@ -0,0 +1,6 @@
+with entry{
+    import:py transformers;
+    pipe = transformers.pipeline("text-classification");
+    print(pipe("This is a sample Text classification test."));
+   
+}   
\ No newline at end of file
diff --git a/jac-splice-orc/jac_splice_orc/test/__init__.py b/jac-splice-orc/jac_splice_orc/test/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/jac-splice-orc/jac_splice_orc/test/test_pod_manager.py b/jac-splice-orc/jac_splice_orc/test/test_pod_manager.py
new file mode 100644
index 0000000000..3d8bb179c4
--- /dev/null
+++ b/jac-splice-orc/jac_splice_orc/test/test_pod_manager.py
@@ -0,0 +1,88 @@
+import pytest
+from fastapi.testclient import TestClient
+from unittest import mock
+
+# Mock gRPC imports to avoid ImportError in test environment
+with mock.patch.dict(
+    "sys.modules",
+    {
+        "grpc_local": mock.MagicMock(),
+        "grpc_local.module_service_pb2": mock.MagicMock(),
+        "grpc_local.module_service_pb2_grpc": mock.MagicMock(),
+    },
+):
+    from ..managers.pod_manager import app, PodManager
+
+client = TestClient(app)
+
+
+@pytest.fixture
+def mock_kubernetes_and_grpc():
+    with mock.patch(
+        "kubernetes.config.load_incluster_config"
+    ) as mock_load_incluster_config, mock.patch(
+        "kubernetes.client.CoreV1Api"
+    ) as mock_v1_api, mock.patch.object(
+        PodManager, "create_pod"
+    ) as mock_create_pod, mock.patch.object(
+        PodManager, "delete_pod"
+    ) as mock_delete_pod, mock.patch.object(
+        PodManager, "forward_to_pod"
+    ) as mock_forward_to_pod, mock.patch.object(
+        PodManager, "get_pod_service_ip"
+    ) as mock_get_pod_service_ip:
+
+        # Mock load_incluster_config to avoid loading in-cluster config during tests
+        mock_load_incluster_config.return_value = None
+
+        # Mock Kubernetes CoreV1Api methods
+        mock_v1_api.return_value = mock.Mock()
+
+        # Mock responses for Kubernetes actions
+        mock_create_pod.return_value = {
+            "message": "Pod numpy-pod and service numpy-service created."
+        }
+        mock_delete_pod.return_value = {
+            "message": "Pod numpy-pod and service numpy-service deleted."
+        }
+
+        # Mock get_pod_service_ip to avoid real Kubernetes API calls
+        mock_get_pod_service_ip.return_value = "127.0.0.1"  # Return a mock IP address
+
+        # Mock gRPC method call to return expected value
+        mock_forward_to_pod.return_value = "[1, 2, 3, 4]"
+
+        yield
+
+
+def test_create_pod(mock_kubernetes_and_grpc):
+    module_config = {
+        "numpy": {
+            "lib_mem_size_req": "100MB",
+            "dependency": ["math", "mkl"],
+            "lib_cpu_req": "500m",
+            "load_type": "remote",
+        }
+    }
+    response = client.post("/create_pod/numpy", json={"module_config": module_config})
+
+    assert response.status_code == 200
+    assert response.json() == {
+        "message": "Pod numpy-pod and service numpy-service created."
+    }
+
+
+def test_run_module(mock_kubernetes_and_grpc):
+    response = client.post(
+        "/run_module?module_name=numpy&method_name=array", json={"args": [1, 2, 3, 4]}
+    )
+    assert response.status_code == 200
+    assert response.json() == "[1, 2, 3, 4]"  # Expected output from gRPC mock
+
+
+def test_delete_pod(mock_kubernetes_and_grpc):
+    response = client.delete("/delete_pod/numpy")
+    assert response.status_code == 200
+    assert response.json() == {
+        "message": "Pod numpy-pod and service numpy-service deleted."
+    }
diff --git a/jac/jaclang/compiler/passes/main/tests/fixtures/uninitialized_hasvars.jac b/jac/jaclang/compiler/passes/main/tests/fixtures/uninitialized_hasvars.jac
new file mode 100644
index 0000000000..482462a6dd
--- /dev/null
+++ b/jac/jaclang/compiler/passes/main/tests/fixtures/uninitialized_hasvars.jac
@@ -0,0 +1,26 @@
+
+# 1. Test initialization order.
+obj Test1 {
+    has var1: int;
+    has var2: int = 42;
+    has var3: int; # <-- This should be syntax error.
+}
+
+
+# 2. Test if postinit is needed but not provided.
+obj Test2 {
+    has var1: str;
+    has var2: int by postinit;
+}
+
+# 3. Postinit should be considered as has default initialization.
+obj Test3 {
+    has var1: int;
+    has var2: int = 42;
+    has var3: int by postinit;  # <-- This is fine.
+    has var4: int;  # <-- This should be syntax error.
+
+    can postinit() {
+        self.var3 = 3;
+    }
+}
diff --git a/jac/jaclang/compiler/passes/main/tests/test_decl_def_match_pass.py b/jac/jaclang/compiler/passes/main/tests/test_decl_def_match_pass.py
index 17ef767235..d5e5fbe2fe 100644
--- a/jac/jaclang/compiler/passes/main/tests/test_decl_def_match_pass.py
+++ b/jac/jaclang/compiler/passes/main/tests/test_decl_def_match_pass.py
@@ -43,35 +43,6 @@ def test_parameter_count_mismatch(self) -> None:
         for exp in expected_stdout_values:
             self.assertIn(exp, errors_output)
 
-    def test_parameter_name_mismatch(self) -> None:
-        """Basic test for pass."""
-        state = jac_file_to_pass(
-            self.fixture_abs_path("defn_decl_mismatch.jac"), DeclImplMatchPass
-        )
-
-        expected_stdout_values = (
-            "Parameter name mismatch for ability (o)SomeObj.(c)bar.",
-            "   14 |",
-            "   15 | # Mis matching parameter name.",
-            "   16 | :obj:SomeObj:can:bar(param1: str, praam2:int) -> str {",
-            "      |                                   ^^^^^^",
-            '   17 |     return "bar";',
-            "   18 | }",
-            "From the declaration of bar.",
-            "    3 | obj SomeObj {",
-            "    4 |     can foo(param1: str, param2:int) -> str;",
-            "    5 |     can bar(param1: str, param2:int) -> str;",
-            "      |                          ^^^^^^",
-            "    6 | }",
-        )
-
-        errors_output = ""
-        for error in state.errors_had:
-            errors_output += error.pretty_print() + "\n"
-
-        for exp in expected_stdout_values:
-            self.assertIn(exp, errors_output)
-
     def test_ability_connected_to_decl(self) -> None:
         """Basic test for pass."""
         state = jac_file_to_pass(self.fixture_abs_path("base.jac"), DeclImplMatchPass)
@@ -105,3 +76,39 @@ def test_arch_ref_has_sym(self) -> None:
         )
         for i in state.ir.get_all_sub_nodes(ast.ArchRef):
             self.assertIsNotNone(i.sym)
+
+    def test_obj_hasvar_initialization(self) -> None:
+        """Basic test for pass."""
+        state = jac_file_to_pass(
+            self.fixture_abs_path("uninitialized_hasvars.jac"), DeclImplMatchPass
+        )
+        self.assertTrue(state.errors_had)
+
+        expected_stdout_values = (
+            "Non default attribute 'var3' follows default attribute",
+            "    4 |     has var1: int;",
+            "    5 |     has var2: int = 42;",
+            "    6 |     has var3: int; # <-- This should be syntax error.",
+            "      |         ^^^^",
+            "    7 | }",
+            'Missing "postinit" method required by un initialized attribute(s).',
+            "   11 | obj Test2 {",
+            "   12 |     has var1: str;",
+            "   13 |     has var2: int by postinit;",
+            "      |         ^^^^",
+            "   14 | }",
+            "Non default attribute 'var4' follows default attribute",
+            "   19 |     has var2: int = 42;",
+            "   20 |     has var3: int by postinit;  # <-- This is fine.",
+            "   21 |     has var4: int;  # <-- This should be syntax error.",
+            "      |         ^^^^",
+            "   22 |",
+            "   23 |     can postinit() {",
+        )
+
+        errors_output = ""
+        for error in state.errors_had:
+            errors_output += error.pretty_print() + "\n"
+
+        for exp in expected_stdout_values:
+            self.assertIn(exp, errors_output)
diff --git a/jac/jaclang/compiler/passes/main/tests/test_def_use_pass.py b/jac/jaclang/compiler/passes/main/tests/test_def_use_pass.py
index b037b35251..a2a6612978 100644
--- a/jac/jaclang/compiler/passes/main/tests/test_def_use_pass.py
+++ b/jac/jaclang/compiler/passes/main/tests/test_def_use_pass.py
@@ -19,7 +19,7 @@ def test_def_uses(self) -> None:
             target=DefUsePass,
         )
         uses = [i.uses for i in state.ir.sym_tab.kid[0].tab.values()]
+        self.assertEqual(len(uses[0]), 1)
         self.assertEqual(len(uses[1]), 1)
-        self.assertEqual(len(uses[2]), 1)
-        self.assertIn("output", [uses[1][0].sym_name, uses[2][0].sym_name])
-        self.assertIn("message", [uses[1][0].sym_name, uses[2][0].sym_name])
+        self.assertIn("output", [uses[0][0].sym_name, uses[1][0].sym_name])
+        self.assertIn("message", [uses[0][0].sym_name, uses[1][0].sym_name])
diff --git a/jac/jaclang/compiler/passes/main/tests/test_registry_pass.py b/jac/jaclang/compiler/passes/main/tests/test_registry_pass.py
index a292d93a68..d6fd1b2235 100644
--- a/jac/jaclang/compiler/passes/main/tests/test_registry_pass.py
+++ b/jac/jaclang/compiler/passes/main/tests/test_registry_pass.py
@@ -10,6 +10,7 @@
 class RegistryPassTests(TestCase):
     """Test pass module."""
 
+    # Need change
     def setUp(self) -> None:
         """Set up test."""
         return super().setUp()
@@ -18,7 +19,7 @@ def test_registry_pass(self) -> None:
         """Basic test for pass."""
         state = jac_file_to_pass(self.fixture_abs_path("registry.jac"), RegistryPass)
         self.assertFalse(state.errors_had)
-        self.assertTrue(
+        self.assertFalse(
             os.path.exists(
                 os.path.join(
                     os.path.dirname(self.fixture_abs_path("registry.jac")),
@@ -27,13 +28,4 @@ def test_registry_pass(self) -> None:
                 )
             )
         )
-        self.assertTrue(
-            os.path.exists(
-                os.path.join(
-                    os.path.dirname(self.fixture_abs_path("registry.jac")),
-                    "__jac_gen__",
-                    "fstrings.registry.pkl",
-                )
-            )
-        )
         self.assertIn("109", str(state.ir.to_dict()))
diff --git a/jac/jaclang/compiler/passes/tool/tests/fixtures/corelib.jac b/jac/jaclang/compiler/passes/tool/tests/fixtures/corelib.jac
index ea7e7552bd..c574cbf683 100644
--- a/jac/jaclang/compiler/passes/tool/tests/fixtures/corelib.jac
+++ b/jac/jaclang/compiler/passes/tool/tests/fixtures/corelib.jac
@@ -34,6 +34,8 @@ glob exec_ctx = ExecutionContext();
 
 obj Anchor :ArchitypeProtocol: {
     has ob: object,
+        ds_entry_funcs: list[DSFunc],
+        ds_exit_funcs: list[DSFunc],
         jid: UUID = :> uuid4,
         timestamp: datetime = :> datetime.now,
         persist: bool = False,
@@ -41,9 +43,7 @@ obj Anchor :ArchitypeProtocol: {
         rw_access: set = :> set,
         ro_access: set = :> set,
         owner_id: UUID = exec_ctx.master,
-        mem: Memory = exec_ctx.memory,
-        ds_entry_funcs: list[DSFunc],
-        ds_exit_funcs: list[DSFunc];
+        mem: Memory = exec_ctx.memory;
 
     static can on_entry(cls: type, triggers: list[type]);
     static can on_exit(cls: type, triggers: list[type]);
diff --git a/jac/jaclang/compiler/passes/tool/tests/fixtures/corelib_fmt.jac b/jac/jaclang/compiler/passes/tool/tests/fixtures/corelib_fmt.jac
index 28d295d45c..8d61d32e60 100644
--- a/jac/jaclang/compiler/passes/tool/tests/fixtures/corelib_fmt.jac
+++ b/jac/jaclang/compiler/passes/tool/tests/fixtures/corelib_fmt.jac
@@ -33,6 +33,8 @@ glob exec_ctx = ExecutionContext();
 
 obj Anchor :ArchitypeProtocol: {
     has ob: object,
+        ds_entry_funcs: list[DSFunc],
+        ds_exit_funcs: list[DSFunc],
         jid: UUID = :> uuid4,
         timestamp: datetime = :> datetime.now,
         persist: bool = False,
@@ -40,9 +42,7 @@ obj Anchor :ArchitypeProtocol: {
         rw_access: set = :> set,
         ro_access: set = :> set,
         owner_id: UUID = exec_ctx.master,
-        mem: Memory = exec_ctx.memory,
-        ds_entry_funcs: list[DSFunc],
-        ds_exit_funcs: list[DSFunc];
+        mem: Memory = exec_ctx.memory;
 
     static can on_entry(cls: type, triggers: list[type]);
     static can on_exit(cls: type, triggers: list[type]);
diff --git a/jac/jaclang/compiler/tests/test_importer.py b/jac/jaclang/compiler/tests/test_importer.py
index 135481918a..40fe79a9e7 100644
--- a/jac/jaclang/compiler/tests/test_importer.py
+++ b/jac/jaclang/compiler/tests/test_importer.py
@@ -15,7 +15,7 @@ class TestLoader(TestCase):
     def test_import_basic_python(self) -> None:
         """Test basic self loading."""
         JacMachine(self.fixture_abs_path(__file__)).attach_program(
-            JacProgram(mod_bundle=None, bytecode=None)
+            JacProgram(mod_bundle=None, bytecode=None, sem_ir=None)
         )
         (h,) = jac_import("fixtures.hello_world", base_path=__file__)
         self.assertEqual(h.hello(), "Hello World!")  # type: ignore
@@ -24,7 +24,7 @@ def test_import_basic_python(self) -> None:
     def test_modules_correct(self) -> None:
         """Test basic self loading."""
         JacMachine(self.fixture_abs_path(__file__)).attach_program(
-            JacProgram(mod_bundle=None, bytecode=None)
+            JacProgram(mod_bundle=None, bytecode=None, sem_ir=None)
         )
         jac_import("fixtures.hello_world", base_path=__file__)
         self.assertIn(
diff --git a/jac/jaclang/compiler/tests/test_parser.py b/jac/jaclang/compiler/tests/test_parser.py
index 0082d2adb8..f5d41e3235 100644
--- a/jac/jaclang/compiler/tests/test_parser.py
+++ b/jac/jaclang/compiler/tests/test_parser.py
@@ -1,6 +1,7 @@
 """Tests for Jac parser."""
 
 import inspect
+import os
 
 from jaclang.compiler import jac_lark as jl
 from jaclang.compiler.absyntree import JacSource
@@ -27,7 +28,12 @@ def micro_suite_test(self, filename: str) -> None:
         prse = JacParser(
             input_ir=JacSource(self.file_to_str(filename), mod_path=filename),
         )
-        self.assertFalse(prse.errors_had)
+        # A list of files where the errors are expected.
+        files_expected_errors = [
+            "uninitialized_hasvars.jac",
+        ]
+        if os.path.basename(filename) not in files_expected_errors:
+            self.assertFalse(prse.errors_had)
 
     def test_parser_fam(self) -> None:
         """Parse micro jac file."""
diff --git a/jac/jaclang/plugin/tests/fixtures/graph_purger.jac b/jac/jaclang/plugin/tests/fixtures/graph_purger.jac
new file mode 100644
index 0000000000..3044008aa4
--- /dev/null
+++ b/jac/jaclang/plugin/tests/fixtures/graph_purger.jac
@@ -0,0 +1,101 @@
+node A {
+    has id: int;
+}
+
+node B {
+    has id: int;
+}
+
+node C {
+    has id: int;
+}
+
+node D {
+    has id: int;
+}
+
+node E {
+    has id: int;
+}
+
+
+walker populate {
+    can setup1 with `root entry {
+        for i in range(2) {
+            here ++> A(id=i);
+        }
+        visit [-->];
+    }
+
+    can setup2 with A entry {
+        for i in range(2) {
+            here ++> B(id=i);
+        }
+        visit [-->];
+    }
+
+    can setup3 with B entry {
+        for i in range(2) {
+            here ++> C(id=i);
+        }
+        visit [-->];
+    }
+
+    can setup4 with C entry {
+        for i in range(2) {
+            here ++> D(id=i);
+        }
+        visit [-->];
+    }
+
+    can setup5 with D entry {
+        for i in range(2) {
+            here ++> E(id=i);
+        }
+        visit [-->];
+    }
+}
+
+walker traverse {
+    can enter1 with `root entry {
+        print(here);
+        visit [-->];
+    }
+
+    can enter2 with A entry {
+        print(here);
+        visit [-->];
+    }
+
+    can enter3 with B entry {
+        print(here);
+        visit [-->];
+    }
+
+    can enter4 with C entry {
+        print(here);
+        visit [-->];
+    }
+
+    can enter5 with D entry {
+        print(here);
+        visit [-->];
+    }
+
+    can enter6 with E entry {
+        print(here);
+        visit [-->];
+    }
+}
+
+walker purge {
+    can purge with `root entry {
+        print(Jac.reset_graph());
+    }
+}
+
+walker check {
+    can enter with `root entry {
+        print(len(Jac.get_context().mem.__shelf__.values()));
+    }
+}
\ No newline at end of file
diff --git a/jac/jaclang/plugin/tests/fixtures/other_root_access.jac b/jac/jaclang/plugin/tests/fixtures/other_root_access.jac
index 384587fe7f..21e60c5bc6 100644
--- a/jac/jaclang/plugin/tests/fixtures/other_root_access.jac
+++ b/jac/jaclang/plugin/tests/fixtures/other_root_access.jac
@@ -23,6 +23,15 @@ walker update_node {
     }
 }
 
+walker update_node_forced {
+    has val: int;
+
+    can enter2 with A entry {
+        Jac.elevate_root();
+        here.val = self.val;
+    }
+}
+
 walker create_node {
     has val: int;
 
diff --git a/jac/jaclang/plugin/tests/test_jaseci.py b/jac/jaclang/plugin/tests/test_jaseci.py
index af7e34bae1..cacc3ee2c6 100644
--- a/jac/jaclang/plugin/tests/test_jaseci.py
+++ b/jac/jaclang/plugin/tests/test_jaseci.py
@@ -269,6 +269,75 @@ def test_indirect_reference_node(self) -> None:
         )
         self._del_session(session)
 
+    def test_walker_purger(self) -> None:
+        """Test simple persistent object."""
+        session = self.fixture_abs_path("test_walker_purger.session")
+        self._output2buffer()
+        cli.enter(
+            filename=self.fixture_abs_path("graph_purger.jac"),
+            session=session,
+            entrypoint="populate",
+            args=[],
+        )
+        cli.enter(
+            filename=self.fixture_abs_path("graph_purger.jac"),
+            session=session,
+            entrypoint="traverse",
+            args=[],
+        )
+        cli.enter(
+            filename=self.fixture_abs_path("graph_purger.jac"),
+            session=session,
+            entrypoint="check",
+            args=[],
+        )
+        cli.enter(
+            filename=self.fixture_abs_path("graph_purger.jac"),
+            session=session,
+            entrypoint="purge",
+            args=[],
+        )
+        output = self.capturedOutput.getvalue().strip()
+        self.assertEqual(
+            output,
+            (
+                "Root()\n"
+                "A(id=0)\nA(id=1)\n"
+                "B(id=0)\nB(id=1)\nB(id=0)\nB(id=1)\n"
+                "C(id=0)\nC(id=1)\nC(id=0)\nC(id=1)\nC(id=0)\nC(id=1)\nC(id=0)\nC(id=1)\n"
+                "D(id=0)\nD(id=1)\nD(id=0)\nD(id=1)\nD(id=0)\nD(id=1)\nD(id=0)\nD(id=1)\n"
+                "D(id=0)\nD(id=1)\nD(id=0)\nD(id=1)\nD(id=0)\nD(id=1)\nD(id=0)\nD(id=1)\n"
+                "E(id=0)\nE(id=1)\nE(id=0)\nE(id=1)\nE(id=0)\nE(id=1)\nE(id=0)\nE(id=1)\n"
+                "E(id=0)\nE(id=1)\nE(id=0)\nE(id=1)\nE(id=0)\nE(id=1)\nE(id=0)\nE(id=1)\n"
+                "E(id=0)\nE(id=1)\nE(id=0)\nE(id=1)\nE(id=0)\nE(id=1)\nE(id=0)\nE(id=1)\n"
+                "E(id=0)\nE(id=1)\nE(id=0)\nE(id=1)\nE(id=0)\nE(id=1)\nE(id=0)\nE(id=1)\n"
+                "125\n124"
+            ),
+        )
+        self._output2buffer()
+        cli.enter(
+            filename=self.fixture_abs_path("graph_purger.jac"),
+            session=session,
+            entrypoint="traverse",
+            args=[],
+        )
+        cli.enter(
+            filename=self.fixture_abs_path("graph_purger.jac"),
+            session=session,
+            entrypoint="check",
+            args=[],
+        )
+        cli.enter(
+            filename=self.fixture_abs_path("graph_purger.jac"),
+            session=session,
+            entrypoint="purge",
+            args=[],
+        )
+        output = self.capturedOutput.getvalue().strip()
+        self.assertEqual(output, "Root()\n1\n0")
+
+        self._del_session(session)
+
     def trigger_access_validation_test(
         self, give_access_to_full_graph: bool, via_all: bool = False
     ) -> None:
@@ -340,6 +409,55 @@ def trigger_access_validation_test(
         self.assertEqual(archs[0], "A(val=2)")
         self.assertEqual(archs[1], "A(val=1)")
 
+        ##############################################
+        #        WITH READ ACCESS BUT ELEVATED       #
+        ##############################################
+
+        self._output2buffer()
+
+        cli.enter(
+            filename=self.fixture_abs_path("other_root_access.jac"),
+            entrypoint="update_node_forced",
+            args=[20],
+            session=session,
+            root=self.roots[0],
+            node=self.nodes[1],
+        )
+        cli.enter(
+            filename=self.fixture_abs_path("other_root_access.jac"),
+            entrypoint="update_node_forced",
+            args=[10],
+            session=session,
+            root=self.roots[1],
+            node=self.nodes[0],
+        )
+
+        cli.enter(
+            filename=self.fixture_abs_path("other_root_access.jac"),
+            entrypoint="check_node",
+            args=[],
+            session=session,
+            root=self.roots[0],
+            node=self.nodes[1],
+        )
+        cli.enter(
+            filename=self.fixture_abs_path("other_root_access.jac"),
+            entrypoint="check_node",
+            args=[],
+            session=session,
+            root=self.roots[1],
+            node=self.nodes[0],
+        )
+        archs = self.capturedOutput.getvalue().strip().split("\n")
+        self.assertTrue(len(archs) == 2)
+
+        # ---------- UPDATE SHOULD HAPPEN ---------- #
+
+        self.assertEqual(archs[0], "A(val=20)")
+        self.assertEqual(archs[1], "A(val=10)")
+
+        # ---------- DISALLOW READ ACCESS ---------- #
+
         self._output2buffer()
         cli.enter(
             filename=self.fixture_abs_path("other_root_access.jac"),
@@ -400,7 +518,7 @@ def trigger_access_validation_test(
         cli.enter(
             filename=self.fixture_abs_path("other_root_access.jac"),
             entrypoint="update_node",
-            args=[20],
+            args=[200],
             root=self.roots[0],
             node=self.nodes[1],
             session=session,
@@ -408,7 +526,7 @@ def trigger_access_validation_test(
         cli.enter(
             filename=self.fixture_abs_path("other_root_access.jac"),
             entrypoint="update_node",
-            args=[10],
+            args=[100],
             session=session,
             root=self.roots[1],
             node=self.nodes[0],
@@ -433,10 +551,12 @@ def trigger_access_validation_test(
         archs = self.capturedOutput.getvalue().strip().split("\n")
         self.assertTrue(len(archs) == 2)
 
-        # --------- UPDATE SHOULD HAPPEN -------- #
+        # ---------- UPDATE SHOULD HAPPEN ---------- #
 
-        self.assertEqual(archs[0], "A(val=20)")
-        self.assertEqual(archs[1], "A(val=10)")
+        self.assertEqual(archs[0], "A(val=200)")
+        self.assertEqual(archs[1], "A(val=100)")
+
+        # ---------- DISALLOW WRITE ACCESS --------- #
 
         self._output2buffer()
         cli.enter(
@@ -474,7 +594,7 @@ def trigger_access_validation_test(
         )
         self.assertFalse(self.capturedOutput.getvalue().strip())
 
-        # --------- ROOTS RESET OWN NODE -------- #
+        # ---------- ROOTS RESET OWN NODE ---------- #
 
         cli.enter(
             filename=self.fixture_abs_path("other_root_access.jac"),
diff --git a/jac/jaclang/tests/fixtures/architype_def_bug.jac b/jac/jaclang/tests/fixtures/architype_def_bug.jac
new file mode 100644
index 0000000000..37a3609a01
--- /dev/null
+++ b/jac/jaclang/tests/fixtures/architype_def_bug.jac
@@ -0,0 +1,17 @@
+# fix test type 2
+walker MyWalker {
+    can travel with `root | MyNode entry {
+        print("MyWalker");
+    }
+}
+
+node MyNode {
+    can work with MyWalker entry {
+        print("MyNode");
+    }
+}
+
+with entry {
+    Node_1 = MyNode();
+    Node_1 spawn MyWalker();
+}
diff --git a/jac/jaclang/tests/fixtures/decl_defn_param_name.jac b/jac/jaclang/tests/fixtures/decl_defn_param_name.jac
new file mode 100644
index 0000000000..611a1ea716
--- /dev/null
+++ b/jac/jaclang/tests/fixtures/decl_defn_param_name.jac
@@ -0,0 +1,19 @@
+
+obj SomeClass {
+    can method1(some_long_paramenter_name: int) -> None;
+    can method2(param1:int, param2:str) -> None;
+}
+
+:o:SomeClass:c:method1(short_name:int) -> None {
+  print("short_name =", short_name);
+}
+
+:o:SomeClass:c:method2(p1:int, p2: str) -> None {
+  print("p1 =", p1, ", p2 =", p2);
+}
+
+with entry {
+  sc = SomeClass();
+  sc.method1(42);
+  sc.method2(64, "foobar");
+}
\ No newline at end of file
diff --git a/jac/jaclang/tests/fixtures/glob_multivar_statement.jac b/jac/jaclang/tests/fixtures/glob_multivar_statement.jac
new file mode 100644
index 0000000000..0c8fb7d445
--- /dev/null
+++ b/jac/jaclang/tests/fixtures/glob_multivar_statement.jac
@@ -0,0 +1,15 @@
+glob a: str, b: str;
+glob c: str;
+
+can do() {
+    :g: a, b, c ;
+
+    (a, b, c) = ("Welcome", "to", "Jaseci!");
+}
+
+with entry {
+    (a, b, c) = ("Hello", "World", "!");
+    print(a, b, c);
+    do();
+    print(a, b, c);
+}
diff --git a/jac/jaclang/tests/fixtures/multi_dim_array_split.jac b/jac/jaclang/tests/fixtures/multi_dim_array_split.jac
new file mode 100644
index 0000000000..20841aee7d
--- /dev/null
+++ b/jac/jaclang/tests/fixtures/multi_dim_array_split.jac
@@ -0,0 +1,19 @@
+import:py numpy as np;
+
+with entry {
+    arr = np.array(
+        [[1,   2,  3,  4,  5],
+         [6,   7,  8,  9, 10],
+         [11, 12, 13, 14, 15],
+         [16, 17, 18, 19, 20],
+         [21, 22, 23, 24, 25]]
+    );
+
+    print('Original Array:');
+    print(arr);
+
+    print();
+
+    print('Sliced Array:');
+    print(arr[1:3, 1::2]);
+}
diff --git a/jac/jaclang/tests/fixtures/registry.jac b/jac/jaclang/tests/fixtures/registry.jac
index 00e4d5ba5d..d612572587 100644
--- a/jac/jaclang/tests/fixtures/registry.jac
+++ b/jac/jaclang/tests/fixtures/registry.jac
@@ -13,16 +13,16 @@ Person {
 
 enum 'Personality of the Person'
 Personality {
-   INTROVERT: 'Person who is shy and reticent' = 9,
-   EXTROVERT: 'Person who is outgoing and socially confident'
+    INTROVERT: 'Person who is shy and reticent' = 9,
+    EXTROVERT: 'Person who is outgoing and socially confident'
 }
 
-glob personality_examples: 'Personality Information of Famous People': dict[str, Personality|None] = {
+glob personality_examples: 'Personality Information of Famous People': dict[str, Personality | None] = {
     'Albert Einstein': Personality.INTROVERT,
     'Barack Obama': Personality.EXTROVERT
 };
 
-glob person_value : list[tuple[dict[str, Personality], int]] =(-90);
+glob person_value: list[tuple[dict[str, Personality], int]] = (-90);
 
 can 'GenAI ability'
 genai_ability(x: 'Something': str) -> 'Something Else': str by llm();
@@ -34,13 +34,25 @@ normal_ability(x: 'Something': str) -> 'Something Else': str {
 }
 
 can foo() {
-   person_value=22;
-   can bar() {
-       person_value=33;
-   }
+    person_value = 22;
+    can bar() {
+        person_value = 33;
+    }
 }
 with entry {
     einstein_age: int = 75;
     einstein_age += 1;
     einstein = Person('Albert Einstein', einstein_age);
 }
+
+import from jaclang.runtimelib.machine { JacMachine }
+
+with entry {
+    registry = JacMachine.get().jac_program.sem_ir;
+
+    print(len(registry.registry));
+    print(len(list(registry.registry.items())[0][1]));
+    print(list(registry.registry.items())[3][0].scope);
+    (_, sem_info) = registry.lookup(name="normal_ability");
+    print(len(sem_info.get_children(registry)));
+}
diff --git a/jac/jaclang/tests/test_cli.py b/jac/jaclang/tests/test_cli.py
index f65505cebf..cf9b1cd183 100644
--- a/jac/jaclang/tests/test_cli.py
+++ b/jac/jaclang/tests/test_cli.py
@@ -94,6 +94,24 @@ def test_jac_impl_err(self) -> None:
         path_to_file = self.fixture_abs_path("err.impl.jac")
         self.assertIn(f'"{path_to_file}", line 2', stdout_value)
 
+    def test_param_name_diff(self) -> None:
+        """Test when parameter name from definitinon and declaration are mismatched."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        sys.stderr = captured_output
+        with contextlib.suppress(Exception):
+            cli.run(self.fixture_abs_path("decl_defn_param_name.jac"))
+        sys.stdout = sys.__stdout__
+        sys.stderr = sys.__stderr__
+
+        expected_stdout_values = (
+            "short_name = 42",
+            "p1 = 64 , p2 = foobar",
+        )
+        output = captured_output.getvalue()
+        for exp in expected_stdout_values:
+            self.assertIn(exp, output)
+
     def test_jac_test_err(self) -> None:
         """Basic test for pass."""
         captured_output = io.StringIO()
@@ -404,3 +422,31 @@ def test_py_to_jac(self) -> None:
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertIn("can my_print(x: object) -> None", stdout_value)
+
+    def test_caching_issue(self) -> None:
+        """Test for Caching Issue."""
+        test_file = self.fixture_abs_path("test_caching_issue.jac")
+        test_cases = [(10, True), (11, False)]
+        for x, is_passed in test_cases:
+            with open(test_file, "w") as f:
+                f.write(
+                    f"""
+                test mytest{{
+                    check 10 == {x};
+                }}
+                """
+                )
+            process = subprocess.Popen(
+                ["jac", "test", test_file],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+            )
+            stdout, stderr = process.communicate()
+            if is_passed:
+                self.assertIn("Passed successfully.", stdout)
+                self.assertIn(".", stderr)
+            else:
+                self.assertNotIn("Passed successfully.", stdout)
+                self.assertIn("F", stderr)
+        os.remove(test_file)
diff --git a/jac/jaclang/tests/test_language.py b/jac/jaclang/tests/test_language.py
index 82fd28c429..92f3394cc1 100644
--- a/jac/jaclang/tests/test_language.py
+++ b/jac/jaclang/tests/test_language.py
@@ -2,7 +2,6 @@
 
 import io
 import os
-import pickle
 import sys
 import sysconfig
 
@@ -24,7 +23,7 @@ def setUp(self) -> None:
         """Set up test."""
         SUPER_ROOT_ANCHOR.edges.clear()
         JacMachine(self.fixture_abs_path("./")).attach_program(
-            JacProgram(mod_bundle=None, bytecode=None)
+            JacProgram(mod_bundle=None, bytecode=None, sem_ir=None)
         )
         return super().setUp()
 
@@ -104,6 +103,39 @@ def test_guess_game(self) -> None:
             "Too high!\nToo low!\nToo high!\nCongratulations! You guessed correctly.\n",
         )
 
+    def test_multi_dim_arr_slice(self) -> None:
+        """Parse micro jac file."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        cli.tool(
+            "ir",
+            [
+                "ast",
+                self.fixture_abs_path("multi_dim_array_split.jac"),
+            ],
+        )
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue()
+
+        expected_outputs = [
+            "+-- AtomTrailer - Type: numpy.ndarray[Any, numpy.dtype[Any]]",
+            "    +-- Name - arr - Type: numpy.ndarray[Any, numpy.dtype[Any]],  SymbolTable: None",
+            "    +-- IndexSlice - [IndexSlice] - Type: builtins.slice,  SymbolTable: None",
+            "        +-- Token - [,",
+            "        +-- Int - 1 - Type: Literal[1]?,  SymbolTable: None",
+            "        +-- Token - :,",
+            "        +-- Int - 3 - Type: Literal[3]?,  SymbolTable: None",
+            "        +-- Token - ,,",
+            "        +-- Int - 1 - Type: Literal[1]?,  SymbolTable: None",
+            "        +-- Token - :,",
+            "        +-- Token - :,",
+            "        +-- Int - 2 - Type: Literal[2]?,  SymbolTable: None",
+            "        +-- Token - ],",
+        ]
+
+        for expected in expected_outputs:
+            self.assertIn(expected, stdout_value)
+
     def test_chandra_bugs(self) -> None:
         """Parse micro jac file."""
         captured_output = io.StringIO()
@@ -475,19 +507,15 @@ def test_registry(self) -> None:
         stdout_value = captured_output.getvalue()
         self.assertNotIn("Error", stdout_value)
 
-        with open(
-            os.path.join(
-                self.fixture_abs_path("./"), "__jac_gen__", "registry.registry.pkl"
-            ),
-            "rb",
-        ) as f:
-            registry = pickle.load(f)
+        output_lines = stdout_value.strip().split("\n")
+        outputs = [
+            int(output_lines[i]) if i != 2 else output_lines[i] for i in range(4)
+        ]
 
-        self.assertEqual(len(registry.registry), 9)
-        self.assertEqual(len(list(registry.registry.items())[0][1]), 2)
-        self.assertEqual(list(registry.registry.items())[3][0].scope, "Person")
-        _, sem_info = registry.lookup(name="normal_ability")
-        self.assertEqual(len(sem_info.get_children(registry)), 2)
+        self.assertEqual(outputs[0], 9)
+        self.assertEqual(outputs[1], 2)
+        self.assertEqual(outputs[2], "Person")
+        self.assertEqual(outputs[3], 2)
 
     def test_enum_inside_arch(self) -> None:
         """Test Enum as member stmt."""
@@ -1184,3 +1212,23 @@ def test_visit_order(self) -> None:
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertEqual("[MyNode(Name='End'), MyNode(Name='Middle')]\n", stdout_value)
+
+    def test_global_multivar(self) -> None:
+        """Test supporting multiple global variable in a statement."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        jac_import("glob_multivar_statement", base_path=self.fixture_abs_path("./"))
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue().split("\n")
+        self.assertIn("Hello World !", stdout_value[0])
+        self.assertIn("Welcome to Jaseci!", stdout_value[1])
+
+    def test_architype_def(self) -> None:
+        """Test architype definition bug."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        jac_import("architype_def_bug", base_path=self.fixture_abs_path("./"))
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue().split("\n")
+        self.assertIn("MyNode", stdout_value[0])
+        self.assertIn("MyWalker", stdout_value[1])