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

Issue:
[LOGGER]: Initial Jac-Cloud logger handler



Discussion / hints:

Fix patch:
diff --git a/jac-cloud/.gitignore b/jac-cloud/.gitignore
index 269f954165..3e9601fd5b 100644
--- a/jac-cloud/.gitignore
+++ b/jac-cloud/.gitignore
@@ -51,3 +51,7 @@ out.txt
 # Mypy files #
 .mypy_cache*
 .jac_mypy_cache
+
+
+# Jac-Cloud #
+logs/
\ No newline at end of file
diff --git a/jac-cloud/README.md b/jac-cloud/README.md
index dec1f2cb9b..b389f977db 100644
--- a/jac-cloud/README.md
+++ b/jac-cloud/README.md
@@ -11,4 +11,5 @@ pre-commit install
 ```
 # **REFERENCES**
 ### [**jac-cloud**](./docs/Jaseci.md)
-### [**Environment Variables**](./docs/Environment-Variables.md)
\ No newline at end of file
+### [**Environment Variables**](./docs/Environment-Variables.md)
+### [**Logger**](./docs/Logger.md)
\ No newline at end of file
diff --git a/jac-cloud/docs/Environment-Variables.md b/jac-cloud/docs/Environment-Variables.md
index e926bfd908..a55d6ee308 100644
--- a/jac-cloud/docs/Environment-Variables.md
+++ b/jac-cloud/docs/Environment-Variables.md
@@ -25,6 +25,13 @@
 | RESET_CODE_TIMEOUT | Password reset code expiration in hours | 24 |
 | SENDGRID_HOST | Sendgrid host used for hyperlinking verification/reset code | http://localhost:8000 |
 | SENDGRID_API_KEY | Sendgrid api key | null    |
+| LOGGER_NAME   | Specified logger name | app   |
+| LOGGER_LEVEL  | Control log level     | debug |
+| LOGGER_FILE_PATH | Log directory and name | /tmp/jac_cloud_logs/jac-cloud.log |
+| LOGGER_ROLLOVER_INTERVAL | M = every minute, H = hourly, D = daily, W = weekly | D |
+| LOGGER_MAX_BACKUP | Maximum number of backup files before it will deletes old file. Non positive value will not have maximum | -1 |
+| LOGGER_ROLLOVER_MAX_FILE_SIZE | Maximum file size in bytes before it will rollover to new file | 10000000 |
+| LOGGER_USE_UTC | If logger will use UTC | false |
 
 # **SSO Supported Enviroment Variable**
 ## Supported Platform
diff --git a/jac-cloud/docs/Logger.md b/jac-cloud/docs/Logger.md
new file mode 100644
index 0000000000..10c65f798d
--- /dev/null
+++ b/jac-cloud/docs/Logger.md
@@ -0,0 +1,57 @@
+# Logging
+* jac-cloud server logs incoming requests and outgoing responses by default to log files stored in `/tmp/` directory
+* The log files are on a daily rotation. Meaning there will be a new log file created every day to prevent log files gets too large.
+* For production usage, we recommend connect your jac-cloud logs to an Elastic instance.
+# Quick Start: Integration with Elasitc
+* Assuming you have a running Elastic instance, you just need to use filebeat to ingest the log files into elastic.
+* We provide a template filebeat config file to get started at `scripts/filebeat-template.yaml`. If you want to adopt the default configuration, simply change the `hosts` and `api_key` field.
+  * Change the hosts field to point to your elastic instance. 
+
+> :warning: It seems that filebeat automatically append a 9200 port to the host URL if no port is specified. If your elastic instance is behind a load balancer and simply has a URL without a custom port, you will need to add either :80 or :443 to the hosts config. For example, `hosts: ["https://my_elastic_instance.me.com:443/]`
+
+* Then simply run `filebeat -e -c scripts/filebeat-template.yaml`.
+
+## More Details on Configuring and Starting Filebeat
+- [Download](https://www.elastic.co/downloads/beats/filebeat) and install filebeat.
+- setup yml based on your setup
+```yml
+filebeat.inputs:
+- type: log
+  enabled: true
+  paths:
+    - /tmp/jac_cloud_logs/*-jac-cloud-*.log
+    - /tmp/jac_cloud_logs/jac-cloud.log
+  json:
+    keys_under_root: true
+    overwrite_keys: true
+    add_error_key: true
+    expand_keys: true
+
+output.elasticsearch:
+  hosts: ["localhost:9200"]
+  protocol: https
+  api_key: "id:api_key"
+  index: "filebeat-testing"
+
+setup.template.name: "filebeat"
+setup.template.pattern: "filebeat-*"
+```
+- to run without restriction, run filebeat as root
+    - `sudo cp filebeat.yml /etc/filebeat/filebeat.yml`
+    - `sudo filebeat -e`
+- normal run
+    - `filebeat -e -c filebeat.yml`
+- for complete documentation
+    - https://www.elastic.co/guide/en/cloud/current/ec-getting-started-search-use-cases-python-logs.html
+    - https://www.elastic.co/guide/en/beats/filebeat/current/configuring-howto-filebeat.html
+
+## Additional Env Vars to customize logger
+| **NAME**  | **DESCRIPTION**   | **DEFAULT**   |
+|-----------|-------------------|---------------|
+| LOGGER_NAME   | Specified logger name | app   |
+| LOGGER_LEVEL  | Control log level     | debug |
+| LOGGER_FILE_PATH | Log directory and name | /tmp/jac_cloud_logs/jac-cloud.log |
+| LOGGER_ROLLOVER_INTERVAL | M = every minute, H = hourly, D = daily, W = weekly | D |
+| LOGGER_MAX_BACKUP | Maximum number of backup files before it will deletes old file. Non positive value will not have maximum | -1 |
+| LOGGER_ROLLOVER_MAX_FILE_SIZE | Maximum file size in bytes before it will rollover to new file | 10000000 |
+| LOGGER_USE_UTC | If logger will use UTC | false |
\ No newline at end of file
diff --git a/jac-cloud/jac_cloud/core/architype.py b/jac-cloud/jac_cloud/core/architype.py
index d08a2bfff8..dae2d2d6fd 100644
--- a/jac-cloud/jac_cloud/core/architype.py
+++ b/jac-cloud/jac_cloud/core/architype.py
@@ -7,7 +7,6 @@
 from re import IGNORECASE, compile
 from typing import (
     Any,
-    Callable,
     ClassVar,
     Iterable,
     Mapping,
@@ -20,7 +19,7 @@
 
 from bson import ObjectId
 
-from jaclang.compiler.constant import EdgeDir
+from jaclang.plugin.feature import JacFeature as Jac
 from jaclang.runtimelib.architype import (
     Access as _Access,
     AccessLevel,
@@ -389,43 +388,6 @@ def disconnect_edge(self, anchor: Anchor) -> None:
         """Push update that there's edge that has been removed."""
         self.pull("edges", anchor)
 
-    def allow_root(
-        self, root: "BaseAnchor", level: AccessLevel | int | str = AccessLevel.READ
-    ) -> None:
-        """Allow all access from target root graph to current Architype."""
-        level = AccessLevel.cast(level)
-        access = self.access.roots
-        if (ref_id := root.ref_id) and level != access.anchors.get(
-            ref_id, AccessLevel.NO_ACCESS
-        ):
-            access.anchors[ref_id] = level
-            self._set.update({f"access.roots.anchors.{ref_id}": level.name})
-            self._unset.pop(f"access.roots.anchors.{ref_id}", None)
-
-    def disallow_root(
-        self, root: Anchor, level: AccessLevel | int | str = AccessLevel.READ
-    ) -> None:
-        """Disallow all access from target root graph to current Architype."""
-        level = AccessLevel.cast(level)
-        access = self.access.roots
-
-        if (ref_id := root.ref_id) and access.anchors.pop(ref_id, None) is not None:
-            self._unset.update({f"access.roots.anchors.{ref_id}": True})
-            self._set.pop(f"access.roots.anchors.{ref_id}", None)
-
-    def unrestrict(self, level: AccessLevel | int | str = AccessLevel.READ) -> None:
-        """Allow everyone to access current Architype."""
-        level = AccessLevel.cast(level)
-        if level != self.access.all:
-            self.access.all = level
-            self._set.update({"access.all": level.name})
-
-    def restrict(self) -> None:
-        """Disallow others to access current Architype."""
-        if self.access.all > AccessLevel.NO_ACCESS:
-            self.access.all = AccessLevel.NO_ACCESS
-            self._set.update({"access.all": AccessLevel.NO_ACCESS.name})
-
     ####################################################
     #                POPULATE OPERATIONS               #
     ####################################################
@@ -461,14 +423,14 @@ def build_query(
         bulk_write: BulkWrite,
     ) -> None:
         """Save Anchor."""
-        if self.state.deleted is False and self.has_write_access(self):  # type: ignore[attr-defined]
+        if self.state.deleted is False and Jac.check_write_access(self):  # type: ignore[arg-type]
             self.state.deleted = True
             self.delete(bulk_write)
         elif not self.state.connected:
             self.state.connected = True
             self.sync_hash()
             self.insert(bulk_write)
-        elif self.has_connect_access(self):  # type: ignore[attr-defined]
+        elif Jac.check_connect_access(self):  # type: ignore[arg-type]
             self.update(bulk_write, True)
 
     def apply(self, session: ClientSession | None = None) -> BulkWrite:
@@ -507,9 +469,8 @@ def update(self, bulk_write: BulkWrite, propagate: bool = False) -> None:
         ############################################################
         #                     POPULATE CONTEXT                     #
         ############################################################
-        from .context import JaseciContext
 
-        if JaseciContext.get().root.has_write_access(self):
+        if Jac.check_write_access(self):  # type: ignore[arg-type]
             set_architype = changes.pop("$set", {})
             if is_dataclass(architype := self.architype) and not isinstance(
                 architype, type
@@ -587,10 +548,6 @@ def delete(self, bulk_write: BulkWrite) -> None:
         """Append Delete Query."""
         raise NotImplementedError("delete must be implemented in subclasses")
 
-    def destroy(self) -> None:
-        """Delete Anchor."""
-        raise NotImplementedError("destroy must be implemented in subclasses")
-
     def has_changed(self) -> int:
         """Check if needs to update."""
         if self.state.full_hash != (new_hash := hash(pdumps(self.serialize()))):
@@ -608,49 +565,6 @@ def sync_hash(self) -> None:
             }
             self.state.full_hash = hash(pdumps(self.serialize()))
 
-    def access_level(self, to: Anchor) -> AccessLevel:
-        """Access validation."""
-        if not to.persistent:
-            return AccessLevel.WRITE
-
-        from .context import JaseciContext
-
-        jctx = JaseciContext.get()
-
-        jroot = jctx.root
-
-        # if current root is system_root
-        # if current root id is equal to target anchor's root id
-        # if current root is the target anchor
-        if jroot == jctx.system_root or jroot.id == to.root or jroot == to:
-            return AccessLevel.WRITE
-
-        access_level = AccessLevel.NO_ACCESS
-
-        # if target anchor have set access.all
-        if (to_access := to.access).all > AccessLevel.NO_ACCESS:
-            access_level = to_access.all
-
-        # if target anchor's root have set allowed roots
-        # if current root is allowed to the whole graph of target anchor's root
-        if to.root and isinstance(
-            to_root := jctx.mem.find_by_id(NodeAnchor.ref(f"n::{to.root}")), Anchor
-        ):
-            if to_root.access.all > access_level:
-                access_level = to_root.access.all
-
-            level = to_root.access.roots.check(jroot.ref_id)
-            if level > AccessLevel.NO_ACCESS and access_level == AccessLevel.NO_ACCESS:
-                access_level = level
-
-        # if target anchor have set allowed roots
-        # if current root is allowed to target anchor
-        level = to_access.roots.check(jroot.ref_id)
-        if level > AccessLevel.NO_ACCESS and access_level == AccessLevel.NO_ACCESS:
-            access_level = level
-
-        return access_level
-
     # ---------------------------------------------------------------------- #
 
     def report(self) -> dict[str, object]:
@@ -760,47 +674,6 @@ def delete(self, bulk_write: BulkWrite) -> None:
 
         bulk_write.del_node(self.id)
 
-    def destroy(self) -> None:
-        """Delete Anchor."""
-        if self.state.deleted is None:
-            from .context import JaseciContext
-
-            jctx = JaseciContext.get()
-
-            if jctx.root.has_write_access(self):
-
-                self.state.deleted = False
-
-                for edge in self.edges:
-                    edge.destroy()
-                jctx.mem.remove(self.id)
-
-    def get_edges(
-        self,
-        dir: EdgeDir,
-        filter_func: Callable[[list["EdgeArchitype"]], list["EdgeArchitype"]] | None,
-        target_obj: list["NodeArchitype"] | None,
-    ) -> list["EdgeArchitype"]:
-        """Get edges connected to this node."""
-        from .context import JaseciContext
-
-        JaseciContext.get().mem.populate_data(self.edges)
-
-        return super().get_edges(dir, filter_func, target_obj)
-
-    def edges_to_nodes(
-        self,
-        dir: EdgeDir,
-        filter_func: Callable[[list["EdgeArchitype"]], list["EdgeArchitype"]] | None,
-        target_obj: list["NodeArchitype"] | None,
-    ) -> list["NodeArchitype"]:
-        """Get set of nodes connected to this node."""
-        from .context import JaseciContext
-
-        JaseciContext.get().mem.populate_data(self.edges)
-
-        return super().edges_to_nodes(dir, filter_func, target_obj)
-
     def serialize(self) -> dict[str, object]:
         """Serialize Node Anchor."""
         return {
@@ -848,11 +721,6 @@ def __document__(cls, doc: Mapping[str, Any]) -> "EdgeAnchor":
             anchor.sync_hash()
             return anchor
 
-    def __post_init__(self) -> None:
-        """Populate edge to source and target."""
-        # remove parent trigger
-        pass
-
     @classmethod
     def ref(cls, ref_id: str) -> "EdgeAnchor":
         """Return EdgeAnchor instance if existing."""
@@ -883,25 +751,6 @@ def delete(self, bulk_write: BulkWrite) -> None:
 
         bulk_write.del_edge(self.id)
 
-    def destroy(self) -> None:
-        """Delete Anchor."""
-        if self.state.deleted is None:
-            from .context import JaseciContext
-
-            jctx = JaseciContext.get()
-
-            if jctx.root.has_write_access(self):
-                self.state.deleted = False
-                self.detach()
-                jctx.mem.remove(self.id)
-
-    def detach(self) -> None:
-        """Detach edge from nodes."""
-        self.source.remove_edge(self)
-        self.source.disconnect_edge(self)
-        self.target.remove_edge(self)
-        self.target.disconnect_edge(self)
-
     def serialize(self) -> dict[str, object]:
         """Serialize Node Anchor."""
         return {
@@ -972,61 +821,6 @@ def delete(self, bulk_write: BulkWrite) -> None:
         """Append Delete Query."""
         bulk_write.del_walker(self.id)
 
-    def destroy(self) -> None:
-        """Delete Anchor."""
-        if self.state.deleted is None:
-            from .context import JaseciContext
-
-            jctx = JaseciContext.get()
-
-            if jctx.root.has_write_access(self):
-                self.state.deleted = False
-                jctx.mem.remove(self.id)
-
-    def spawn_call(self, node: Anchor) -> "WalkerArchitype":
-        """Invoke data spatial call."""
-        if walker := self.architype:
-            self.path = []
-            self.next = [node]
-            self.returns = []
-            while len(self.next):
-                if current_node := self.next.pop(0).architype:
-                    for i in current_node._jac_entry_funcs_:
-                        if not i.trigger or isinstance(walker, i.trigger):
-                            if i.func:
-                                self.returns.append(i.func(current_node, walker))
-                            else:
-                                raise ValueError(f"No function {i.name} to call.")
-                        if self.disengaged:
-                            return walker
-                    for i in walker._jac_entry_funcs_:
-                        if not i.trigger or isinstance(current_node, i.trigger):
-                            if i.func:
-                                self.returns.append(i.func(walker, current_node))
-                            else:
-                                raise ValueError(f"No function {i.name} to call.")
-                        if self.disengaged:
-                            return walker
-                    for i in walker._jac_exit_funcs_:
-                        if not i.trigger or isinstance(current_node, i.trigger):
-                            if i.func:
-                                self.returns.append(i.func(walker, current_node))
-                            else:
-                                raise ValueError(f"No function {i.name} to call.")
-                        if self.disengaged:
-                            return walker
-                    for i in current_node._jac_exit_funcs_:
-                        if not i.trigger or isinstance(walker, i.trigger):
-                            if i.func:
-                                self.returns.append(i.func(current_node, walker))
-                            else:
-                                raise ValueError(f"No function {i.name} to call.")
-                        if self.disengaged:
-                            return walker
-            self.ignores = []
-            return walker
-        raise Exception(f"Invalid Reference {self.id}")
-
 
 @dataclass(eq=False, repr=False, kw_only=True)
 class ObjectAnchor(BaseAnchor, Anchor):  # type: ignore[misc]
@@ -1081,7 +875,7 @@ class NodeArchitype(BaseArchitype, _NodeArchitype):
 
     __jac__: NodeAnchor
 
-    def __post_init__(self) -> None:
+    def __init__(self) -> None:
         """Create node architype."""
         self.__jac__ = NodeAnchor(
             architype=self,
@@ -1102,27 +896,6 @@ class EdgeArchitype(BaseArchitype, _EdgeArchitype):
 
     __jac__: EdgeAnchor
 
-    def __attach__(
-        self,
-        source: NodeAnchor,
-        target: NodeAnchor,
-        is_undirected: bool,
-    ) -> None:
-        """Attach EdgeAnchor properly."""
-        jac = self.__jac__ = EdgeAnchor(
-            architype=self,
-            name=self.__class__.__name__,
-            source=source,
-            target=target,
-            is_undirected=is_undirected,
-            access=Permission(),
-            state=AnchorState(),
-        )
-        source.edges.append(jac)
-        target.edges.append(jac)
-        source.connect_edge(jac)
-        target.connect_edge(jac)
-
     @classmethod
     def __ref_cls__(cls) -> str:
         """Get class naming."""
@@ -1134,7 +907,7 @@ class WalkerArchitype(BaseArchitype, _WalkerArchitype):
 
     __jac__: WalkerAnchor
 
-    def __post_init__(self) -> None:
+    def __init__(self) -> None:
         """Create walker architype."""
         self.__jac__ = WalkerAnchor(
             architype=self,
@@ -1154,7 +927,7 @@ class ObjectArchitype(BaseArchitype, Architype):
 
     __jac__: ObjectAnchor
 
-    def __post_init__(self) -> None:
+    def __init__(self) -> None:
         """Create default architype."""
         self.__jac__ = ObjectAnchor(
             architype=self,
@@ -1171,26 +944,6 @@ class GenericEdge(EdgeArchitype):
     _jac_entry_funcs_: ClassVar[list[DSFunc]] = []
     _jac_exit_funcs_: ClassVar[list[DSFunc]] = []
 
-    def __attach__(
-        self,
-        source: NodeAnchor,
-        target: NodeAnchor,
-        is_undirected: bool,
-    ) -> None:
-        """Attach EdgeAnchor properly."""
-        jac = self.__jac__ = EdgeAnchor(
-            architype=self,
-            source=source,
-            target=target,
-            is_undirected=is_undirected,
-            access=Permission(),
-            state=AnchorState(),
-        )
-        source.edges.append(jac)
-        target.edges.append(jac)
-        source.connect_edge(jac)
-        target.connect_edge(jac)
-
 
 @dataclass(eq=False)
 class Root(NodeArchitype):
@@ -1199,7 +952,7 @@ class Root(NodeArchitype):
     _jac_entry_funcs_: ClassVar[list[DSFunc]] = []
     _jac_exit_funcs_: ClassVar[list[DSFunc]] = []
 
-    def __post_init__(self) -> None:
+    def __init__(self) -> None:
         """Create node architype."""
         self.__jac__ = NodeAnchor(
             architype=self,
diff --git a/jac-cloud/jac_cloud/core/context.py b/jac-cloud/jac_cloud/core/context.py
index 092975966e..803254265a 100644
--- a/jac-cloud/jac_cloud/core/context.py
+++ b/jac-cloud/jac_cloud/core/context.py
@@ -8,7 +8,6 @@
 from bson import ObjectId
 
 from fastapi import Request
-from fastapi.responses import ORJSONResponse
 
 from jaclang.runtimelib.context import ExecutionContext
 
@@ -65,10 +64,6 @@ class JaseciContext(ExecutionContext):
     base: ExecutionContext
     request: Request
 
-    def validate_access(self) -> bool:
-        """Validate access."""
-        return self.root.has_read_access(self.entry_node)
-
     def close(self) -> None:
         """Clean up context."""
         self.mem.close()
@@ -144,7 +139,7 @@ def get_root() -> Root:  # type: ignore[override]
         """Get current root."""
         return cast(Root, JaseciContext.get().root.architype)
 
-    def response(self, returns: list[Any]) -> ORJSONResponse:
+    def response(self, returns: list[Any]) -> dict[str, Any]:
         """Return serialized version of reports."""
         resp = ContextResponse[Any](status=self.status)
 
@@ -159,7 +154,7 @@ def response(self, returns: list[Any]) -> ORJSONResponse:
         if SHOW_ENDPOINT_RETURNS:
             resp.returns = returns
 
-        return ORJSONResponse(resp.__serialize__(), status_code=self.status)
+        return resp.__serialize__()
 
     def clean_response(
         self, key: str | int, val: Any, obj: list | dict  # noqa: ANN401
diff --git a/jac-cloud/jac_cloud/core/memory.py b/jac-cloud/jac_cloud/core/memory.py
index e362f77bdd..2439b0486c 100644
--- a/jac-cloud/jac_cloud/core/memory.py
+++ b/jac-cloud/jac_cloud/core/memory.py
@@ -6,6 +6,7 @@
 
 from bson import ObjectId
 
+from jaclang.plugin.feature import JacFeature as Jac
 from jaclang.runtimelib.memory import Memory
 
 
@@ -115,9 +116,6 @@ def close(self) -> None:
 
     def get_bulk_write(self) -> BulkWrite:
         """Sync memory to database."""
-        from .context import JaseciContext
-
-        JaseciContext
         bulk_write = BulkWrite()
 
         for anchor in self.__gc__:
@@ -139,8 +137,8 @@ def get_bulk_write(self) -> BulkWrite:
                     bulk_write.operations[anchor.__class__].append(
                         InsertOne(anchor.serialize())
                     )
-                elif (new_hash := anchor.has_changed()) and anchor.has_connect_access(
-                    anchor
+                elif (new_hash := anchor.has_changed()) and Jac.check_connect_access(
+                    anchor  # type: ignore[arg-type]
                 ):
                     anchor.state.full_hash = new_hash
                     if (
diff --git a/jac-cloud/jac_cloud/jaseci/__init__.py b/jac-cloud/jac_cloud/jaseci/__init__.py
index 0c7bc41812..068a60e59a 100644
--- a/jac-cloud/jac_cloud/jaseci/__init__.py
+++ b/jac-cloud/jac_cloud/jaseci/__init__.py
@@ -2,13 +2,15 @@
 
 from contextlib import asynccontextmanager
 from os import getenv
+from traceback import format_exception
 from typing import Any, AsyncGenerator
 
-from fastapi import FastAPI as _FaststAPI
+from fastapi import FastAPI as _FaststAPI, Request
+from fastapi.responses import ORJSONResponse
 
 from uvicorn import run as _run
 
-from .utils import Emailer
+from .utils import Emailer, logger
 
 
 class FastAPI:
@@ -63,6 +65,22 @@ async def lifespan(app: _FaststAPI) -> AsyncGenerator[None, _FaststAPI]:
             for router in [healthz_router, sso_router, user_router, walker_router]:
                 cls.__app__.include_router(router)
 
+            @cls.__app__.exception_handler(Exception)
+            async def uncatched_exception_handler(
+                request: Request, exc: Exception
+            ) -> ORJSONResponse:
+                """Catched uncatched exceptions."""
+                response = {"errors": format_exception(exc)}
+
+                log: dict[str, Any] = {"request_url": str(request.url)}
+                log["extra_fields"] = list(log.keys())
+                logger.error(
+                    f"Call from to {log["request_url"]} returns unexpected errors: {response["errors"]}",
+                    extra=log,
+                )
+
+                return ORJSONResponse(response, status_code=500)
+
         return cls.__app__
 
     @classmethod
@@ -71,7 +89,7 @@ def start(
         host: str | None = None,
         port: int | None = None,
         emailer: type[Emailer] | None = None,
-        **kwargs: Any  # noqa ANN401
+        **kwargs: Any,  # noqa ANN401
     ) -> None:
         """Run FastAPI Handler via Uvicorn."""
         if emailer:
@@ -81,5 +99,5 @@ def start(
             cls.get(),
             host=host or getenv("HOST") or "0.0.0.0",
             port=port or int(getenv("PORT", "8000")),
-            **kwargs
+            **kwargs,
         )
diff --git a/jac-cloud/jac_cloud/jaseci/models/user.py b/jac-cloud/jac_cloud/jaseci/models/user.py
index 1fe40a23a0..07ebb4cea8 100644
--- a/jac-cloud/jac_cloud/jaseci/models/user.py
+++ b/jac-cloud/jac_cloud/jaseci/models/user.py
@@ -29,6 +29,12 @@ def obfuscate(self) -> dict:
             data["password"] = pbkdf2_sha512.hash(self.password).encode()
         return data
 
+    def printable(self) -> dict:
+        """Return BaseModel.model_dump where the password is hashed."""
+        data = self.model_dump(exclude={"password"})
+        data["password"] = "****"
+        return data
+
 
 @dataclass(kw_only=True)
 class User:
diff --git a/jac-cloud/jac_cloud/jaseci/routers/user.py b/jac-cloud/jac_cloud/jaseci/routers/user.py
index e4a1bc25f5..570e449009 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,6 +38,8 @@
 @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())
+
     with User.Collection.get_session() as session, session.start_transaction():
         root = Root().__jac__
 
@@ -56,7 +58,9 @@ def register(req: User.register_type()) -> ORJSONResponse:  # type: ignore
                     BulkWrite.commit(session)
                     if not is_activated:
                         User.send_verification_code(create_code(id), req.email)
-                    return ORJSONResponse({"message": "Successfully Registered!"}, 201)
+                    resp = {"message": "Successfully Registered!"}
+                    log_exit(resp, log)
+                    return ORJSONResponse(resp, 201)
             except (ConnectionFailure, OperationFailure) as ex:
                 if ex.has_error_label("TransientTransactionError"):
                     retry += 1
@@ -72,7 +76,10 @@ def register(req: User.register_type()) -> ORJSONResponse:  # type: ignore
                 logger.exception("Error executing bulk write!")
                 session.abort_transaction()
                 break
-    return ORJSONResponse({"message": "Registration Failed!"}, 409)
+
+    resp = {"message": "Registration Failed!"}
+    log_exit(resp, log)
+    return ORJSONResponse(resp, 409)
 
 
 @router.post(
diff --git a/jac-cloud/jac_cloud/jaseci/utils/__init__.py b/jac-cloud/jac_cloud/jaseci/utils/__init__.py
index 31f0428e00..f3c00ae8a8 100644
--- a/jac-cloud/jac_cloud/jaseci/utils/__init__.py
+++ b/jac-cloud/jac_cloud/jaseci/utils/__init__.py
@@ -1,10 +1,10 @@
 """Jaseci Utilities."""
 
-import logging
 from datetime import datetime, timedelta, timezone
 from random import choice
 from string import ascii_letters, digits
 
+from .logger import log_dumps, log_entry, log_exit, logger
 from .mail import Emailer, SendGridEmailer
 
 
@@ -23,14 +23,14 @@ def utc_timestamp(**addons: int) -> int:
     return int(utc_datetime(**addons).timestamp())
 
 
-logger = logging.getLogger(__name__)
-# logger.addHandler(logging.StreamHandler(sys.stdout))
-
 __all__ = [
     "Emailer",
     "SendGridEmailer",
     "random_string",
     "utc_datetime",
     "utc_timestamp",
+    "log_dumps",
+    "log_entry",
+    "log_exit",
     "logger",
 ]
diff --git a/jac-cloud/jac_cloud/jaseci/utils/logger.py b/jac-cloud/jac_cloud/jaseci/utils/logger.py
new file mode 100644
index 0000000000..642c07e826
--- /dev/null
+++ b/jac-cloud/jac_cloud/jaseci/utils/logger.py
@@ -0,0 +1,306 @@
+"""Jaseci Log Handlers."""
+
+from datetime import time as dtime
+from enum import IntEnum
+from io import text_encoding
+from itertools import chain
+from json import dumps
+from logging import FileHandler, LogRecord, getLogger
+from logging.handlers import (
+    BaseRotatingHandler,
+    RotatingFileHandler,
+    TimedRotatingFileHandler,
+)
+from os import getenv, remove, stat
+from os.path import exists, getmtime, isfile
+from pathlib import Path
+from re import ASCII, compile, escape
+from stat import ST_MTIME
+from time import gmtime, localtime, strftime, time as ttime
+from typing import Any
+
+from ecs_logging import StdlibFormatter
+
+DEFAULT_PART = [0]
+DEFAULT_SEPARATORS = (",", ":")
+
+
+class MixedTimedRotatingFileHandler(TimedRotatingFileHandler, RotatingFileHandler):
+    """Merge TimedRotatingFileHandler and RotatingFileHandler."""
+
+    # mypy bug: Incompatible types in assignment
+    # (expression has type "int", base class "RotatingFileHandler" defined the type as "str")
+    # even RotatingHandler declared as int
+    maxBytes: int  # type: ignore[assignment] # noqa: N815
+
+    def __init__(
+        self,
+        filename: str,
+        when: str = "h",
+        interval: int = 1,
+        max_bytes: int = 0,
+        backup_count: int = 0,
+        encoding: str | None = None,
+        delay: bool = False,
+        utc: bool = False,
+        at_time: dtime | None = None,
+        errors: str | None = None,
+    ) -> None:
+        """Override __init__."""
+        Path(filename).parent.mkdir(parents=True, exist_ok=True)
+        BaseRotatingHandler.__init__(
+            self,
+            filename,
+            "a",
+            encoding=text_encoding(encoding),
+            delay=delay,
+            errors=errors,
+        )
+
+        file_path = Path(self.baseFilename)
+        self.file_folder = file_path.parent.absolute()
+        self.file_name = file_path.stem
+        self.file_ext = file_path.suffix
+
+        self.maxBytes: int = max_bytes
+        self.when = when.upper()
+        self.backupCount = backup_count
+        self.utc = utc
+        self.atTime = at_time
+
+        re_format = escape(self.file_name) + r"-[0-9]+" + escape(self.file_ext) + "$"
+        if self.when == "S":
+            self.interval = 1
+            self.prefix = "%Y-%m-%d-%H-%M-%S"
+            ext_match = (
+                r"^(?<!\d)\d{4}-\d{2}-\d{2}-\d{2}-\d{2}-\d{2}(?!\d)-" + re_format
+            )
+        elif self.when == "M":
+            self.interval = 60
+            self.prefix = "%Y-%m-%d-%H-%M"
+            ext_match = r"^(?<!\d)\d{4}-\d{2}-\d{2}-\d{2}-\d{2}(?!\d)-" + re_format
+        elif self.when == "H":
+            self.interval = 60 * 60
+            self.prefix = "%Y-%m-%d-%H"
+            ext_match = r"^(?<!\d)\d{4}-\d{2}-\d{2}-\d{2}(?!\d)-" + re_format
+        elif self.when == "D" or self.when == "MIDNIGHT":
+            self.interval = 60 * 60 * 24
+            self.prefix = "%Y-%m-%d"
+            ext_match = r"^(?<!\d)\d{4}-\d{2}-\d{2}(?!\d)-" + re_format
+        elif self.when.startswith("W"):
+            self.interval = 60 * 60 * 24 * 7
+            if len(self.when) != 2:
+                raise ValueError(
+                    f"You must specify a day for weekly rollover from 0 to 6 (0 is Monday): {self.when}"
+                )
+            if self.when[1] < "0" or self.when[1] > "6":
+                raise ValueError(
+                    f"Invalid day specified for weekly rollover: {self.when}"
+                )
+            self.dayOfWeek = int(self.when[1])
+            self.prefix = "%Y-%m-%d"
+            ext_match = r"^(?<!\d)\d{4}-\d{2}-\d{2}(?!\d)-" + re_format
+        else:
+            raise ValueError(f"Invalid rollover interval specified: {self.when}")
+
+        self.extMatch = compile(ext_match, ASCII)
+        self.interval = self.interval * interval
+        filename = self.baseFilename
+        if exists(filename):
+            t = stat(filename)[ST_MTIME]
+        else:
+            t = ttime()
+        self.has_buffer = False
+        self.rolloverAt = self.computeRollover(int(t))
+
+    def pull_buffer(self) -> int:
+        """Pull buffer."""
+        if self.has_buffer:
+            self.has_buffer = False
+            return self.interval
+        return 0
+
+    def build_file_name(self, prefix: str) -> str:
+        """Override rotation_filename."""
+        part_extractor = compile(
+            r"^"
+            + escape(f"{prefix}-{self.file_name}-")
+            + r"([0-9]+)"
+            + escape(self.file_ext)
+            + r"$"
+        )
+
+        part = (
+            max(
+                chain(
+                    (
+                        int(match.group(1))
+                        for path in self.file_folder.iterdir()
+                        if (match := part_extractor.match(path.name))
+                    ),
+                    DEFAULT_PART,
+                )
+            )
+            + 1
+        )
+
+        name = f"{self.file_folder}/{prefix}-{self.file_name}-{part}{self.file_ext}"
+
+        if not callable(self.namer):
+            return name
+        else:
+            return self.namer(name)
+
+    def remove_old_backup(self) -> None:
+        """Remove old backup files."""
+        if self.backupCount > 0:
+            backups = sorted(
+                (
+                    path
+                    for path in self.file_folder.iterdir()
+                    if self.extMatch.match(path.name)
+                ),
+                key=getmtime,
+            )
+
+            if self.backupCount < (backup_count := len(backups)):
+                for backup in backups[0 : backup_count - self.backupCount]:
+                    remove(backup)
+
+    def doRollover(self, record: LogRecord) -> None:  # type: ignore[override] # noqa: N802
+        """Override doRollover."""
+        current_time = int(record.created)
+        t = self.rolloverAt - (self.interval + self.pull_buffer())
+
+        if self.utc:
+            time_tuple = gmtime(t)
+        else:
+            time_tuple = localtime(t)
+            dst_now = localtime(current_time)[-1]
+            dst_then = time_tuple[-1]
+            if dst_now != dst_then:
+                if dst_now:
+                    addend = 3600
+                else:
+                    addend = -3600
+                time_tuple = localtime(t + addend)
+        prefix = strftime(self.prefix, time_tuple)
+
+        if self.stream:
+            self.stream.close()
+            self.stream = None  # type: ignore[assignment]
+
+        self.rotate(self.baseFilename, self.build_file_name(prefix))
+        self.remove_old_backup()
+
+        if not self.delay:
+            self.stream = self._open()
+
+    def shouldRollover(self, record: LogRecord) -> bool:  # noqa: N802
+        """Override shouldRollover."""
+        t = int(record.created)
+        if exists(self.baseFilename) and not isfile(self.baseFilename):
+            self.rolloverAt = self.computeRollover(t)
+            return False
+        if self.stream is None:
+            self.stream = self._open()
+        if self.maxBytes > 0:
+            msg = "%s\n" % self.format(record)
+            self.stream.seek(0, 2)
+            if self.stream.tell() + len(msg) >= self.maxBytes:
+                return True
+        if t >= self.rolloverAt:
+            self.has_buffer = True
+            self.rolloverAt = self.computeRollover(t)
+            return True
+        return False
+
+    def computeRollover(self, currentTime: int) -> int:  # noqa: N802, N803
+        """Override compute roll over to adjust buffer."""
+        return super().computeRollover(currentTime) - int(currentTime % self.interval)
+
+    def emit(self, record: LogRecord) -> None:
+        """
+        Emit a record.
+
+        Output the record to the file, catering for rollover as described
+        in doRollover().
+        """
+        try:
+            if self.shouldRollover(record):
+                self.doRollover(record)
+            FileHandler.emit(self, record)
+        except Exception:
+            self.handleError(record)
+
+
+class Level(IntEnum):
+    """Log Level Enum."""
+
+    CRITICAL = 50
+    FATAL = CRITICAL
+    ERROR = 40
+    WARNING = 30
+    WARN = WARNING
+    INFO = 20
+    DEBUG = 10
+    NOTSET = 0
+
+
+logger = getLogger(getenv("LOGGER_NAME", "app"))
+logger.setLevel(Level[getenv("LOGGER_LEVEL", "DEBUG")].value)
+
+handler = MixedTimedRotatingFileHandler(
+    getenv("LOGGER_FILE_PATH", "/tmp/jac_cloud_logs/jac-cloud.log"),
+    when=getenv("LOGGER_ROLLOVER_INTERVAL", "d"),
+    backup_count=int(getenv("LOGGER_MAX_BACKUP", "-1")),
+    max_bytes=int(getenv("LOGGER_ROLLOVER_MAX_FILE_SIZE", "10000000")),
+    utc=getenv("LOGGER_USE_UTC") == "true",
+)
+handler.setFormatter(StdlibFormatter())
+logger.addHandler(handler)
+
+
+def log_dumps(payload: dict[str, Any] | list[Any]) -> str:
+    """Dump dictionary log."""
+    return dumps(payload, separators=DEFAULT_SEPARATORS)
+
+
+def log_entry(
+    api: str, caller: str | None, payload: dict[str, Any], node: str | None = None
+) -> dict[str, Any]:
+    """Log metadata on entry."""
+    log: dict[str, Any] = {
+        "api_name": api,
+        "caller_name": caller,
+        "payload": log_dumps(payload),
+        "entry_node": node,
+    }
+    msg = str(
+        f"Incoming call from {log["caller_name"]}"
+        f" to {log["api_name"]}"
+        f" with payload: {log["payload"]}"
+        f" at entry node: {log["entry_node"]}"
+    )
+    log["extra_fields"] = list(log.keys())
+    logger.info(msg, extra=log)
+
+    return log
+
+
+def log_exit(response: dict[str, Any], log: dict[str, Any] | None = None) -> None:
+    """Log metadata on exit."""
+    log = log or {}
+    log["api_response"] = log_dumps(response)
+    log["extra_fields"] = list(log.keys())
+    log_msg = str(
+        f"Returning call from {log["caller_name"]}"
+        f" to {log["api_name"]}"
+        f" with payload: {log["payload"]}"
+        f" at entry node: {log["entry_node"]}"
+        f" with response: {log["api_response"]}"
+    )
+    logger.info(
+        log_msg,
+        extra=log,
+    )
diff --git a/jac-cloud/jac_cloud/plugin/jaseci.py b/jac-cloud/jac_cloud/plugin/jaseci.py
index d199ffb2e5..95b632c195 100644
--- a/jac-cloud/jac_cloud/plugin/jaseci.py
+++ b/jac-cloud/jac_cloud/plugin/jaseci.py
@@ -22,7 +22,8 @@
 )
 from fastapi.responses import ORJSONResponse
 
-from jaclang.plugin.default import JacFeatureDefaults, hookimpl
+from jaclang.compiler.constant import EdgeDir
+from jaclang.plugin.default import JacFeatureImpl, hookimpl
 from jaclang.plugin.feature import JacFeature as Jac
 from jaclang.runtimelib.architype import DSFunc
 
@@ -33,14 +34,18 @@
 from starlette.datastructures import UploadFile as BaseUploadFile
 
 from ..core.architype import (
+    AccessLevel,
     Anchor,
+    AnchorState,
     Architype,
     BaseAnchor,
+    EdgeAnchor,
     EdgeArchitype,
     GenericEdge,
     NodeAnchor,
     NodeArchitype,
     ObjectArchitype,
+    Permission,
     Root,
     WalkerAnchor,
     WalkerArchitype,
@@ -48,6 +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
 
 
 T = TypeVar("T")
@@ -151,6 +157,13 @@ 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,
+            )
+
             if isinstance(body, BaseUploadFile) and body_model:
                 body = loads(syncify(body.read)())
                 try:
@@ -161,16 +174,22 @@ def api_entry(
             jctx = JaseciContext.create(request, NodeAnchor.ref(node) if node else None)
 
             wlk: WalkerAnchor = cls(**body, **pl["query"], **pl["files"]).__jac__
-            if jctx.validate_access():
-                wlk.spawn_call(jctx.entry_node)
+            if Jac.check_read_access(jctx.entry_node):
+                Jac.spawn_call(wlk.architype, jctx.entry_node.architype)
                 jctx.close()
-                return jctx.response(wlk.returns)
+
+                resp = jctx.response(wlk.returns)
+                log_exit(resp, log)
+
+                return ORJSONResponse(resp, jctx.status)
             else:
+                error = {
+                    "error": f"You don't have access on target entry{cast(Anchor, jctx.entry_node).ref_id}!"
+                }
                 jctx.close()
-                raise HTTPException(
-                    403,
-                    f"You don't have access on target entry{cast(Anchor, jctx.entry_node).ref_id}!",
-                )
+
+                log_exit(error, log)
+                raise HTTPException(403, error)
 
         def api_root(
             request: Request,
@@ -258,16 +277,201 @@ class DefaultSpecs:
     private: bool = False
 
 
-class JacPlugin:
+class JacAccessValidationPlugin:
+    """Jac Access Validation Implementations."""
+
+    @staticmethod
+    @hookimpl
+    def allow_root(
+        architype: Architype, root_id: BaseAnchor, level: AccessLevel | int | str
+    ) -> None:
+        """Allow all access from target root graph to current Architype."""
+        if not FastAPI.is_enabled():
+            JacFeatureImpl.allow_root(
+                architype=architype, root_id=root_id, level=level  # type: ignore[arg-type]
+            )
+            return
+
+        anchor = architype.__jac__
+
+        level = AccessLevel.cast(level)
+        access = anchor.access.roots
+        if (
+            isinstance(anchor, BaseAnchor)
+            and (ref_id := root_id.ref_id)
+            and level != access.anchors.get(ref_id, AccessLevel.NO_ACCESS)
+        ):
+            access.anchors[ref_id] = level
+            anchor._set.update({f"access.roots.anchors.{ref_id}": level.name})
+            anchor._unset.pop(f"access.roots.anchors.{ref_id}", None)
+
+    @staticmethod
+    @hookimpl
+    def disallow_root(
+        architype: Architype, root_id: BaseAnchor, level: AccessLevel | int | str
+    ) -> None:
+        """Disallow all access from target root graph to current Architype."""
+        if not FastAPI.is_enabled():
+            JacFeatureImpl.disallow_root(
+                architype=architype, root_id=root_id, level=level  # type: ignore[arg-type]
+            )
+            return
+
+        anchor = architype.__jac__
+
+        level = AccessLevel.cast(level)
+        access = anchor.access.roots
+        if (
+            isinstance(anchor, BaseAnchor)
+            and (ref_id := root_id.ref_id)
+            and access.anchors.pop(ref_id, None) is not None
+        ):
+            anchor._unset.update({f"access.roots.anchors.{ref_id}": True})
+            anchor._set.pop(f"access.roots.anchors.{ref_id}", None)
+
+    @staticmethod
+    @hookimpl
+    def unrestrict(architype: Architype, level: AccessLevel | int | str) -> None:
+        """Allow everyone to access current Architype."""
+        if not FastAPI.is_enabled():
+            JacFeatureImpl.unrestrict(architype=architype, level=level)
+            return
+
+        anchor = architype.__jac__
+
+        level = AccessLevel.cast(level)
+        if isinstance(anchor, BaseAnchor) and level != anchor.access.all:
+            anchor.access.all = level
+            anchor._set.update({"access.all": level.name})
+
+    @staticmethod
+    @hookimpl
+    def restrict(architype: Architype) -> None:
+        """Disallow others to access current Architype."""
+        if not FastAPI.is_enabled():
+            JacFeatureImpl.restrict(architype=architype)
+            return
+
+        anchor = architype.__jac__
+
+        if isinstance(anchor, BaseAnchor) and anchor.access.all > AccessLevel.NO_ACCESS:
+            anchor.access.all = AccessLevel.NO_ACCESS
+            anchor._set.update({"access.all": AccessLevel.NO_ACCESS.name})
+
+    @staticmethod
+    @hookimpl
+    def check_access_level(to: Anchor) -> AccessLevel:
+        """Access validation."""
+        if not FastAPI.is_enabled():
+            return JacFeatureImpl.check_access_level(to=to)
+
+        if not to.persistent:
+            return AccessLevel.WRITE
+
+        from ..core.context import JaseciContext
+
+        jctx = JaseciContext.get()
+
+        jroot = jctx.root
+
+        # if current root is system_root
+        # if current root id is equal to target anchor's root id
+        # if current root is the target anchor
+        if jroot == jctx.system_root or jroot.id == to.root or jroot == to:
+            return AccessLevel.WRITE
+
+        access_level = AccessLevel.NO_ACCESS
+
+        # if target anchor have set access.all
+        if (to_access := to.access).all > AccessLevel.NO_ACCESS:
+            access_level = to_access.all
+
+        # if target anchor's root have set allowed roots
+        # if current root is allowed to the whole graph of target anchor's root
+        if to.root and isinstance(
+            to_root := jctx.mem.find_by_id(NodeAnchor.ref(f"n::{to.root}")), Anchor
+        ):
+            if to_root.access.all > access_level:
+                access_level = to_root.access.all
+
+            level = to_root.access.roots.check(jroot.ref_id)
+            if level > AccessLevel.NO_ACCESS and access_level == AccessLevel.NO_ACCESS:
+                access_level = level
+
+        # if target anchor have set allowed roots
+        # if current root is allowed to target anchor
+        level = to_access.roots.check(jroot.ref_id)
+        if level > AccessLevel.NO_ACCESS and access_level == AccessLevel.NO_ACCESS:
+            access_level = level
+
+        return access_level
+
+
+class JacNodePlugin:
+    """Jac Node Operations."""
+
+    @staticmethod
+    @hookimpl
+    def get_edges(
+        node: NodeAnchor,
+        dir: EdgeDir,
+        filter_func: Callable[[list[EdgeArchitype]], list[EdgeArchitype]] | None,
+        target_obj: list[NodeArchitype] | None,
+    ) -> list[EdgeArchitype]:
+        """Get edges connected to this node."""
+        if FastAPI.is_enabled():
+            JaseciContext.get().mem.populate_data(node.edges)
+
+        return JacFeatureImpl.get_edges(
+            node=node, dir=dir, filter_func=filter_func, target_obj=target_obj  # type: ignore[arg-type, return-value]
+        )
+
+    @staticmethod
+    @hookimpl
+    def edges_to_nodes(
+        node: NodeAnchor,
+        dir: EdgeDir,
+        filter_func: Callable[[list[EdgeArchitype]], list[EdgeArchitype]] | None,
+        target_obj: list[NodeArchitype] | None,
+    ) -> list[NodeArchitype]:
+        """Get set of nodes connected to this node."""
+        if FastAPI.is_enabled():
+            JaseciContext.get().mem.populate_data(node.edges)
+
+        return JacFeatureImpl.edges_to_nodes(
+            node=node, dir=dir, filter_func=filter_func, target_obj=target_obj  # type: ignore[arg-type, return-value]
+        )
+
+
+class JacEdgePlugin:
+    """Jac Edge Operations."""
+
+    @staticmethod
+    @hookimpl
+    def detach(edge: EdgeAnchor) -> None:
+        """Detach edge from nodes."""
+        if not FastAPI.is_enabled():
+            JacFeatureImpl.detach(edge=edge)
+            return
+
+        Jac.remove_edge(node=edge.source, edge=edge)
+        edge.source.disconnect_edge(edge)
+
+        Jac.remove_edge(node=edge.target, edge=edge)
+        edge.target.disconnect_edge(edge)
+
+
+class JacPlugin(JacAccessValidationPlugin, JacNodePlugin, JacEdgePlugin):
     """Jaseci Implementations."""
 
     @staticmethod
     @hookimpl
     def get_context() -> ExecutionContext:
         """Get current execution context."""
-        if FastAPI.is_enabled():
-            return JaseciContext.get()
-        return JacFeatureDefaults.get_context()
+        if not FastAPI.is_enabled():
+            return JacFeatureImpl.get_context()
+
+        return JaseciContext.get()
 
     @staticmethod
     @hookimpl
@@ -278,46 +482,46 @@ def make_architype(
         on_exit: list[DSFunc],
     ) -> Type[Architype]:
         """Create a new architype."""
-        if FastAPI.is_enabled():
-            for i in on_entry + on_exit:
-                i.resolve(cls)
-            if not hasattr(cls, "_jac_entry_funcs_") or not hasattr(
-                cls, "_jac_exit_funcs_"
-            ):
-                # Saving the module path and reassign it after creating cls
-                # So the jac modules are part of the correct module
-                cur_module = cls.__module__
-                cls = type(cls.__name__, (cls, arch_base), {})
-                cls.__module__ = cur_module
-                cls._jac_entry_funcs_ = on_entry  # type: ignore
-                cls._jac_exit_funcs_ = on_exit  # type: ignore
-            else:
-                new_entry_funcs = OrderedDict(zip([i.name for i in on_entry], on_entry))
-                entry_funcs = OrderedDict(
-                    zip([i.name for i in cls._jac_entry_funcs_], cls._jac_entry_funcs_)
-                )
-                entry_funcs.update(new_entry_funcs)
-                cls._jac_entry_funcs_ = list(entry_funcs.values())
-
-                new_exit_funcs = OrderedDict(zip([i.name for i in on_exit], on_exit))
-                exit_funcs = OrderedDict(
-                    zip([i.name for i in cls._jac_exit_funcs_], cls._jac_exit_funcs_)
-                )
-                exit_funcs.update(new_exit_funcs)
-                cls._jac_exit_funcs_ = list(exit_funcs.values())
-
-            inner_init = cls.__init__  # type: ignore
-
-            @wraps(inner_init)
-            def new_init(self: Architype, *args: object, **kwargs: object) -> None:
-                arch_base.__init__(self)
-                inner_init(self, *args, **kwargs)
-
-            cls.__init__ = new_init  # type: ignore
-            return cls
-        return JacFeatureDefaults.make_architype(
-            cls=cls, arch_base=arch_base, on_entry=on_entry, on_exit=on_exit
-        )
+        if not FastAPI.is_enabled():
+            return JacFeatureImpl.make_architype(
+                cls=cls, arch_base=arch_base, on_entry=on_entry, on_exit=on_exit
+            )
+        for i in on_entry + on_exit:
+            i.resolve(cls)
+        if not hasattr(cls, "_jac_entry_funcs_") or not hasattr(
+            cls, "_jac_exit_funcs_"
+        ):
+            # Saving the module path and reassign it after creating cls
+            # So the jac modules are part of the correct module
+            cur_module = cls.__module__
+            cls = type(cls.__name__, (cls, arch_base), {})
+            cls.__module__ = cur_module
+            cls._jac_entry_funcs_ = on_entry  # type: ignore
+            cls._jac_exit_funcs_ = on_exit  # type: ignore
+        else:
+            new_entry_funcs = OrderedDict(zip([i.name for i in on_entry], on_entry))
+            entry_funcs = OrderedDict(
+                zip([i.name for i in cls._jac_entry_funcs_], cls._jac_entry_funcs_)
+            )
+            entry_funcs.update(new_entry_funcs)
+            cls._jac_entry_funcs_ = list(entry_funcs.values())
+
+            new_exit_funcs = OrderedDict(zip([i.name for i in on_exit], on_exit))
+            exit_funcs = OrderedDict(
+                zip([i.name for i in cls._jac_exit_funcs_], cls._jac_exit_funcs_)
+            )
+            exit_funcs.update(new_exit_funcs)
+            cls._jac_exit_funcs_ = list(exit_funcs.values())
+
+        inner_init = cls.__init__  # type: ignore
+
+        @wraps(inner_init)
+        def new_init(self: Architype, *args: object, **kwargs: object) -> None:
+            arch_base.__init__(self)
+            inner_init(self, *args, **kwargs)
+
+        cls.__init__ = new_init  # type: ignore
+        return cls
 
     @staticmethod
     @hookimpl
@@ -325,20 +529,20 @@ def make_obj(
         on_entry: list[DSFunc], on_exit: list[DSFunc]
     ) -> Callable[[type], type]:
         """Create a new architype."""
-        if FastAPI.is_enabled():
-
-            def decorator(cls: Type[Architype]) -> Type[Architype]:
-                """Decorate class."""
-                cls = Jac.make_architype(
-                    cls=cls,
-                    arch_base=ObjectArchitype,
-                    on_entry=on_entry,
-                    on_exit=on_exit,
-                )
-                return cls
+        if not FastAPI.is_enabled():
+            return JacFeatureImpl.make_obj(on_entry=on_entry, on_exit=on_exit)
+
+        def decorator(cls: Type[Architype]) -> Type[Architype]:
+            """Decorate class."""
+            cls = Jac.make_architype(
+                cls=cls,
+                arch_base=ObjectArchitype,
+                on_entry=on_entry,
+                on_exit=on_exit,
+            )
+            return cls
 
-            return decorator
-        return JacFeatureDefaults.make_obj(on_entry=on_entry, on_exit=on_exit)
+        return decorator
 
     @staticmethod
     @hookimpl
@@ -346,17 +550,17 @@ def make_node(
         on_entry: list[DSFunc], on_exit: list[DSFunc]
     ) -> Callable[[type], type]:
         """Create a obj architype."""
-        if FastAPI.is_enabled():
+        if not FastAPI.is_enabled():
+            return JacFeatureImpl.make_node(on_entry=on_entry, on_exit=on_exit)
 
-            def decorator(cls: Type[Architype]) -> Type[Architype]:
-                """Decorate class."""
-                cls = Jac.make_architype(
-                    cls=cls, arch_base=NodeArchitype, on_entry=on_entry, on_exit=on_exit
-                )
-                return cls
+        def decorator(cls: Type[Architype]) -> Type[Architype]:
+            """Decorate class."""
+            cls = Jac.make_architype(
+                cls=cls, arch_base=NodeArchitype, on_entry=on_entry, on_exit=on_exit
+            )
+            return cls
 
-            return decorator
-        return JacFeatureDefaults.make_node(on_entry=on_entry, on_exit=on_exit)
+        return decorator
 
     @staticmethod
     @hookimpl
@@ -364,17 +568,17 @@ def make_edge(
         on_entry: list[DSFunc], on_exit: list[DSFunc]
     ) -> Callable[[type], type]:
         """Create a edge architype."""
-        if FastAPI.is_enabled():
+        if not FastAPI.is_enabled():
+            return JacFeatureImpl.make_edge(on_entry=on_entry, on_exit=on_exit)
 
-            def decorator(cls: Type[Architype]) -> Type[Architype]:
-                """Decorate class."""
-                cls = Jac.make_architype(
-                    cls=cls, arch_base=EdgeArchitype, on_entry=on_entry, on_exit=on_exit
-                )
-                return cls
+        def decorator(cls: Type[Architype]) -> Type[Architype]:
+            """Decorate class."""
+            cls = Jac.make_architype(
+                cls=cls, arch_base=EdgeArchitype, on_entry=on_entry, on_exit=on_exit
+            )
+            return cls
 
-            return decorator
-        return JacFeatureDefaults.make_edge(on_entry=on_entry, on_exit=on_exit)
+        return decorator
 
     @staticmethod
     @hookimpl
@@ -382,46 +586,48 @@ def make_walker(
         on_entry: list[DSFunc], on_exit: list[DSFunc]
     ) -> Callable[[type], type]:
         """Create a walker architype."""
-        if FastAPI.is_enabled():
-
-            def decorator(cls: Type[Architype]) -> Type[Architype]:
-                """Decorate class."""
-                cls = Jac.make_architype(
-                    cls=cls,
-                    arch_base=WalkerArchitype,
-                    on_entry=on_entry,
-                    on_exit=on_exit,
-                )
-                populate_apis(cls)
-                return cls
+        if not FastAPI.is_enabled():
+            return JacFeatureImpl.make_walker(on_entry=on_entry, on_exit=on_exit)
+
+        def decorator(cls: Type[Architype]) -> Type[Architype]:
+            """Decorate class."""
+            cls = Jac.make_architype(
+                cls=cls,
+                arch_base=WalkerArchitype,
+                on_entry=on_entry,
+                on_exit=on_exit,
+            )
+            populate_apis(cls)
+            return cls
 
-            return decorator
-        return JacFeatureDefaults.make_walker(on_entry=on_entry, on_exit=on_exit)
+        return decorator
 
     @staticmethod
     @hookimpl
     def report(expr: Any) -> None:  # noqa:ANN401
         """Jac's report stmt feature."""
-        if FastAPI.is_enabled():
-            JaseciContext.get().reports.append(expr)
-            return
-        JacFeatureDefaults.report(expr=expr)
+        if not FastAPI.is_enabled():
+            return JacFeatureImpl.report(expr=expr)
+
+        JaseciContext.get().reports.append(expr)
 
     @staticmethod
     @hookimpl
     def get_root() -> Root:
         """Jac's assign comprehension feature."""
-        if FastAPI.is_enabled():
-            return JaseciContext.get_root()
-        return JacFeatureDefaults.get_root()  # type:ignore[return-value]
+        if not FastAPI.is_enabled():
+            return JacFeatureImpl.get_root()  # type:ignore[return-value]
+
+        return JaseciContext.get_root()
 
     @staticmethod
     @hookimpl
     def get_root_type() -> Type[Root]:
         """Jac's root getter."""
-        if FastAPI.is_enabled():
-            return Root
-        return JacFeatureDefaults.get_root_type()  # type:ignore[return-value]
+        if not FastAPI.is_enabled():
+            return JacFeatureImpl.get_root_type()  # type:ignore[return-value]
+
+        return Root
 
     @staticmethod
     @hookimpl
@@ -431,33 +637,53 @@ def build_edge(
         conn_assign: tuple[tuple, tuple] | None,
     ) -> Callable[[NodeAnchor, NodeAnchor], EdgeArchitype]:
         """Jac's root getter."""
-        if FastAPI.is_enabled():
-            conn_type = conn_type if conn_type else GenericEdge
-
-            def builder(source: NodeAnchor, target: NodeAnchor) -> EdgeArchitype:
-                edge = conn_type() if isinstance(conn_type, type) else conn_type
-                edge.__attach__(source, target, is_undirected)
-                if conn_assign:
-                    for fld, val in zip(conn_assign[0], conn_assign[1]):
-                        if hasattr(edge, fld):
-                            setattr(edge, fld, val)
-                        else:
-                            raise ValueError(f"Invalid attribute: {fld}")
-                if source.persistent or target.persistent:
-                    edge.__jac__.save()
-                    target.save()
-                    source.save()
-                return edge
-
-            return builder
-        return JacFeatureDefaults.build_edge(  # type:ignore[return-value]
-            is_undirected=is_undirected, conn_type=conn_type, conn_assign=conn_assign
-        )
+        if not FastAPI.is_enabled():
+            return JacFeatureImpl.build_edge(  # type:ignore[return-value]
+                is_undirected=is_undirected,
+                conn_type=conn_type,
+                conn_assign=conn_assign,
+            )
+
+        conn_type = conn_type if conn_type else GenericEdge
+
+        def builder(source: NodeAnchor, target: NodeAnchor) -> EdgeArchitype:
+            edge = conn_type() if isinstance(conn_type, type) else conn_type
+
+            eanch = edge.__jac__ = EdgeAnchor(
+                architype=edge,
+                name=("" if isinstance(edge, GenericEdge) else edge.__class__.__name__),
+                source=source,
+                target=target,
+                is_undirected=is_undirected,
+                access=Permission(),
+                state=AnchorState(),
+            )
+            source.edges.append(eanch)
+            target.edges.append(eanch)
+            source.connect_edge(eanch)
+            target.connect_edge(eanch)
+
+            if conn_assign:
+                for fld, val in zip(conn_assign[0], conn_assign[1]):
+                    if hasattr(edge, fld):
+                        setattr(edge, fld, val)
+                    else:
+                        raise ValueError(f"Invalid attribute: {fld}")
+            if source.persistent or target.persistent:
+                Jac.save(eanch)
+                Jac.save(target)
+                Jac.save(source)
+            return edge
+
+        return builder
 
     @staticmethod
     @hookimpl
     def get_object(id: str) -> Architype | None:
         """Get object via reference id."""
+        if not FastAPI.is_enabled():
+            return JacFeatureImpl.get_object(id=id)
+
         with suppress(ValueError):
             if isinstance(architype := BaseAnchor.ref(id).architype, Architype):
                 return architype
@@ -468,4 +694,122 @@ def get_object(id: str) -> Architype | None:
     @hookimpl
     def object_ref(obj: Architype) -> str:
         """Get object reference id."""
+        if not FastAPI.is_enabled():
+            return JacFeatureImpl.object_ref(obj=obj)
+
         return str(obj.__jac__.ref_id)
+
+    @staticmethod
+    @hookimpl
+    def spawn_call(op1: Architype, op2: Architype) -> WalkerArchitype:
+        """Invoke data spatial call."""
+        if not FastAPI.is_enabled():
+            return JacFeatureImpl.spawn_call(
+                op1=op1, op2=op2
+            )  # type:ignore[return-value]
+
+        if isinstance(op1, WalkerArchitype):
+            warch = op1
+            walker = op1.__jac__
+            if isinstance(op2, NodeArchitype):
+                node = op2.__jac__
+            elif isinstance(op2, EdgeArchitype):
+                node = op2.__jac__.target
+            else:
+                raise TypeError("Invalid target object")
+        elif isinstance(op2, WalkerArchitype):
+            warch = op2
+            walker = op2.__jac__
+            if isinstance(op1, NodeArchitype):
+                node = op1.__jac__
+            elif isinstance(op1, EdgeArchitype):
+                node = op1.__jac__.target
+            else:
+                raise TypeError("Invalid target object")
+        else:
+            raise TypeError("Invalid walker object")
+
+        walker.path = []
+        walker.next = [node]
+        walker.returns = []
+
+        if walker.next:
+            current_node = walker.next[-1].architype
+            for i in warch._jac_entry_funcs_:
+                if not i.trigger:
+                    if i.func:
+                        walker.returns.append(i.func(warch, current_node))
+                    else:
+                        raise ValueError(f"No function {i.name} to call.")
+        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):
+                        if i.func:
+                            walker.returns.append(i.func(current_node, warch))
+                        else:
+                            raise ValueError(f"No function {i.name} to call.")
+                    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:
+                            walker.returns.append(i.func(warch, current_node))
+                        elif not i.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:
+                            walker.returns.append(i.func(warch, current_node))
+                        elif not i.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):
+                        if i.func:
+                            walker.returns.append(i.func(current_node, warch))
+                        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:
+                if i.func:
+                    walker.returns.append(i.func(warch, current_node))
+                else:
+                    raise ValueError(f"No function {i.name} to call.")
+        walker.ignores = []
+        return warch
+
+    @staticmethod
+    @hookimpl
+    def destroy(obj: Architype | Anchor | BaseAnchor) -> None:
+        """Destroy object."""
+        if not FastAPI.is_enabled():
+            return JacFeatureImpl.destroy(obj=obj)  # type:ignore[arg-type]
+
+        anchor = obj.__jac__ if isinstance(obj, Architype) else obj
+
+        if (
+            isinstance(anchor, BaseAnchor)
+            and anchor.state.deleted is None
+            and Jac.check_write_access(anchor)  # type: ignore[arg-type]
+        ):
+            anchor.state.deleted = False
+            match anchor:
+                case NodeAnchor():
+                    for edge in anchor.edges:
+                        Jac.destroy(edge)
+                case EdgeAnchor():
+                    Jac.detach(anchor)
+                case _:
+                    pass
+
+            Jac.get_context().mem.remove(anchor.id)
diff --git a/jac-cloud/scripts/filebeat-template.yml b/jac-cloud/scripts/filebeat-template.yml
new file mode 100644
index 0000000000..bfcec61443
--- /dev/null
+++ b/jac-cloud/scripts/filebeat-template.yml
@@ -0,0 +1,20 @@
+filebeat.inputs:
+- type: log
+  enabled: true
+  paths:
+    - /tmp/jac_cloud_logs/*-jac-cloud-*.log
+    - /tmp/jac_cloud_logs/jac-cloud.log
+  json:
+    keys_under_root: true
+    overwrite_keys: true
+    add_error_key: true
+    expand_keys: true
+
+output.elasticsearch:
+  hosts: ["localhost:9200"]
+  protocol: https
+  api_key: "id:api_key"
+  index: "filebeat-testing"
+
+setup.template.name: "filebeat"
+setup.template.pattern: "filebeat-*"
\ No newline at end of file
diff --git a/jac-cloud/setup.py b/jac-cloud/setup.py
index d913b23e6a..6d9f9c1b55 100644
--- a/jac-cloud/setup.py
+++ b/jac-cloud/setup.py
@@ -2,14 +2,14 @@
 
 from setuptools import find_packages, setup
 
-VERSION = "0.1.1"
+VERSION = "0.1.3"
 
 setup(
     name="jac-cloud",
     version=VERSION,
     packages=find_packages(include=["jac_cloud", "jac_cloud.*"]),
     install_requires=[
-        "jaclang~=0.7.17",
+        "jaclang~=0.7.23",
         "fastapi~=0.111.0",
         "pydantic~=2.8.2",
         "pymongo~=4.8.0",
@@ -31,6 +31,7 @@
         "google-auth~=2.32.0",
         "asyncer~=0.0.8",
         "fakeredis~=2.24.1",
+        "ecs-logging~=2.2.0",
     ],
     package_data={},
     entry_points={
diff --git a/jac/.pre-commit-config.yaml b/jac/.pre-commit-config.yaml
index 3c64d33a1e..750eb07c79 100644
--- a/jac/.pre-commit-config.yaml
+++ b/jac/.pre-commit-config.yaml
@@ -7,7 +7,7 @@ repos:
       - id: check-json
       - id: trailing-whitespace
   - repo: https://github.com/psf/black
-    rev: 24.1.1
+    rev: 24.8.0
     hooks:
       - id: black
         exclude: "vendor"
diff --git a/jac/examples/micro/simple_walk_by_edge.jac b/jac/examples/micro/simple_walk_by_edge.jac
new file mode 100644
index 0000000000..1613dbfb53
--- /dev/null
+++ b/jac/examples/micro/simple_walk_by_edge.jac
@@ -0,0 +1,23 @@
+"""Example of simple walker walking nodes."""
+
+node A {}
+
+walker Walk {
+    has id: int = 0;
+
+    can skip_root with `root entry {
+        visit [-->];
+    }
+
+    can step with A entry {
+        print(f'Visited {self.id}');
+    }
+}
+
+with entry {
+    root ++> (a:=A());
+    ae = :e:[root-->a][0];
+
+    Walk(id = 1) spawn ae;
+    ae spawn Walk(id=2);
+}
diff --git a/jac/jaclang/__init__.py b/jac/jaclang/__init__.py
index 9afb8c8aa9..157fe1ab21 100644
--- a/jac/jaclang/__init__.py
+++ b/jac/jaclang/__init__.py
@@ -1,17 +1,12 @@
 """The Jac Programming Language."""
 
-from jaclang.plugin.default import (  # noqa: E402
-    JacBuiltin,
-    JacCmdDefaults,
-    JacFeatureDefaults,
-)
-from jaclang.plugin.feature import JacFeature, pm  # noqa: E402
+from jaclang.plugin.default import JacFeatureImpl
+from jaclang.plugin.feature import JacFeature, plugin_manager
 
 jac_import = JacFeature.jac_import
 
-pm.register(JacFeatureDefaults)
-pm.register(JacBuiltin)
-pm.register(JacCmdDefaults)
-pm.load_setuptools_entrypoints("jac")
+
+plugin_manager.register(JacFeatureImpl)
+plugin_manager.load_setuptools_entrypoints("jac")
 
 __all__ = ["jac_import"]
diff --git a/jac/jaclang/cli/cli.py b/jac/jaclang/cli/cli.py
index e6e3949cb8..7caf1e5f5b 100644
--- a/jac/jaclang/cli/cli.py
+++ b/jac/jaclang/cli/cli.py
@@ -28,6 +28,7 @@
 
 
 Cmd.create_cmd()
+Jac.setup()
 
 
 @cmd_registry.register
@@ -283,7 +284,9 @@ def enter(
 
             jctx.set_entry_node(node)
 
-            if isinstance(architype, WalkerArchitype) and jctx.validate_access():
+            if isinstance(architype, WalkerArchitype) and Jac.check_read_access(
+                jctx.entry_node
+            ):
                 Jac.spawn_call(jctx.entry_node.architype, architype)
 
     jctx.close()
diff --git a/jac/jaclang/compiler/passes/main/type_check_pass.py b/jac/jaclang/compiler/passes/main/type_check_pass.py
index 35abbbcff5..6184679230 100644
--- a/jac/jaclang/compiler/passes/main/type_check_pass.py
+++ b/jac/jaclang/compiler/passes/main/type_check_pass.py
@@ -50,12 +50,6 @@ def api(self, top_module_path: str = "") -> None:
         options = myab.myb.Options()
         options.ignore_missing_imports = True
         options.cache_dir = Con.JAC_MYPY_CACHE
-        options.mypy_path = [
-            # str( # TODO: Remove me, this was the wrong way to point to stubs
-            #     pathlib.Path(os.path.dirname(__file__)).parent.parent.parent.parent
-            #     / "stubs"
-            # )
-        ]
         if top_module_path != "":
             options.mypy_path.append(top_module_path)
 
@@ -116,6 +110,14 @@ def api(self, top_module_path: str = "") -> None:
             old_graph=mypy_graph,
             new_modules=new_modules,  # To parse the dependancies of modules
         )
+        mypy_graph = {
+            k: v
+            for k, v in mypy_graph.items()
+            if (
+                k.startswith("jaclang.plugin")
+                or not (k.startswith("jaclang.") or k.startswith("mypy."))
+            )
+        }
         for i in mypy_graph:
             self.ir.py_mod_dep_map[i] = mypy_graph[i].xpath
             for j in mypy_graph[i].dependencies:
diff --git a/jac/jaclang/plugin/builtin.py b/jac/jaclang/plugin/builtin.py
index 9288d26ae7..aaeb3fdffe 100644
--- a/jac/jaclang/plugin/builtin.py
+++ b/jac/jaclang/plugin/builtin.py
@@ -19,9 +19,9 @@ def dotgen(
     dot_file: Optional[str] = None,
 ) -> str:
     """Print the dot graph."""
-    from jaclang.plugin.feature import pm
+    from jaclang.plugin.feature import JacFeature as Jac
 
-    root = pm.hook.get_root()
+    root = Jac.get_root()
     node = node if node is not None else root
     depth = depth if depth is not None else -1
     traverse = traverse if traverse is not None else False
@@ -29,7 +29,7 @@ def dotgen(
     edge_limit = edge_limit if edge_limit is not None else 512
     node_limit = node_limit if node_limit is not None else 512
 
-    return pm.hook.dotgen(
+    return Jac.dotgen(
         edge_type=edge_type,
         node=node,
         depth=depth,
diff --git a/jac/jaclang/plugin/default.py b/jac/jaclang/plugin/default.py
index 22db8b68a8..9fc1da55ec 100644
--- a/jac/jaclang/plugin/default.py
+++ b/jac/jaclang/plugin/default.py
@@ -11,59 +11,548 @@
 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 uuid import UUID
 
-import jaclang.compiler.absyntree as ast
-from jaclang.compiler.constant import EdgeDir, colors
-from jaclang.compiler.passes.main.pyast_gen_pass import PyastGenPass
+from jaclang.compiler.constant import colors
 from jaclang.compiler.semtable import SemInfo, SemRegistry, SemScope
-from jaclang.runtimelib.constructs import (
+from jaclang.plugin.feature import (
+    AccessLevel,
+    Anchor,
     Architype,
     DSFunc,
     EdgeAnchor,
     EdgeArchitype,
+    EdgeDir,
     ExecutionContext,
-    GenericEdge,
-    JacTestCheck,
+    JacFeature as Jac,
     NodeAnchor,
     NodeArchitype,
+    P,
+    PyastGenPass,
     Root,
-    WalkerAnchor,
+    T,
     WalkerArchitype,
+    ast,
+)
+from jaclang.runtimelib.constructs import (
+    GenericEdge,
+    JacTestCheck,
 )
 from jaclang.runtimelib.importer import ImportPathSpec, JacImporter, PythonImporter
 from jaclang.runtimelib.machine import JacMachine, JacProgram
-from jaclang.runtimelib.utils import traverse_graph
-from jaclang.plugin.feature import JacFeature as Jac  # noqa: I100
-from jaclang.plugin.spec import P, T
+from jaclang.runtimelib.utils import collect_node_connections, traverse_graph
 
 
 import pluggy
 
 hookimpl = pluggy.HookimplMarker("jac")
+logger = getLogger(__name__)
+
+
+class JacAccessValidationImpl:
+    """Jac Access Validation Implementations."""
+
+    @staticmethod
+    @hookimpl
+    def allow_root(
+        architype: Architype, root_id: UUID, level: AccessLevel | int | str
+    ) -> None:
+        """Allow all access from target root graph to current Architype."""
+        level = AccessLevel.cast(level)
+        access = architype.__jac__.access.roots
+
+        _root_id = str(root_id)
+        if level != access.anchors.get(_root_id, AccessLevel.NO_ACCESS):
+            access.anchors[_root_id] = level
+
+    @staticmethod
+    @hookimpl
+    def disallow_root(
+        architype: Architype, root_id: UUID, level: AccessLevel | int | str
+    ) -> None:
+        """Disallow all access from target root graph to current Architype."""
+        level = AccessLevel.cast(level)
+        access = architype.__jac__.access.roots
+
+        access.anchors.pop(str(root_id), None)
+
+    @staticmethod
+    @hookimpl
+    def unrestrict(architype: Architype, level: AccessLevel | int | str) -> None:
+        """Allow everyone to access current Architype."""
+        anchor = architype.__jac__
+        level = AccessLevel.cast(level)
+        if level != anchor.access.all:
+            anchor.access.all = level
+
+    @staticmethod
+    @hookimpl
+    def restrict(architype: Architype) -> None:
+        """Disallow others to access current Architype."""
+        anchor = architype.__jac__
+        if anchor.access.all > AccessLevel.NO_ACCESS:
+            anchor.access.all = AccessLevel.NO_ACCESS
+
+    @staticmethod
+    @hookimpl
+    def check_read_access(to: Anchor) -> bool:
+        """Read Access Validation."""
+        if not (access_level := Jac.check_access_level(to) > AccessLevel.NO_ACCESS):
+            logger.info(
+                f"Current root doesn't have read access to {to.__class__.__name__}[{to.id}]"
+            )
+        return access_level
+
+    @staticmethod
+    @hookimpl
+    def check_connect_access(to: Anchor) -> bool:
+        """Write Access Validation."""
+        if not (access_level := Jac.check_access_level(to) > AccessLevel.READ):
+            logger.info(
+                f"Current root doesn't have connect access to {to.__class__.__name__}[{to.id}]"
+            )
+        return access_level
+
+    @staticmethod
+    @hookimpl
+    def check_write_access(to: Anchor) -> bool:
+        """Write Access Validation."""
+        if not (access_level := Jac.check_access_level(to) > AccessLevel.CONNECT):
+            logger.info(
+                f"Current root doesn't have write access to {to.__class__.__name__}[{to.id}]"
+            )
+        return access_level
+
+    @staticmethod
+    @hookimpl
+    def check_access_level(to: Anchor) -> AccessLevel:
+        """Access validation."""
+        if not to.persistent:
+            return AccessLevel.WRITE
+
+        jctx = Jac.get_context()
+
+        jroot = jctx.root
+
+        # if current root is system_root
+        # if current root id is equal to target anchor's root id
+        # if current root is the target anchor
+        if jroot == jctx.system_root or jroot.id == to.root or jroot == to:
+            return AccessLevel.WRITE
+
+        access_level = AccessLevel.NO_ACCESS
+
+        # if target anchor have set access.all
+        if (to_access := to.access).all > AccessLevel.NO_ACCESS:
+            access_level = to_access.all
+
+        # if target anchor's root have set allowed roots
+        # if current root is allowed to the whole graph of target anchor's root
+        if to.root and isinstance(to_root := jctx.mem.find_one(to.root), Anchor):
+            if to_root.access.all > access_level:
+                access_level = to_root.access.all
+
+            level = to_root.access.roots.check(str(jroot.id))
+            if level > AccessLevel.NO_ACCESS and access_level == AccessLevel.NO_ACCESS:
+                access_level = level
+
+        # if target anchor have set allowed roots
+        # if current root is allowed to target anchor
+        level = to_access.roots.check(str(jroot.id))
+        if level > AccessLevel.NO_ACCESS and access_level == AccessLevel.NO_ACCESS:
+            access_level = level
+
+        return access_level
+
+
+class JacNodeImpl:
+    """Jac Node Operations."""
+
+    @staticmethod
+    @hookimpl
+    def node_dot(node: NodeArchitype, dot_file: Optional[str]) -> str:
+        """Generate Dot file for visualizing nodes and edges."""
+        visited_nodes: set[NodeAnchor] = set()
+        connections: set[tuple[NodeArchitype, NodeArchitype, str]] = set()
+        unique_node_id_dict = {}
+
+        collect_node_connections(node.__jac__, visited_nodes, connections)
+        dot_content = 'digraph {\nnode [style="filled", shape="ellipse", fillcolor="invis", fontcolor="black"];\n'
+        for idx, i in enumerate([nodes_.architype for nodes_ in visited_nodes]):
+            unique_node_id_dict[i] = (i.__class__.__name__, str(idx))
+            dot_content += f'{idx} [label="{i}"];\n'
+        dot_content += 'edge [color="gray", style="solid"];\n'
+
+        for pair in list(set(connections)):
+            dot_content += (
+                f"{unique_node_id_dict[pair[0]][1]} -> {unique_node_id_dict[pair[1]][1]}"
+                f' [label="{pair[2]}"];\n'
+            )
+        if dot_file:
+            with open(dot_file, "w") as f:
+                f.write(dot_content + "}")
+        return dot_content + "}"
+
+    @staticmethod
+    @hookimpl
+    def get_edges(
+        node: NodeAnchor,
+        dir: EdgeDir,
+        filter_func: Optional[Callable[[list[EdgeArchitype]], list[EdgeArchitype]]],
+        target_obj: Optional[list[NodeArchitype]],
+    ) -> list[EdgeArchitype]:
+        """Get edges connected to this node."""
+        ret_edges: list[EdgeArchitype] = []
+        for anchor in node.edges:
+            if (
+                (source := anchor.source)
+                and (target := anchor.target)
+                and (not filter_func or filter_func([anchor.architype]))
+                and source.architype
+                and target.architype
+            ):
+                if (
+                    dir in [EdgeDir.OUT, EdgeDir.ANY]
+                    and node == source
+                    and (not target_obj or target.architype in target_obj)
+                    and Jac.check_read_access(target)
+                ):
+                    ret_edges.append(anchor.architype)
+                if (
+                    dir in [EdgeDir.IN, EdgeDir.ANY]
+                    and node == target
+                    and (not target_obj or source.architype in target_obj)
+                    and Jac.check_read_access(source)
+                ):
+                    ret_edges.append(anchor.architype)
+        return ret_edges
+
+    @staticmethod
+    @hookimpl
+    def edges_to_nodes(
+        node: NodeAnchor,
+        dir: EdgeDir,
+        filter_func: Optional[Callable[[list[EdgeArchitype]], list[EdgeArchitype]]],
+        target_obj: Optional[list[NodeArchitype]],
+    ) -> list[NodeArchitype]:
+        """Get set of nodes connected to this node."""
+        ret_edges: list[NodeArchitype] = []
+        for anchor in node.edges:
+            if (
+                (source := anchor.source)
+                and (target := anchor.target)
+                and (not filter_func or filter_func([anchor.architype]))
+                and source.architype
+                and target.architype
+            ):
+                if (
+                    dir in [EdgeDir.OUT, EdgeDir.ANY]
+                    and node == source
+                    and (not target_obj or target.architype in target_obj)
+                    and Jac.check_read_access(target)
+                ):
+                    ret_edges.append(target.architype)
+                if (
+                    dir in [EdgeDir.IN, EdgeDir.ANY]
+                    and node == target
+                    and (not target_obj or source.architype in target_obj)
+                    and Jac.check_read_access(source)
+                ):
+                    ret_edges.append(source.architype)
+        return ret_edges
+
+    @staticmethod
+    @hookimpl
+    def remove_edge(node: NodeAnchor, edge: EdgeAnchor) -> None:
+        """Remove reference without checking sync status."""
+        for idx, ed in enumerate(node.edges):
+            if ed.id == edge.id:
+                node.edges.pop(idx)
+                break
+
+
+class JacEdgeImpl:
+    """Jac Edge Operations."""
+
+    @staticmethod
+    @hookimpl
+    def detach(edge: EdgeAnchor) -> None:
+        """Detach edge from nodes."""
+        Jac.remove_edge(node=edge.source, edge=edge)
+        Jac.remove_edge(node=edge.target, edge=edge)
+
+
+class JacWalkerImpl:
+    """Jac Edge Operations."""
+
+    @staticmethod
+    @hookimpl
+    def visit_node(
+        walker: WalkerArchitype,
+        expr: (
+            list[NodeArchitype | EdgeArchitype]
+            | list[NodeArchitype]
+            | list[EdgeArchitype]
+            | NodeArchitype
+            | EdgeArchitype
+        ),
+    ) -> bool:
+        """Jac's visit stmt feature."""
+        if isinstance(walker, WalkerArchitype):
+            """Walker visits node."""
+            wanch = walker.__jac__
+            before_len = len(wanch.next)
+            for anchor in (
+                (i.__jac__ for i in expr) if isinstance(expr, list) else [expr.__jac__]
+            ):
+                if anchor not in wanch.ignores:
+                    if isinstance(anchor, NodeAnchor):
+                        wanch.next.append(anchor)
+                    elif isinstance(anchor, EdgeAnchor):
+                        if target := anchor.target:
+                            wanch.next.append(target)
+                        else:
+                            raise ValueError("Edge has no target.")
+            return len(wanch.next) > before_len
+        else:
+            raise TypeError("Invalid walker object")
+
+    @staticmethod
+    @hookimpl
+    def ignore(
+        walker: WalkerArchitype,
+        expr: (
+            list[NodeArchitype | EdgeArchitype]
+            | list[NodeArchitype]
+            | list[EdgeArchitype]
+            | NodeArchitype
+            | EdgeArchitype
+        ),
+    ) -> bool:
+        """Jac's ignore stmt feature."""
+        if isinstance(walker, WalkerArchitype):
+            wanch = walker.__jac__
+            before_len = len(wanch.ignores)
+            for anchor in (
+                (i.__jac__ for i in expr) if isinstance(expr, list) else [expr.__jac__]
+            ):
+                if anchor not in wanch.ignores:
+                    if isinstance(anchor, NodeAnchor):
+                        wanch.ignores.append(anchor)
+                    elif isinstance(anchor, EdgeAnchor):
+                        if target := anchor.target:
+                            wanch.ignores.append(target)
+                        else:
+                            raise ValueError("Edge has no target.")
+            return len(wanch.ignores) > before_len
+        else:
+            raise TypeError("Invalid walker object")
+
+    @staticmethod
+    @hookimpl
+    def spawn_call(op1: Architype, op2: Architype) -> WalkerArchitype:
+        """Invoke data spatial call."""
+        if isinstance(op1, WalkerArchitype):
+            warch = op1
+            walker = op1.__jac__
+            if isinstance(op2, NodeArchitype):
+                node = op2.__jac__
+            elif isinstance(op2, EdgeArchitype):
+                node = op2.__jac__.target
+            else:
+                raise TypeError("Invalid target object")
+        elif isinstance(op2, WalkerArchitype):
+            warch = op2
+            walker = op2.__jac__
+            if isinstance(op1, NodeArchitype):
+                node = op1.__jac__
+            elif isinstance(op1, EdgeArchitype):
+                node = op1.__jac__.target
+            else:
+                raise TypeError("Invalid target object")
+        else:
+            raise TypeError("Invalid walker object")
+
+        walker.path = []
+        walker.next = [node]
+        if walker.next:
+            current_node = walker.next[-1].architype
+            for i in warch._jac_entry_funcs_:
+                if not i.trigger:
+                    if i.func:
+                        i.func(warch, current_node)
+                    else:
+                        raise ValueError(f"No function {i.name} to call.")
+        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):
+                        if i.func:
+                            i.func(current_node, warch)
+                        else:
+                            raise ValueError(f"No function {i.name} to call.")
+                    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:
+                            i.func(warch, current_node)
+                        elif not i.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:
+                            i.func(warch, current_node)
+                        elif not i.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):
+                        if i.func:
+                            i.func(current_node, warch)
+                        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:
+                if i.func:
+                    i.func(warch, current_node)
+                else:
+                    raise ValueError(f"No function {i.name} to call.")
+        walker.ignores = []
+        return warch
+
+    @staticmethod
+    @hookimpl
+    def disengage(walker: WalkerArchitype) -> bool:  # noqa: ANN401
+        """Jac's disengage stmt feature."""
+        walker.__jac__.disengaged = True
+        return True
+
+
+class JacBuiltinImpl:
+    """Jac Builtins."""
+
+    @staticmethod
+    @hookimpl
+    def dotgen(
+        node: NodeArchitype,
+        depth: int,
+        traverse: bool,
+        edge_type: Optional[list[str]],
+        bfs: bool,
+        edge_limit: int,
+        node_limit: int,
+        dot_file: Optional[str],
+    ) -> str:
+        """Generate Dot file for visualizing nodes and edges."""
+        edge_type = edge_type if edge_type else []
+        visited_nodes: list[NodeArchitype] = []
+        node_depths: dict[NodeArchitype, int] = {node: 0}
+        queue: list = [[node, 0]]
+        connections: list[tuple[NodeArchitype, NodeArchitype, EdgeArchitype]] = []
+
+        def dfs(node: NodeArchitype, cur_depth: int) -> None:
+            """Depth first search."""
+            if node not in visited_nodes:
+                visited_nodes.append(node)
+                traverse_graph(
+                    node,
+                    cur_depth,
+                    depth,
+                    edge_type,
+                    traverse,
+                    connections,
+                    node_depths,
+                    visited_nodes,
+                    queue,
+                    bfs,
+                    dfs,
+                    node_limit,
+                    edge_limit,
+                )
+
+        if bfs:
+            cur_depth = 0
+            while queue:
+                current_node, cur_depth = queue.pop(0)
+                if current_node not in visited_nodes:
+                    visited_nodes.append(current_node)
+                    traverse_graph(
+                        current_node,
+                        cur_depth,
+                        depth,
+                        edge_type,
+                        traverse,
+                        connections,
+                        node_depths,
+                        visited_nodes,
+                        queue,
+                        bfs,
+                        dfs,
+                        node_limit,
+                        edge_limit,
+                    )
+        else:
+            dfs(node, cur_depth=0)
+        dot_content = (
+            'digraph {\nnode [style="filled", shape="ellipse", '
+            'fillcolor="invis", fontcolor="black"];\n'
+        )
+        for source, target, edge in connections:
+            dot_content += (
+                f"{visited_nodes.index(source)} -> {visited_nodes.index(target)} "
+                f' [label="{html.escape(str(edge.__jac__.architype))} "];\n'
+            )
+        for node_ in visited_nodes:
+            color = (
+                colors[node_depths[node_]] if node_depths[node_] < 25 else colors[24]
+            )
+            dot_content += (
+                f'{visited_nodes.index(node_)} [label="{html.escape(str(node_.__jac__.architype))}"'
+                f'fillcolor="{color}"];\n'
+            )
+        if dot_file:
+            with open(dot_file, "w") as f:
+                f.write(dot_content + "}")
+        return dot_content + "}"
+
 
-__all__ = [
-    "EdgeAnchor",
-    "GenericEdge",
-    "hookimpl",
-    "JacTestCheck",
-    "NodeAnchor",
-    "WalkerAnchor",
-    "NodeArchitype",
-    "EdgeArchitype",
-    "Root",
-    "WalkerArchitype",
-    "Architype",
-    "DSFunc",
-    "T",
-]
-
-
-class JacFeatureDefaults:
+class JacCmdImpl:
+    """Jac CLI command."""
+
+    @staticmethod
+    @hookimpl
+    def create_cmd() -> None:
+        """Create Jac CLI cmds."""
+        pass
+
+
+class JacFeatureImpl(
+    JacAccessValidationImpl,
+    JacNodeImpl,
+    JacEdgeImpl,
+    JacWalkerImpl,
+    JacBuiltinImpl,
+    JacCmdImpl,
+):
     """Jac Feature."""
 
-    pm = pluggy.PluginManager("jac")
+    @staticmethod
+    @hookimpl
+    def setup() -> None:
+        """Set Class References."""
+        pass
 
     @staticmethod
     @hookimpl
@@ -74,6 +563,7 @@ def get_context() -> ExecutionContext:
     @staticmethod
     @hookimpl
     def get_object(id: str) -> Architype | None:
+        """Get object by id."""
         if id == "root":
             return Jac.get_context().root.architype
         elif obj := Jac.get_context().mem.find_by_id(UUID(id)):
@@ -84,6 +574,7 @@ def get_object(id: str) -> Architype | None:
     @staticmethod
     @hookimpl
     def object_ref(obj: Architype) -> str:
+        """Get object's id."""
         return obj.__jac__.id.hex
 
     @staticmethod
@@ -361,69 +852,11 @@ def has_instance_default(gen_func: Callable[[], T]) -> T:
         """Jac's has container default feature."""
         return field(default_factory=lambda: gen_func())
 
-    @staticmethod
-    @hookimpl
-    def spawn_call(op1: Architype, op2: Architype) -> WalkerArchitype:
-        """Jac's spawn operator feature."""
-        if isinstance(op1, WalkerArchitype):
-            return op1.__jac__.spawn_call(op2.__jac__)
-        elif isinstance(op2, WalkerArchitype):
-            return op2.__jac__.spawn_call(op1.__jac__)
-        else:
-            raise TypeError("Invalid walker object")
-
     @staticmethod
     @hookimpl
     def report(expr: Any) -> Any:  # noqa: ANN401
         """Jac's report stmt feature."""
 
-    @staticmethod
-    @hookimpl
-    def ignore(
-        walker: WalkerArchitype,
-        expr: (
-            list[NodeArchitype | EdgeArchitype]
-            | list[NodeArchitype]
-            | list[EdgeArchitype]
-            | NodeArchitype
-            | EdgeArchitype
-        ),
-    ) -> bool:
-        """Jac's ignore stmt feature."""
-        if isinstance(walker, WalkerArchitype):
-            return walker.__jac__.ignore_node(
-                (i.__jac__ for i in expr) if isinstance(expr, list) else [expr.__jac__]
-            )
-        else:
-            raise TypeError("Invalid walker object")
-
-    @staticmethod
-    @hookimpl
-    def visit_node(
-        walker: WalkerArchitype,
-        expr: (
-            list[NodeArchitype | EdgeArchitype]
-            | list[NodeArchitype]
-            | list[EdgeArchitype]
-            | NodeArchitype
-            | EdgeArchitype
-        ),
-    ) -> bool:
-        """Jac's visit stmt feature."""
-        if isinstance(walker, WalkerArchitype):
-            return walker.__jac__.visit_node(
-                (i.__jac__ for i in expr) if isinstance(expr, list) else [expr.__jac__]
-            )
-        else:
-            raise TypeError("Invalid walker object")
-
-    @staticmethod
-    @hookimpl
-    def disengage(walker: WalkerArchitype) -> bool:  # noqa: ANN401
-        """Jac's disengage stmt feature."""
-        walker.__jac__.disengage_now()
-        return True
-
     @staticmethod
     @hookimpl
     def edge_ref(
@@ -444,19 +877,23 @@ def edge_ref(
         if edges_only:
             connected_edges: list[EdgeArchitype] = []
             for node in node_obj:
-                connected_edges += node.__jac__.get_edges(
-                    dir, filter_func, target_obj=targ_obj_set
+                edges = Jac.get_edges(
+                    node.__jac__, dir, filter_func, target_obj=targ_obj_set
+                )
+                connected_edges.extend(
+                    edge for edge in edges if edge not in connected_edges
                 )
-            return list(set(connected_edges))
+            return connected_edges
         else:
             connected_nodes: list[NodeArchitype] = []
             for node in node_obj:
+                nodes = Jac.edges_to_nodes(
+                    node.__jac__, dir, filter_func, target_obj=targ_obj_set
+                )
                 connected_nodes.extend(
-                    node.__jac__.edges_to_nodes(
-                        dir, filter_func, target_obj=targ_obj_set
-                    )
+                    node for node in nodes if node not in connected_nodes
                 )
-            return list(set(connected_nodes))
+            return connected_nodes
 
     @staticmethod
     @hookimpl
@@ -474,14 +911,12 @@ def connect(
         right = [right] if isinstance(right, NodeArchitype) else right
         edges = []
 
-        root = Jac.get_root().__jac__
-
         for i in left:
             _left = i.__jac__
-            if root.has_connect_access(_left):
+            if Jac.check_connect_access(_left):
                 for j in right:
                     _right = j.__jac__
-                    if root.has_connect_access(_right):
+                    if Jac.check_connect_access(_right):
                         edges.append(edge_spec(_left, _right))
         return right if not edges_only else edges
 
@@ -498,8 +933,6 @@ def disconnect(
         left = [left] if isinstance(left, NodeArchitype) else left
         right = [right] if isinstance(right, NodeArchitype) else right
 
-        root = Jac.get_root().__jac__
-
         for i in left:
             node = i.__jac__
             for anchor in set(node.edges):
@@ -514,17 +947,17 @@ def disconnect(
                         dir in [EdgeDir.OUT, EdgeDir.ANY]
                         and node == source
                         and target.architype in right
-                        and root.has_write_access(target)
+                        and Jac.check_write_access(target)
                     ):
-                        anchor.destroy() if anchor.persistent else anchor.detach()
+                        Jac.destroy(anchor) if anchor.persistent else Jac.detach(anchor)
                         disconnect_occurred = True
                     if (
                         dir in [EdgeDir.IN, EdgeDir.ANY]
                         and node == target
                         and source.architype in right
-                        and root.has_write_access(source)
+                        and Jac.check_write_access(source)
                     ):
-                        anchor.destroy() if anchor.persistent else anchor.detach()
+                        Jac.destroy(anchor) if anchor.persistent else Jac.detach(anchor)
                         disconnect_occurred = True
 
         return disconnect_occurred
@@ -565,7 +998,16 @@ def build_edge(
 
         def builder(source: NodeAnchor, target: NodeAnchor) -> EdgeArchitype:
             edge = conn_type() if isinstance(conn_type, type) else conn_type
-            edge.__attach__(source, target, is_undirected)
+
+            eanch = edge.__jac__ = EdgeAnchor(
+                architype=edge,
+                source=source,
+                target=target,
+                is_undirected=is_undirected,
+            )
+            source.edges.append(eanch)
+            target.edges.append(eanch)
+
             if conn_assign:
                 for fld, val in zip(conn_assign[0], conn_assign[1]):
                     if hasattr(edge, fld):
@@ -573,13 +1015,44 @@ def builder(source: NodeAnchor, target: NodeAnchor) -> EdgeArchitype:
                     else:
                         raise ValueError(f"Invalid attribute: {fld}")
             if source.persistent or target.persistent:
-                edge.__jac__.save()
-                target.save()
-                source.save()
+                Jac.save(eanch)
+                Jac.save(target)
+                Jac.save(source)
             return edge
 
         return builder
 
+    @staticmethod
+    @hookimpl
+    def save(obj: Architype | Anchor) -> None:
+        """Destroy object."""
+        anchor = obj.__jac__ if isinstance(obj, Architype) else obj
+
+        jctx = Jac.get_context()
+
+        anchor.persistent = True
+        anchor.root = jctx.root.id
+
+        jctx.mem.set(anchor.id, anchor)
+
+    @staticmethod
+    @hookimpl
+    def destroy(obj: Architype | Anchor) -> None:
+        """Destroy object."""
+        anchor = obj.__jac__ if isinstance(obj, Architype) else obj
+
+        if Jac.check_write_access(anchor):
+            match anchor:
+                case NodeAnchor():
+                    for edge in anchor.edges:
+                        Jac.destroy(edge)
+                case EdgeAnchor():
+                    Jac.detach(anchor)
+                case _:
+                    pass
+
+            Jac.get_context().mem.remove(anchor.id)
+
     @staticmethod
     @hookimpl
     def get_semstr_type(
@@ -645,6 +1118,7 @@ def obj_scope(file_loc: str, attr: str) -> str:
     @staticmethod
     @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),
@@ -843,101 +1317,3 @@ def get_by_llm_call_args(_pass: PyastGenPass, node: ast.FuncCall) -> dict:
             "include_info": [],
             "exclude_info": [],
         }
-
-
-class JacBuiltin:
-    """Jac Builtins."""
-
-    @staticmethod
-    @hookimpl
-    def dotgen(
-        node: NodeArchitype,
-        depth: int,
-        traverse: bool,
-        edge_type: list[str],
-        bfs: bool,
-        edge_limit: int,
-        node_limit: int,
-        dot_file: Optional[str],
-    ) -> str:
-        """Generate Dot file for visualizing nodes and edges."""
-        edge_type = edge_type if edge_type else []
-        visited_nodes: list[NodeArchitype] = []
-        node_depths: dict[NodeArchitype, int] = {node: 0}
-        queue: list = [[node, 0]]
-        connections: list[tuple[NodeArchitype, NodeArchitype, EdgeArchitype]] = []
-
-        def dfs(node: NodeArchitype, cur_depth: int) -> None:
-            """Depth first search."""
-            if node not in visited_nodes:
-                visited_nodes.append(node)
-                traverse_graph(
-                    node,
-                    cur_depth,
-                    depth,
-                    edge_type,
-                    traverse,
-                    connections,
-                    node_depths,
-                    visited_nodes,
-                    queue,
-                    bfs,
-                    dfs,
-                    node_limit,
-                    edge_limit,
-                )
-
-        if bfs:
-            cur_depth = 0
-            while queue:
-                current_node, cur_depth = queue.pop(0)
-                if current_node not in visited_nodes:
-                    visited_nodes.append(current_node)
-                    traverse_graph(
-                        current_node,
-                        cur_depth,
-                        depth,
-                        edge_type,
-                        traverse,
-                        connections,
-                        node_depths,
-                        visited_nodes,
-                        queue,
-                        bfs,
-                        dfs,
-                        node_limit,
-                        edge_limit,
-                    )
-        else:
-            dfs(node, cur_depth=0)
-        dot_content = (
-            'digraph {\nnode [style="filled", shape="ellipse", '
-            'fillcolor="invis", fontcolor="black"];\n'
-        )
-        for source, target, edge in connections:
-            dot_content += (
-                f"{visited_nodes.index(source)} -> {visited_nodes.index(target)} "
-                f' [label="{html.escape(str(edge.__jac__.architype))} "];\n'
-            )
-        for node_ in visited_nodes:
-            color = (
-                colors[node_depths[node_]] if node_depths[node_] < 25 else colors[24]
-            )
-            dot_content += (
-                f'{visited_nodes.index(node_)} [label="{html.escape(str(node_.__jac__.architype))}"'
-                f'fillcolor="{color}"];\n'
-            )
-        if dot_file:
-            with open(dot_file, "w") as f:
-                f.write(dot_content + "}")
-        return dot_content + "}"
-
-
-class JacCmdDefaults:
-    """Jac CLI command."""
-
-    @staticmethod
-    @hookimpl
-    def create_cmd() -> None:
-        """Create Jac CLI cmds."""
-        pass
diff --git a/jac/jaclang/plugin/feature.py b/jac/jaclang/plugin/feature.py
index fd9fe49e19..3c0b0e7feb 100644
--- a/jac/jaclang/plugin/feature.py
+++ b/jac/jaclang/plugin/feature.py
@@ -4,57 +4,265 @@
 
 import ast as ast3
 import types
-from typing import Any, Callable, Mapping, Optional, Sequence, Type, TypeAlias, Union
+from typing import (
+    Any,
+    Callable,
+    ClassVar,
+    Mapping,
+    Optional,
+    Sequence,
+    Type,
+    TypeAlias,
+    Union,
+)
+from uuid import UUID
 
-import jaclang.compiler.absyntree as ast
-from jaclang.compiler.passes.main.pyast_gen_pass import PyastGenPass
-from jaclang.plugin.spec import JacBuiltin, JacCmdSpec, JacFeatureSpec, P, T
-from jaclang.runtimelib.constructs import (
+from jaclang.plugin.spec import (
+    AccessLevel,
+    Anchor,
     Architype,
+    DSFunc,
+    EdgeAnchor,
     EdgeArchitype,
+    EdgeDir,
+    ExecutionContext,
     NodeAnchor,
     NodeArchitype,
+    P,
+    PyastGenPass,
     Root,
+    T,
     WalkerArchitype,
+    ast,
+    plugin_manager,
 )
-from jaclang.runtimelib.context import ExecutionContext
 
-import pluggy
 
-pm = pluggy.PluginManager("jac")
-pm.add_hookspecs(JacFeatureSpec)
-pm.add_hookspecs(JacCmdSpec)
-pm.add_hookspecs(JacBuiltin)
+class JacAccessValidation:
+    """Jac Access Validation Specs."""
 
+    @staticmethod
+    def allow_root(
+        architype: Architype,
+        root_id: UUID,
+        level: AccessLevel | int | str = AccessLevel.READ,
+    ) -> None:
+        """Allow all access from target root graph to current Architype."""
+        plugin_manager.hook.allow_root(
+            architype=architype, root_id=root_id, level=level
+        )
 
-class JacFeature:
-    """Jac Feature."""
+    @staticmethod
+    def disallow_root(
+        architype: Architype,
+        root_id: UUID,
+        level: AccessLevel | int | str = AccessLevel.READ,
+    ) -> None:
+        """Disallow all access from target root graph to current Architype."""
+        plugin_manager.hook.disallow_root(
+            architype=architype, root_id=root_id, level=level
+        )
+
+    @staticmethod
+    def unrestrict(
+        architype: Architype, level: AccessLevel | int | str = AccessLevel.READ
+    ) -> None:
+        """Allow everyone to access current Architype."""
+        plugin_manager.hook.unrestrict(architype=architype, level=level)
+
+    @staticmethod
+    def restrict(architype: Architype) -> None:
+        """Disallow others to access current Architype."""
+        plugin_manager.hook.restrict(architype=architype)
+
+    @staticmethod
+    def check_read_access(to: Anchor) -> bool:
+        """Read Access Validation."""
+        return plugin_manager.hook.check_read_access(to=to)
+
+    @staticmethod
+    def check_connect_access(to: Anchor) -> bool:
+        """Write Access Validation."""
+        return plugin_manager.hook.check_connect_access(to=to)
+
+    @staticmethod
+    def check_write_access(to: Anchor) -> bool:
+        """Write Access Validation."""
+        return plugin_manager.hook.check_write_access(to=to)
+
+    @staticmethod
+    def check_access_level(to: Anchor) -> AccessLevel:
+        """Access validation."""
+        return plugin_manager.hook.check_access_level(to=to)
+
+
+class JacNode:
+    """Jac Node Operations."""
+
+    @staticmethod
+    def node_dot(node: NodeArchitype, dot_file: Optional[str] = None) -> str:
+        """Generate Dot file for visualizing nodes and edges."""
+        return plugin_manager.hook.node_dot(node=node, dot_file=dot_file)
+
+    @staticmethod
+    def get_edges(
+        node: NodeAnchor,
+        dir: EdgeDir,
+        filter_func: Optional[Callable[[list[EdgeArchitype]], list[EdgeArchitype]]],
+        target_obj: Optional[list[NodeArchitype]],
+    ) -> list[EdgeArchitype]:
+        """Get edges connected to this node."""
+        return plugin_manager.hook.get_edges(
+            node=node, dir=dir, filter_func=filter_func, target_obj=target_obj
+        )
+
+    @staticmethod
+    def edges_to_nodes(
+        node: NodeAnchor,
+        dir: EdgeDir,
+        filter_func: Optional[Callable[[list[EdgeArchitype]], list[EdgeArchitype]]],
+        target_obj: Optional[list[NodeArchitype]],
+    ) -> list[NodeArchitype]:
+        """Get set of nodes connected to this node."""
+        return plugin_manager.hook.edges_to_nodes(
+            node=node, dir=dir, filter_func=filter_func, target_obj=target_obj
+        )
+
+    @staticmethod
+    def remove_edge(node: NodeAnchor, edge: EdgeAnchor) -> None:
+        """Remove reference without checking sync status."""
+        return plugin_manager.hook.remove_edge(node=node, edge=edge)
+
+
+class JacEdge:
+    """Jac Edge Operations."""
+
+    @staticmethod
+    def detach(edge: EdgeAnchor) -> None:
+        """Detach edge from nodes."""
+        return plugin_manager.hook.detach(edge=edge)
+
+
+class JacWalker:
+    """Jac Edge Operations."""
+
+    @staticmethod
+    def visit_node(
+        walker: WalkerArchitype,
+        expr: (
+            list[NodeArchitype | EdgeArchitype]
+            | list[NodeArchitype]
+            | list[EdgeArchitype]
+            | NodeArchitype
+            | EdgeArchitype
+        ),
+    ) -> bool:  # noqa: ANN401
+        """Jac's visit stmt feature."""
+        return plugin_manager.hook.visit_node(walker=walker, expr=expr)
+
+    @staticmethod
+    def ignore(
+        walker: WalkerArchitype,
+        expr: (
+            list[NodeArchitype | EdgeArchitype]
+            | list[NodeArchitype]
+            | list[EdgeArchitype]
+            | NodeArchitype
+            | EdgeArchitype
+        ),
+    ) -> bool:  # noqa: ANN401
+        """Jac's ignore stmt feature."""
+        return plugin_manager.hook.ignore(walker=walker, expr=expr)
+
+    @staticmethod
+    def spawn_call(op1: Architype, op2: Architype) -> WalkerArchitype:
+        """Jac's spawn operator feature."""
+        return plugin_manager.hook.spawn_call(op1=op1, op2=op2)
+
+    @staticmethod
+    def disengage(walker: WalkerArchitype) -> bool:
+        """Jac's disengage stmt feature."""
+        return plugin_manager.hook.disengage(walker=walker)
+
+
+class JacClassReferences:
+    """Default Classes References."""
+
+    EdgeDir: ClassVar[TypeAlias] = EdgeDir
+    DSFunc: ClassVar[TypeAlias] = DSFunc
+    RootType: ClassVar[TypeAlias] = Root
+    Obj: ClassVar[TypeAlias] = Architype
+    Node: ClassVar[TypeAlias] = NodeArchitype
+    Edge: ClassVar[TypeAlias] = EdgeArchitype
+    Walker: ClassVar[TypeAlias] = WalkerArchitype
+
+
+class JacBuiltin:
+    """Jac Builtins."""
+
+    @staticmethod
+    def dotgen(
+        node: NodeArchitype,
+        depth: int,
+        traverse: bool,
+        edge_type: Optional[list[str]],
+        bfs: bool,
+        edge_limit: int,
+        node_limit: int,
+        dot_file: Optional[str],
+    ) -> str:
+        """Generate Dot file for visualizing nodes and edges."""
+        return plugin_manager.hook.dotgen(
+            node=node,
+            depth=depth,
+            traverse=traverse,
+            edge_type=edge_type,
+            bfs=bfs,
+            edge_limit=edge_limit,
+            node_limit=node_limit,
+            dot_file=dot_file,
+        )
+
+
+class JacCmd:
+    """Jac CLI command."""
 
-    from jaclang.compiler.constant import EdgeDir as EdgeDirType
-    from jaclang.runtimelib.constructs import DSFunc as DSFuncType
+    @staticmethod
+    def create_cmd() -> None:
+        """Create Jac CLI cmds."""
+        return plugin_manager.hook.create_cmd()
+
+
+class JacFeature(
+    JacClassReferences,
+    JacAccessValidation,
+    JacNode,
+    JacEdge,
+    JacWalker,
+    JacBuiltin,
+    JacCmd,
+):
+    """Jac Feature."""
 
-    EdgeDir: TypeAlias = EdgeDirType
-    DSFunc: TypeAlias = DSFuncType
-    RootType: TypeAlias = Root
-    Obj: TypeAlias = Architype
-    Node: TypeAlias = NodeArchitype
-    Edge: TypeAlias = EdgeArchitype
-    Walker: TypeAlias = WalkerArchitype
+    @staticmethod
+    def setup() -> None:
+        """Set Class References."""
+        plugin_manager.hook.setup()
 
     @staticmethod
     def get_context() -> ExecutionContext:
         """Get current execution context."""
-        return pm.hook.get_context()
+        return plugin_manager.hook.get_context()
 
     @staticmethod
     def get_object(id: str) -> Architype | None:
         """Get object given id."""
-        return pm.hook.get_object(id=id)
+        return plugin_manager.hook.get_object(id=id)
 
     @staticmethod
     def object_ref(obj: Architype) -> str:
         """Get object reference id."""
-        return pm.hook.object_ref(obj=obj)
+        return plugin_manager.hook.object_ref(obj=obj)
 
     @staticmethod
     def make_architype(
@@ -64,7 +272,7 @@ def make_architype(
         on_exit: list[DSFunc],
     ) -> Type[Architype]:
         """Create a obj architype."""
-        return pm.hook.make_architype(
+        return plugin_manager.hook.make_architype(
             cls=cls, on_entry=on_entry, on_exit=on_exit, arch_base=arch_base
         )
 
@@ -73,35 +281,35 @@ def make_obj(
         on_entry: list[DSFunc], on_exit: list[DSFunc]
     ) -> Callable[[type], type]:
         """Create a obj architype."""
-        return pm.hook.make_obj(on_entry=on_entry, on_exit=on_exit)
+        return plugin_manager.hook.make_obj(on_entry=on_entry, on_exit=on_exit)
 
     @staticmethod
     def make_node(
         on_entry: list[DSFunc], on_exit: list[DSFunc]
     ) -> Callable[[type], type]:
         """Create a node architype."""
-        return pm.hook.make_node(on_entry=on_entry, on_exit=on_exit)
+        return plugin_manager.hook.make_node(on_entry=on_entry, on_exit=on_exit)
 
     @staticmethod
     def make_edge(
         on_entry: list[DSFunc], on_exit: list[DSFunc]
     ) -> Callable[[type], type]:
         """Create a edge architype."""
-        return pm.hook.make_edge(on_entry=on_entry, on_exit=on_exit)
+        return plugin_manager.hook.make_edge(on_entry=on_entry, on_exit=on_exit)
 
     @staticmethod
     def make_walker(
         on_entry: list[DSFunc], on_exit: list[DSFunc]
     ) -> Callable[[type], type]:
         """Create a walker architype."""
-        return pm.hook.make_walker(on_entry=on_entry, on_exit=on_exit)
+        return plugin_manager.hook.make_walker(on_entry=on_entry, on_exit=on_exit)
 
     @staticmethod
     def impl_patch_filename(
         file_loc: str,
     ) -> Callable[[Callable[P, T]], Callable[P, T]]:
         """Update impl file location."""
-        return pm.hook.impl_patch_filename(file_loc=file_loc)
+        return plugin_manager.hook.impl_patch_filename(file_loc=file_loc)
 
     @staticmethod
     def jac_import(
@@ -116,7 +324,7 @@ def jac_import(
         reload_module: Optional[bool] = False,
     ) -> tuple[types.ModuleType, ...]:
         """Core Import Process."""
-        return pm.hook.jac_import(
+        return plugin_manager.hook.jac_import(
             target=target,
             base_path=base_path,
             absorb=absorb,
@@ -131,7 +339,7 @@ def jac_import(
     @staticmethod
     def create_test(test_fun: Callable) -> Callable:
         """Create a test."""
-        return pm.hook.create_test(test_fun=test_fun)
+        return plugin_manager.hook.create_test(test_fun=test_fun)
 
     @staticmethod
     def run_test(
@@ -143,7 +351,7 @@ def run_test(
         verbose: bool = False,
     ) -> int:
         """Run the test suite in the specified .jac file."""
-        return pm.hook.run_test(
+        return plugin_manager.hook.run_test(
             filepath=filepath,
             filter=filter,
             xit=xit,
@@ -155,55 +363,17 @@ def run_test(
     @staticmethod
     def elvis(op1: Optional[T], op2: T) -> T:
         """Jac's elvis operator feature."""
-        return pm.hook.elvis(op1=op1, op2=op2)
+        return plugin_manager.hook.elvis(op1=op1, op2=op2)
 
     @staticmethod
     def has_instance_default(gen_func: Callable[[], T]) -> T:
         """Jac's has container default feature."""
-        return pm.hook.has_instance_default(gen_func=gen_func)
-
-    @staticmethod
-    def spawn_call(op1: Architype, op2: Architype) -> WalkerArchitype:
-        """Jac's spawn operator feature."""
-        return pm.hook.spawn_call(op1=op1, op2=op2)
+        return plugin_manager.hook.has_instance_default(gen_func=gen_func)
 
     @staticmethod
     def report(expr: Any) -> Any:  # noqa: ANN401
         """Jac's report stmt feature."""
-        return pm.hook.report(expr=expr)
-
-    @staticmethod
-    def ignore(
-        walker: WalkerArchitype,
-        expr: (
-            list[NodeArchitype | EdgeArchitype]
-            | list[NodeArchitype]
-            | list[EdgeArchitype]
-            | NodeArchitype
-            | EdgeArchitype
-        ),
-    ) -> bool:  # noqa: ANN401
-        """Jac's ignore stmt feature."""
-        return pm.hook.ignore(walker=walker, expr=expr)
-
-    @staticmethod
-    def visit_node(
-        walker: WalkerArchitype,
-        expr: (
-            list[NodeArchitype | EdgeArchitype]
-            | list[NodeArchitype]
-            | list[EdgeArchitype]
-            | NodeArchitype
-            | EdgeArchitype
-        ),
-    ) -> bool:  # noqa: ANN401
-        """Jac's visit stmt feature."""
-        return pm.hook.visit_node(walker=walker, expr=expr)
-
-    @staticmethod
-    def disengage(walker: WalkerArchitype) -> bool:  # noqa: ANN401
-        """Jac's disengage stmt feature."""
-        return pm.hook.disengage(walker=walker)
+        return plugin_manager.hook.report(expr=expr)
 
     @staticmethod
     def edge_ref(
@@ -214,7 +384,7 @@ def edge_ref(
         edges_only: bool = False,
     ) -> list[NodeArchitype] | list[EdgeArchitype]:
         """Jac's apply_dir stmt feature."""
-        return pm.hook.edge_ref(
+        return plugin_manager.hook.edge_ref(
             node_obj=node_obj,
             target_obj=target_obj,
             dir=dir,
@@ -233,7 +403,7 @@ def connect(
 
         Note: connect needs to call assign compr with tuple in op
         """
-        return pm.hook.connect(
+        return plugin_manager.hook.connect(
             left=left, right=right, edge_spec=edge_spec, edges_only=edges_only
         )
 
@@ -245,7 +415,7 @@ def disconnect(
         filter_func: Optional[Callable[[list[EdgeArchitype]], list[EdgeArchitype]]],
     ) -> bool:
         """Jac's disconnect operator feature."""
-        return pm.hook.disconnect(
+        return plugin_manager.hook.disconnect(
             left=left,
             right=right,
             dir=dir,
@@ -257,17 +427,17 @@ def assign_compr(
         target: list[T], attr_val: tuple[tuple[str], tuple[Any]]
     ) -> list[T]:
         """Jac's assign comprehension feature."""
-        return pm.hook.assign_compr(target=target, attr_val=attr_val)
+        return plugin_manager.hook.assign_compr(target=target, attr_val=attr_val)
 
     @staticmethod
     def get_root() -> Root:
         """Jac's root getter."""
-        return pm.hook.get_root()
+        return plugin_manager.hook.get_root()
 
     @staticmethod
     def get_root_type() -> Type[Root]:
         """Jac's root type getter."""
-        return pm.hook.get_root_type()
+        return plugin_manager.hook.get_root_type()
 
     @staticmethod
     def build_edge(
@@ -276,28 +446,42 @@ def build_edge(
         conn_assign: Optional[tuple[tuple, tuple]],
     ) -> Callable[[NodeAnchor, NodeAnchor], EdgeArchitype]:
         """Jac's root getter."""
-        return pm.hook.build_edge(
+        return plugin_manager.hook.build_edge(
             is_undirected=is_undirected, conn_type=conn_type, conn_assign=conn_assign
         )
 
+    @staticmethod
+    def save(
+        obj: Architype | Anchor,
+    ) -> None:
+        """Destroy object."""
+        plugin_manager.hook.save(obj=obj)
+
+    @staticmethod
+    def destroy(
+        obj: Architype | Anchor,
+    ) -> None:
+        """Destroy object."""
+        plugin_manager.hook.destroy(obj=obj)
+
     @staticmethod
     def get_semstr_type(
         file_loc: str, scope: str, attr: str, return_semstr: bool
     ) -> Optional[str]:
         """Jac's get_semstr_type feature."""
-        return pm.hook.get_semstr_type(
+        return plugin_manager.hook.get_semstr_type(
             file_loc=file_loc, scope=scope, attr=attr, return_semstr=return_semstr
         )
 
     @staticmethod
     def obj_scope(file_loc: str, attr: str) -> str:
         """Jac's get_semstr_type feature."""
-        return pm.hook.obj_scope(file_loc=file_loc, attr=attr)
+        return plugin_manager.hook.obj_scope(file_loc=file_loc, attr=attr)
 
     @staticmethod
     def get_sem_type(file_loc: str, attr: str) -> tuple[str | None, str | None]:
         """Jac's get_semstr_type feature."""
-        return pm.hook.get_sem_type(file_loc=file_loc, attr=attr)
+        return plugin_manager.hook.get_sem_type(file_loc=file_loc, attr=attr)
 
     @staticmethod
     def with_llm(
@@ -314,7 +498,7 @@ def with_llm(
         _locals: Mapping,
     ) -> Any:  # noqa: ANN401
         """Jac's with_llm feature."""
-        return pm.hook.with_llm(
+        return plugin_manager.hook.with_llm(
             file_loc=file_loc,
             model=model,
             model_params=model_params,
@@ -331,7 +515,7 @@ def with_llm(
     @staticmethod
     def gen_llm_body(_pass: PyastGenPass, node: ast.Ability) -> list[ast3.AST]:
         """Generate the by LLM body."""
-        return pm.hook.gen_llm_body(_pass=_pass, node=node)
+        return plugin_manager.hook.gen_llm_body(_pass=_pass, node=node)
 
     @staticmethod
     def by_llm_call(
@@ -346,7 +530,7 @@ def by_llm_call(
         exclude_info: list[tuple[str, ast3.AST]],
     ) -> ast3.Call:
         """Return the LLM Call, e.g. _Jac.with_llm()."""
-        return pm.hook.by_llm_call(
+        return plugin_manager.hook.by_llm_call(
             _pass=_pass,
             model=model,
             model_params=model_params,
@@ -361,13 +545,4 @@ def by_llm_call(
     @staticmethod
     def get_by_llm_call_args(_pass: PyastGenPass, node: ast.FuncCall) -> dict:
         """Get the by LLM call args."""
-        return pm.hook.get_by_llm_call_args(_pass=_pass, node=node)
-
-
-class JacCmd:
-    """Jac CLI command."""
-
-    @staticmethod
-    def create_cmd() -> None:
-        """Create Jac CLI cmds."""
-        return pm.hook.create_cmd()
+        return plugin_manager.hook.get_by_llm_call_args(_pass=_pass, node=node)
diff --git a/jac/jaclang/plugin/plugin.md b/jac/jaclang/plugin/plugin.md
new file mode 100644
index 0000000000..dd59f8f9b5
--- /dev/null
+++ b/jac/jaclang/plugin/plugin.md
@@ -0,0 +1,471 @@
+# **Override Plugin Implementations**
+
+
+## AccessValidation Related Methods
+### **`allow_root`**
+```python
+def allow_root(
+    architype: Architype,
+    root_id: UUID,
+    level: AccessLevel | int | str
+) -> None:
+    """Allow all access from target root graph to current Architype."""
+```
+### **`disallow_root`**
+```python
+def disallow_root(
+    architype: Architype,
+    root_id: UUID,
+    level: AccessLevel | int | str
+) -> None:
+    """Disallow all access from target root graph to current Architype."""
+```
+### **`unrestrict`**
+```python
+def unrestrict(
+    architype: Architype,
+    level: AccessLevel | int | str
+) -> None:
+    """Allow everyone to access current Architype."""
+```
+### **`restrict`**
+```python
+def restrict(
+    architype: Architype
+) -> None:
+    """Disallow others to access current Architype."""
+```
+### **`check_read_access`**
+```python
+def check_read_access(
+    to: Anchor
+) -> bool:
+    """Read Access Validation."""
+```
+### **`check_connect_access`**
+```python
+def check_connect_access(
+    to: Anchor
+) -> bool:
+    """Connect Access Validation."""
+```
+### **`check_write_access`**
+```python
+def check_write_access(
+    to: Anchor
+) -> bool:
+    """Write Access Validation."""
+```
+### **`check_access_level`**
+```python
+def check_access_level(
+    to: Anchor
+) -> AccessLevel:
+    """Access validation."""
+```
+
+
+## Node Related Methods
+### **`node_dot`**
+```python
+def node_dot(
+    node: NodeArchitype,
+    dot_file: Optional[str]
+) -> str:
+    """Generate Dot file for visualizing nodes and edges."""
+```
+### **`get_edges`**
+```python
+def get_edges(
+    node: NodeAnchor,
+    dir: EdgeDir,
+    filter_func: Optional[Callable[[list[EdgeArchitype]], list[EdgeArchitype]]],
+    target_obj: Optional[list[NodeArchitype]],
+) -> list[EdgeArchitype]:
+    """Get edges connected to this node."""
+```
+### **`edges_to_nodes`**
+```python
+def edges_to_nodes(
+    node: NodeAnchor,
+    dir: EdgeDir,
+    filter_func: Optional[Callable[[list[EdgeArchitype]], list[EdgeArchitype]]],
+    target_obj: Optional[list[NodeArchitype]],
+) -> list[NodeArchitype]:
+    """Get set of nodes connected to this node."""
+```
+### **`remove_edge`**
+```python
+def remove_edge(
+    node: NodeAnchor,
+    edge: EdgeAnchor
+) -> None:
+    """Remove reference without checking sync status."""
+```
+
+
+## Edge Related Methods
+### **`detach`**
+```python
+def detach(
+    edge: EdgeAnchor
+) -> None:
+    """Detach edge from nodes."""
+```
+
+
+## Walker Related Methods
+### **`visit_node`**
+```python
+def visit_node(
+    walker: WalkerArchitype,
+    expr: (
+    list[NodeArchitype | EdgeArchitype]
+    | list[NodeArchitype]
+    | list[EdgeArchitype]
+    | NodeArchitype
+    | EdgeArchitype
+    ),
+) -> bool:
+    """Include target node/edge to current walker's visit queue."""
+```
+### **`ignore`**
+```python
+def ignore(
+    walker: WalkerArchitype,
+    expr: (
+        list[NodeArchitype | EdgeArchitype]
+        | list[NodeArchitype]
+        | list[EdgeArchitype]
+        | NodeArchitype
+        | EdgeArchitype
+    ),
+) -> bool:
+    """Include target node/edge to current walker's ignored architype."""
+```
+### **`spawn_call`**
+```python
+def spawn_call(
+    op1: Architype,
+    op2: Architype
+) -> WalkerArchitype:
+    """Invoke data spatial call."""
+```
+### **`disengage`**
+```python
+def disengage(
+    walker: WalkerArchitype
+) -> bool:
+    """Disengaged current walker."""
+```
+
+
+## Builtin Related Methods
+### **`dotgen`**
+```python
+def dotgen(
+    node: NodeArchitype,
+    depth: int,
+    traverse: bool,
+    edge_type: Optional[list[str]],
+    bfs: bool,
+    edge_limit: int,
+    node_limit: int,
+    dot_file: Optional[str],
+) -> str:
+    """Print the dot graph."""
+```
+
+
+## Cmd Related Methods
+### **`create_cmd`**
+```python
+def create_cmd(
+) -> None:
+    """Create Jac CLI cmds."""
+```
+
+
+## Feature Related Methods
+### **`setup`**
+```python
+def setup(
+) -> None:
+    """Set Class References to Jac."""
+```
+### **`get_context`**
+```python
+def get_context(
+) -> ExecutionContext:
+    """Get current execution context."""
+```
+### **`get_object`**
+```python
+def get_object(
+    id: str
+) -> Architype | None:
+    """Get object by id."""
+```
+### **`object_ref`**
+```python
+def object_ref(
+    obj: Architype
+) -> str:
+    """Get object's id."""
+```
+### **`make_architype`**
+```python
+def make_architype(
+    cls: type,
+    arch_base: Type[Architype],
+    on_entry: list[DSFunc],
+    on_exit: list[DSFunc],
+) -> Type[Architype]:
+    """Create a obj architype."""
+```
+### **`make_obj`**
+```python
+def make_obj(
+    on_entry: list[DSFunc],
+    on_exit: list[DSFunc]
+) -> Callable[[type], type]:
+    """Create a obj architype."""
+```
+### **`make_node`**
+```python
+def make_node(
+    on_entry: list[DSFunc],
+    on_exit: list[DSFunc]
+) -> Callable[[type], type]:
+    """Create a node architype."""
+```
+### **`make_edge`**
+```python
+def make_edge(
+    on_entry: list[DSFunc],
+    on_exit: list[DSFunc]
+) -> Callable[[type], type]:
+    """Create a edge architype."""
+```
+### **`make_walker`**
+```python
+def make_walker(
+    on_entry: list[DSFunc],
+    on_exit: list[DSFunc]
+) -> Callable[[type], type]:
+    """Create a walker architype."""
+```
+### **`impl_patch_filename`**
+```python
+def impl_patch_filename(
+    file_loc: str,
+) -> Callable[[Callable[P, T]], Callable[P, T]]:
+    """Update impl file location."""
+```
+### **`jac_import`**
+```python
+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."""
+```
+### **`create_test`**
+```python
+def create_test(
+    test_fun: Callable
+) -> Callable:
+    """Create a new test."""
+```
+### **`run_test`**
+```python
+def run_test(
+    filepath: str,
+    filter: Optional[str],
+    xit: bool,
+    maxfail: Optional[int],
+    directory: Optional[str],
+    verbose: bool,
+) -> int:
+    """Run the test suite in the specified .jac file."""
+```
+### **`elvis`**
+```python
+def elvis(
+    op1: Optional[T],
+    op2: T
+) -> T:
+    """Jac's elvis operator feature."""
+```
+### **`has_instance_default`**
+```python
+def has_instance_default(
+    gen_func: Callable[[], T]
+) -> T:
+    """Jac's has container default feature."""
+```
+### **`report`**
+```python
+def report(
+    expr: Any
+) -> Any:
+    """Jac's report stmt feature."""
+```
+### **`edge_ref`**
+```python
+def edge_ref(
+    node_obj: NodeArchitype | list[NodeArchitype],
+    target_obj: Optional[NodeArchitype | list[NodeArchitype]],
+    dir: EdgeDir,
+    filter_func: Optional[Callable[[list[EdgeArchitype]], list[EdgeArchitype]]],
+    edges_only: bool,
+) -> list[NodeArchitype] | list[EdgeArchitype]:
+    """Jac's apply_dir stmt feature."""
+```
+### **`connect`**
+```python
+def connect(
+    left: NodeArchitype | list[NodeArchitype],
+    right: NodeArchitype | list[NodeArchitype],
+    edge_spec: Callable[[NodeAnchor, NodeAnchor], EdgeArchitype],
+    edges_only: bool,
+) -> list[NodeArchitype] | list[EdgeArchitype]:
+    """Jac's connect operator feature.
+
+    Note: connect needs to call assign compr with tuple in op
+    """
+```
+### **`disconnect`**
+```python
+def disconnect(
+    left: NodeArchitype | list[NodeArchitype],
+    right: NodeArchitype | list[NodeArchitype],
+    dir: EdgeDir,
+    filter_func: Optional[Callable[[list[EdgeArchitype]], list[EdgeArchitype]]],
+) -> bool:
+    """Jac's disconnect operator feature."""
+```
+### **`assign_compr`**
+```python
+def assign_compr(
+    target: list[T],
+    attr_val: tuple[tuple[str], tuple[Any]]
+) -> list[T]:
+    """Jac's assign comprehension feature."""
+```
+### **`get_root`**
+```python
+def get_root(
+) -> Root:
+    """Get current root."""
+```
+### **`get_root_type`**
+```python
+def get_root_type(
+) -> Type[Root]:
+    """Get root type."""
+```
+### **`build_edge`**
+```python
+def build_edge(
+    is_undirected: bool,
+    conn_type: Optional[Type[EdgeArchitype] | EdgeArchitype],
+    conn_assign: Optional[tuple[tuple, tuple]],
+) -> Callable[[NodeAnchor, NodeAnchor], EdgeArchitype]:
+    """Build edge operator."""
+```
+### **`save`**
+```python
+def save(
+    obj: Architype | Anchor,
+) -> None:
+    """Save object."""
+```
+### **`destroy`**
+```python
+def destroy(
+    obj: Architype | Anchor,
+) -> None:
+    """Destroy object."""
+```
+### **`get_semstr_type`**
+```python
+def get_semstr_type(
+    file_loc: str,
+    scope: str,
+    attr: str,
+    return_semstr: bool
+) -> Optional[str]:
+    """Jac's get_semstr_type stmt feature."""
+```
+### **`obj_scope`**
+```python
+def obj_scope(
+    file_loc: str,
+    attr: str
+) -> str:
+    """Jac's get_semstr_type feature."""
+```
+### **`get_sem_type`**
+```python
+def get_sem_type(
+    file_loc: str,
+    attr: str
+) -> tuple[str | None, str | None]:
+    """Jac's get_semstr_type feature."""
+```
+### **`with_llm`**
+```python
+def with_llm(
+    file_loc: str,
+    model: Any,
+    model_params: dict[str, Any],
+    scope: str,
+    incl_info: list[tuple[str, str]],
+    excl_info: list[tuple[str, str]],
+    inputs: list[tuple[str, str, str, Any]],
+    outputs: tuple,
+    action: str,
+    _globals: dict,
+    _locals: Mapping,
+) -> Any:
+    """Jac's with_llm stmt feature."""
+```
+### **`gen_llm_body`**
+```python
+def gen_llm_body(
+    _pass: PyastGenPass,
+    node: ast.Ability
+) -> list[ast3.AST]:
+    """Generate the by LLM body."""
+```
+### **`by_llm_call`**
+```python
+def by_llm_call(
+    _pass: PyastGenPass,
+    model: ast3.AST,
+    model_params: dict[str, ast.Expr],
+    scope: ast3.AST,
+    inputs: Sequence[Optional[ast3.AST]],
+    outputs: Sequence[Optional[ast3.AST]] | ast3.Call,
+    action: Optional[ast3.AST],
+    include_info: list[tuple[str, ast3.AST]],
+    exclude_info: list[tuple[str, ast3.AST]],
+) -> ast3.Call:
+    """Return the LLM Call, e.g. _Jac.with_llm()."""
+```
+### **`get_by_llm_call_args`**
+```python
+def get_by_llm_call_args(
+    _pass: PyastGenPass,
+    node: ast.FuncCall
+) -> dict:
+    """Get the by LLM call args."""
+```
diff --git a/jac/jaclang/plugin/spec.py b/jac/jaclang/plugin/spec.py
index e5fccc63dc..88b9c57538 100644
--- a/jac/jaclang/plugin/spec.py
+++ b/jac/jaclang/plugin/spec.py
@@ -11,37 +11,233 @@
     Optional,
     ParamSpec,
     Sequence,
-    TYPE_CHECKING,
     Type,
     TypeVar,
     Union,
 )
+from uuid import UUID
 
-import jaclang.compiler.absyntree as ast
+from jaclang.compiler import absyntree as ast
+from jaclang.compiler.constant import EdgeDir
 from jaclang.compiler.passes.main.pyast_gen_pass import PyastGenPass
-
-if TYPE_CHECKING:
-    from jaclang.plugin.default import (
-        Architype,
-        EdgeDir,
-        WalkerArchitype,
-        Root,
-        DSFunc,
-    )
-    from jaclang.runtimelib.constructs import EdgeArchitype, NodeAnchor, NodeArchitype
-    from jaclang.runtimelib.context import ExecutionContext
+from jaclang.runtimelib.constructs import (
+    AccessLevel,
+    Anchor,
+    Architype,
+    DSFunc,
+    EdgeAnchor,
+    EdgeArchitype,
+    NodeAnchor,
+    NodeArchitype,
+    Root,
+    WalkerArchitype,
+)
+from jaclang.runtimelib.context import ExecutionContext
 
 import pluggy
 
 hookspec = pluggy.HookspecMarker("jac")
+plugin_manager = pluggy.PluginManager("jac")
 
 T = TypeVar("T")
 P = ParamSpec("P")
 
 
-class JacFeatureSpec:
+class JacAccessValidationSpec:
+    """Jac Access Validation Specs."""
+
+    @staticmethod
+    @hookspec(firstresult=True)
+    def allow_root(
+        architype: Architype, root_id: UUID, level: AccessLevel | int | str
+    ) -> None:
+        """Allow all access from target root graph to current Architype."""
+        raise NotImplementedError
+
+    @staticmethod
+    @hookspec(firstresult=True)
+    def disallow_root(
+        architype: Architype, root_id: UUID, level: AccessLevel | int | str
+    ) -> None:
+        """Disallow all access from target root graph to current Architype."""
+        raise NotImplementedError
+
+    @staticmethod
+    @hookspec(firstresult=True)
+    def unrestrict(architype: Architype, level: AccessLevel | int | str) -> None:
+        """Allow everyone to access current Architype."""
+        raise NotImplementedError
+
+    @staticmethod
+    @hookspec(firstresult=True)
+    def restrict(architype: Architype) -> None:
+        """Disallow others to access current Architype."""
+        raise NotImplementedError
+
+    @staticmethod
+    @hookspec(firstresult=True)
+    def check_read_access(to: Anchor) -> bool:
+        """Read Access Validation."""
+        raise NotImplementedError
+
+    @staticmethod
+    @hookspec(firstresult=True)
+    def check_connect_access(to: Anchor) -> bool:
+        """Write Access Validation."""
+        raise NotImplementedError
+
+    @staticmethod
+    @hookspec(firstresult=True)
+    def check_write_access(to: Anchor) -> bool:
+        """Write Access Validation."""
+        raise NotImplementedError
+
+    @staticmethod
+    @hookspec(firstresult=True)
+    def check_access_level(to: Anchor) -> AccessLevel:
+        """Access validation."""
+        raise NotImplementedError
+
+
+class JacNodeSpec:
+    """Jac Node Operations."""
+
+    @staticmethod
+    @hookspec(firstresult=True)
+    def node_dot(node: NodeArchitype, dot_file: Optional[str]) -> str:
+        """Generate Dot file for visualizing nodes and edges."""
+        raise NotImplementedError
+
+    @staticmethod
+    @hookspec(firstresult=True)
+    def get_edges(
+        node: NodeAnchor,
+        dir: EdgeDir,
+        filter_func: Optional[Callable[[list[EdgeArchitype]], list[EdgeArchitype]]],
+        target_obj: Optional[list[NodeArchitype]],
+    ) -> list[EdgeArchitype]:
+        """Get edges connected to this node."""
+        raise NotImplementedError
+
+    @staticmethod
+    @hookspec(firstresult=True)
+    def edges_to_nodes(
+        node: NodeAnchor,
+        dir: EdgeDir,
+        filter_func: Optional[Callable[[list[EdgeArchitype]], list[EdgeArchitype]]],
+        target_obj: Optional[list[NodeArchitype]],
+    ) -> list[NodeArchitype]:
+        """Get set of nodes connected to this node."""
+        raise NotImplementedError
+
+    @staticmethod
+    @hookspec(firstresult=True)
+    def remove_edge(node: NodeAnchor, edge: EdgeAnchor) -> None:
+        """Remove reference without checking sync status."""
+        raise NotImplementedError
+
+
+class JacEdgeSpec:
+    """Jac Edge Operations."""
+
+    @staticmethod
+    @hookspec(firstresult=True)
+    def detach(edge: EdgeAnchor) -> None:
+        """Detach edge from nodes."""
+        raise NotImplementedError
+
+
+class JacWalkerSpec:
+    """Jac Edge Operations."""
+
+    @staticmethod
+    @hookspec(firstresult=True)
+    def visit_node(
+        walker: WalkerArchitype,
+        expr: (
+            list[NodeArchitype | EdgeArchitype]
+            | list[NodeArchitype]
+            | list[EdgeArchitype]
+            | NodeArchitype
+            | EdgeArchitype
+        ),
+    ) -> bool:  # noqa: ANN401
+        """Jac's visit stmt feature."""
+        raise NotImplementedError
+
+    @staticmethod
+    @hookspec(firstresult=True)
+    def ignore(
+        walker: WalkerArchitype,
+        expr: (
+            list[NodeArchitype | EdgeArchitype]
+            | list[NodeArchitype]
+            | list[EdgeArchitype]
+            | NodeArchitype
+            | EdgeArchitype
+        ),
+    ) -> bool:
+        """Jac's ignore stmt feature."""
+        raise NotImplementedError
+
+    @staticmethod
+    @hookspec(firstresult=True)
+    def spawn_call(op1: Architype, op2: Architype) -> WalkerArchitype:
+        """Invoke data spatial call."""
+        raise NotImplementedError
+
+    @staticmethod
+    @hookspec(firstresult=True)
+    def disengage(walker: WalkerArchitype) -> bool:
+        """Jac's disengage stmt feature."""
+        raise NotImplementedError
+
+
+class JacBuiltinSpec:
+    """Jac Builtins."""
+
+    @staticmethod
+    @hookspec(firstresult=True)
+    def dotgen(
+        node: NodeArchitype,
+        depth: int,
+        traverse: bool,
+        edge_type: Optional[list[str]],
+        bfs: bool,
+        edge_limit: int,
+        node_limit: int,
+        dot_file: Optional[str],
+    ) -> str:
+        """Print the dot graph."""
+        raise NotImplementedError
+
+
+class JacCmdSpec:
+    """Jac CLI command."""
+
+    @staticmethod
+    @hookspec
+    def create_cmd() -> None:
+        """Create Jac CLI cmds."""
+        raise NotImplementedError
+
+
+class JacFeatureSpec(
+    JacAccessValidationSpec,
+    JacNodeSpec,
+    JacEdgeSpec,
+    JacWalkerSpec,
+    JacBuiltinSpec,
+    JacCmdSpec,
+):
     """Jac Feature."""
 
+    @staticmethod
+    @hookspec(firstresult=True)
+    def setup() -> None:
+        """Set Class References."""
+        raise NotImplementedError
+
     @staticmethod
     @hookspec(firstresult=True)
     def get_context() -> ExecutionContext:
@@ -51,13 +247,13 @@ def get_context() -> ExecutionContext:
     @staticmethod
     @hookspec(firstresult=True)
     def get_object(id: str) -> Architype | None:
-        """Get object given id.."""
+        """Get object by id."""
         raise NotImplementedError
 
     @staticmethod
     @hookspec(firstresult=True)
     def object_ref(obj: Architype) -> str:
-        """Get object given id.."""
+        """Get object's id."""
         raise NotImplementedError
 
     @staticmethod
@@ -158,54 +354,12 @@ def has_instance_default(gen_func: Callable[[], T]) -> T:
         """Jac's has container default feature."""
         raise NotImplementedError
 
-    @staticmethod
-    @hookspec(firstresult=True)
-    def spawn_call(op1: Architype, op2: Architype) -> WalkerArchitype:
-        """Jac's spawn operator feature."""
-        raise NotImplementedError
-
     @staticmethod
     @hookspec(firstresult=True)
     def report(expr: Any) -> Any:  # noqa: ANN401
         """Jac's report stmt feature."""
         raise NotImplementedError
 
-    @staticmethod
-    @hookspec(firstresult=True)
-    def ignore(
-        walker: WalkerArchitype,
-        expr: (
-            list[NodeArchitype | EdgeArchitype]
-            | list[NodeArchitype]
-            | list[EdgeArchitype]
-            | NodeArchitype
-            | EdgeArchitype
-        ),
-    ) -> bool:
-        """Jac's ignore stmt feature."""
-        raise NotImplementedError
-
-    @staticmethod
-    @hookspec(firstresult=True)
-    def visit_node(
-        walker: WalkerArchitype,
-        expr: (
-            list[NodeArchitype | EdgeArchitype]
-            | list[NodeArchitype]
-            | list[EdgeArchitype]
-            | NodeArchitype
-            | EdgeArchitype
-        ),
-    ) -> bool:  # noqa: ANN401
-        """Jac's visit stmt feature."""
-        raise NotImplementedError
-
-    @staticmethod
-    @hookspec(firstresult=True)
-    def disengage(walker: WalkerArchitype) -> bool:  # noqa: ANN401
-        """Jac's disengage stmt feature."""
-        raise NotImplementedError
-
     @staticmethod
     @hookspec(firstresult=True)
     def edge_ref(
@@ -273,6 +427,22 @@ def build_edge(
         """Jac's root getter."""
         raise NotImplementedError
 
+    @staticmethod
+    @hookspec(firstresult=True)
+    def save(
+        obj: Architype | Anchor,
+    ) -> None:
+        """Destroy object."""
+        raise NotImplementedError
+
+    @staticmethod
+    @hookspec(firstresult=True)
+    def destroy(
+        obj: Architype | Anchor,
+    ) -> None:
+        """Destroy object."""
+        raise NotImplementedError
+
     @staticmethod
     @hookspec(firstresult=True)
     def get_semstr_type(
@@ -288,6 +458,7 @@ def obj_scope(file_loc: str, attr: str) -> str:
         raise NotImplementedError
 
     @staticmethod
+    @hookspec(firstresult=True)
     def get_sem_type(file_loc: str, attr: str) -> tuple[str | None, str | None]:
         """Jac's get_semstr_type feature."""
         raise NotImplementedError
@@ -339,30 +510,4 @@ def get_by_llm_call_args(_pass: PyastGenPass, node: ast.FuncCall) -> dict:
         raise NotImplementedError
 
 
-class JacBuiltin:
-    """Jac Builtins."""
-
-    @staticmethod
-    @hookspec(firstresult=True)
-    def dotgen(
-        node: NodeArchitype,
-        depth: int,
-        traverse: bool,
-        edge_type: list[str],
-        bfs: bool,
-        edge_limit: int,
-        node_limit: int,
-        dot_file: Optional[str],
-    ) -> str:
-        """Print the dot graph."""
-        raise NotImplementedError
-
-
-class JacCmdSpec:
-    """Jac CLI command."""
-
-    @staticmethod
-    @hookspec
-    def create_cmd() -> None:
-        """Create Jac CLI cmds."""
-        raise NotImplementedError
+plugin_manager.add_hookspecs(JacFeatureSpec)
diff --git a/jac/jaclang/runtimelib/architype.py b/jac/jaclang/runtimelib/architype.py
index c7979fa557..6c1ad9a55c 100644
--- a/jac/jaclang/runtimelib/architype.py
+++ b/jac/jaclang/runtimelib/architype.py
@@ -7,12 +7,9 @@
 from logging import getLogger
 from pickle import dumps
 from types import UnionType
-from typing import Any, Callable, ClassVar, Iterable, Optional, TypeVar
+from typing import Any, Callable, ClassVar, Optional, TypeVar
 from uuid import UUID, uuid4
 
-from jaclang.compiler.constant import EdgeDir
-from jaclang.runtimelib.utils import collect_node_connections
-
 logger = getLogger(__name__)
 
 TARCH = TypeVar("TARCH", bound="Architype")
@@ -77,128 +74,6 @@ class Anchor:
     persistent: bool = False
     hash: int = 0
 
-    ##########################################################################
-    #                             ACCESS CONTROL: TODO: Make Base Type       #
-    ##########################################################################
-
-    def allow_root(
-        self, root_id: UUID, level: AccessLevel | int | str = AccessLevel.READ
-    ) -> None:
-        """Allow all access from target root graph to current Architype."""
-        level = AccessLevel.cast(level)
-        access = self.access.roots
-
-        _root_id = str(root_id)
-        if level != access.anchors.get(_root_id, AccessLevel.NO_ACCESS):
-            access.anchors[_root_id] = level
-
-    def disallow_root(
-        self, root_id: UUID, level: AccessLevel | int | str = AccessLevel.READ
-    ) -> None:
-        """Disallow all access from target root graph to current Architype."""
-        level = AccessLevel.cast(level)
-        access = self.access.roots
-
-        access.anchors.pop(str(root_id), None)
-
-    def unrestrict(self, level: AccessLevel | int | str = AccessLevel.READ) -> None:
-        """Allow everyone to access current Architype."""
-        level = AccessLevel.cast(level)
-        if level != self.access.all:
-            self.access.all = level
-
-    def restrict(self) -> None:
-        """Disallow others to access current Architype."""
-        if self.access.all > AccessLevel.NO_ACCESS:
-            self.access.all = AccessLevel.NO_ACCESS
-
-    def has_read_access(self, to: Anchor) -> bool:
-        """Read Access Validation."""
-        if not (access_level := self.access_level(to) > AccessLevel.NO_ACCESS):
-            logger.info(
-                f"Current root doesn't have read access to {to.__class__.__name__}[{to.id}]"
-            )
-        return access_level
-
-    def has_connect_access(self, to: Anchor) -> bool:
-        """Write Access Validation."""
-        if not (access_level := self.access_level(to) > AccessLevel.READ):
-            logger.info(
-                f"Current root doesn't have connect access to {to.__class__.__name__}[{to.id}]"
-            )
-        return access_level
-
-    def has_write_access(self, to: Anchor) -> bool:
-        """Write Access Validation."""
-        if not (access_level := self.access_level(to) > AccessLevel.CONNECT):
-            logger.info(
-                f"Current root doesn't have write access to {to.__class__.__name__}[{to.id}]"
-            )
-        return access_level
-
-    def access_level(self, to: Anchor) -> AccessLevel:
-        """Access validation."""
-        if not to.persistent:
-            return AccessLevel.WRITE
-
-        from jaclang.plugin.feature import JacFeature as Jac
-
-        jctx = Jac.get_context()
-
-        jroot = jctx.root
-
-        # if current root is system_root
-        # if current root id is equal to target anchor's root id
-        # if current root is the target anchor
-        if jroot == jctx.system_root or jroot.id == to.root or jroot == to:
-            return AccessLevel.WRITE
-
-        access_level = AccessLevel.NO_ACCESS
-
-        # if target anchor have set access.all
-        if (to_access := to.access).all > AccessLevel.NO_ACCESS:
-            access_level = to_access.all
-
-        # if target anchor's root have set allowed roots
-        # if current root is allowed to the whole graph of target anchor's root
-        if to.root and isinstance(to_root := jctx.mem.find_one(to.root), Anchor):
-            if to_root.access.all > access_level:
-                access_level = to_root.access.all
-
-            level = to_root.access.roots.check(str(jroot.id))
-            if level > AccessLevel.NO_ACCESS and access_level == AccessLevel.NO_ACCESS:
-                access_level = level
-
-        # if target anchor have set allowed roots
-        # if current root is allowed to target anchor
-        level = to_access.roots.check(str(jroot.id))
-        if level > AccessLevel.NO_ACCESS and access_level == AccessLevel.NO_ACCESS:
-            access_level = level
-
-        return access_level
-
-    # ---------------------------------------------------------------------- #
-
-    def save(self) -> None:
-        """Save Anchor."""
-        from jaclang.plugin.feature import JacFeature as Jac
-
-        jctx = Jac.get_context()
-
-        self.persistent = True
-        self.root = jctx.root.id
-
-        jctx.mem.set(self.id, self)
-
-    def destroy(self) -> None:
-        """Destroy Anchor."""
-        from jaclang.plugin.feature import JacFeature as Jac
-
-        jctx = Jac.get_context()
-
-        if jctx.root.has_write_access(self):
-            jctx.mem.remove(self.id)
-
     def is_populated(self) -> bool:
         """Check if state."""
         return "architype" in self.__dict__
@@ -304,122 +179,6 @@ class NodeAnchor(Anchor):
     architype: NodeArchitype
     edges: list[EdgeAnchor]
 
-    def get_edges(
-        self,
-        dir: EdgeDir,
-        filter_func: Optional[Callable[[list[EdgeArchitype]], list[EdgeArchitype]]],
-        target_obj: Optional[list[NodeArchitype]],
-    ) -> list[EdgeArchitype]:
-        """Get edges connected to this node."""
-        from jaclang.plugin.feature import JacFeature as Jac
-
-        root = Jac.get_root().__jac__
-        ret_edges: list[EdgeArchitype] = []
-        for anchor in self.edges:
-            if (
-                (source := anchor.source)
-                and (target := anchor.target)
-                and (not filter_func or filter_func([anchor.architype]))
-                and source.architype
-                and target.architype
-            ):
-                if (
-                    dir in [EdgeDir.OUT, EdgeDir.ANY]
-                    and self == source
-                    and (not target_obj or target.architype in target_obj)
-                    and root.has_read_access(target)
-                ):
-                    ret_edges.append(anchor.architype)
-                if (
-                    dir in [EdgeDir.IN, EdgeDir.ANY]
-                    and self == target
-                    and (not target_obj or source.architype in target_obj)
-                    and root.has_read_access(source)
-                ):
-                    ret_edges.append(anchor.architype)
-        return ret_edges
-
-    def edges_to_nodes(
-        self,
-        dir: EdgeDir,
-        filter_func: Optional[Callable[[list[EdgeArchitype]], list[EdgeArchitype]]],
-        target_obj: Optional[list[NodeArchitype]],
-    ) -> list[NodeArchitype]:
-        """Get set of nodes connected to this node."""
-        from jaclang.plugin.feature import JacFeature as Jac
-
-        root = Jac.get_root().__jac__
-        ret_edges: list[NodeArchitype] = []
-        for anchor in self.edges:
-            if (
-                (source := anchor.source)
-                and (target := anchor.target)
-                and (not filter_func or filter_func([anchor.architype]))
-                and source.architype
-                and target.architype
-            ):
-                if (
-                    dir in [EdgeDir.OUT, EdgeDir.ANY]
-                    and self == source
-                    and (not target_obj or target.architype in target_obj)
-                    and root.has_read_access(target)
-                ):
-                    ret_edges.append(target.architype)
-                if (
-                    dir in [EdgeDir.IN, EdgeDir.ANY]
-                    and self == target
-                    and (not target_obj or source.architype in target_obj)
-                    and root.has_read_access(source)
-                ):
-                    ret_edges.append(source.architype)
-        return ret_edges
-
-    def remove_edge(self, edge: EdgeAnchor) -> None:
-        """Remove reference without checking sync status."""
-        for idx, ed in enumerate(self.edges):
-            if ed.id == edge.id:
-                self.edges.pop(idx)
-                break
-
-    def gen_dot(self, dot_file: Optional[str] = None) -> str:
-        """Generate Dot file for visualizing nodes and edges."""
-        visited_nodes: set[NodeAnchor] = set()
-        connections: set[tuple[NodeArchitype, NodeArchitype, str]] = set()
-        unique_node_id_dict = {}
-
-        collect_node_connections(self, visited_nodes, connections)
-        dot_content = 'digraph {\nnode [style="filled", shape="ellipse", fillcolor="invis", fontcolor="black"];\n'
-        for idx, i in enumerate([nodes_.architype for nodes_ in visited_nodes]):
-            unique_node_id_dict[i] = (i.__class__.__name__, str(idx))
-            dot_content += f'{idx} [label="{i}"];\n'
-        dot_content += 'edge [color="gray", style="solid"];\n'
-
-        for pair in list(set(connections)):
-            dot_content += (
-                f"{unique_node_id_dict[pair[0]][1]} -> {unique_node_id_dict[pair[1]][1]}"
-                f' [label="{pair[2]}"];\n'
-            )
-        if dot_file:
-            with open(dot_file, "w") as f:
-                f.write(dot_content + "}")
-        return dot_content + "}"
-
-    def spawn_call(self, walk: WalkerAnchor) -> WalkerArchitype:
-        """Invoke data spatial call."""
-        return walk.spawn_call(self)
-
-    def destroy(self) -> None:
-        """Destroy Anchor."""
-        from jaclang.plugin.feature import JacFeature as Jac
-
-        jctx = Jac.get_context()
-
-        if jctx.root.has_write_access(self):
-            for edge in self.edges:
-                edge.destroy()
-
-            jctx.mem.remove(self.id)
-
     def __getstate__(self) -> dict[str, object]:
         """Serialize Node Anchor."""
         state = super().__getstate__()
@@ -439,30 +198,6 @@ class EdgeAnchor(Anchor):
     target: NodeAnchor
     is_undirected: bool
 
-    def __post_init__(self) -> None:
-        """Populate edge to source and target."""
-        self.source.edges.append(self)
-        self.target.edges.append(self)
-
-    def detach(self) -> None:
-        """Detach edge from nodes."""
-        self.source.remove_edge(self)
-        self.target.remove_edge(self)
-
-    def spawn_call(self, walk: WalkerAnchor) -> WalkerArchitype:
-        """Invoke data spatial call."""
-        return walk.spawn_call(self.target)
-
-    def destroy(self) -> None:
-        """Destroy Anchor."""
-        from jaclang.plugin.feature import JacFeature as Jac
-
-        jctx = Jac.get_context()
-
-        if jctx.root.has_write_access(self):
-            self.detach()
-            jctx.mem.remove(self.id)
-
     def __getstate__(self) -> dict[str, object]:
         """Serialize Node Anchor."""
         state = super().__getstate__()
@@ -489,99 +224,6 @@ class WalkerAnchor(Anchor):
     ignores: list[Anchor] = field(default_factory=list)
     disengaged: bool = False
 
-    def visit_node(self, anchors: Iterable[NodeAnchor | EdgeAnchor]) -> bool:
-        """Walker visits node."""
-        before_len = len(self.next)
-        for anchor in anchors:
-            if anchor not in self.ignores:
-                if isinstance(anchor, NodeAnchor):
-                    self.next.append(anchor)
-                elif isinstance(anchor, EdgeAnchor):
-                    if target := anchor.target:
-                        self.next.append(target)
-                    else:
-                        raise ValueError("Edge has no target.")
-        return len(self.next) > before_len
-
-    def ignore_node(self, anchors: Iterable[NodeAnchor | EdgeAnchor]) -> bool:
-        """Walker ignores node."""
-        before_len = len(self.ignores)
-        for anchor in anchors:
-            if anchor not in self.ignores:
-                if isinstance(anchor, NodeAnchor):
-                    self.ignores.append(anchor)
-                elif isinstance(anchor, EdgeAnchor):
-                    if target := anchor.target:
-                        self.ignores.append(target)
-                    else:
-                        raise ValueError("Edge has no target.")
-        return len(self.ignores) > before_len
-
-    def disengage_now(self) -> None:
-        """Disengage walker from traversal."""
-        self.disengaged = True
-
-    def spawn_call(self, node: Anchor) -> WalkerArchitype:
-        """Invoke data spatial call."""
-        if walker := self.architype:
-            self.path = []
-            self.next = [node]
-            if self.next:
-                current_node = self.next[-1].architype
-                for i in walker._jac_entry_funcs_:
-                    if not i.trigger:
-                        if i.func:
-                            i.func(walker, current_node)
-                        else:
-                            raise ValueError(f"No function {i.name} to call.")
-            while len(self.next):
-                if current_node := self.next.pop(0).architype:
-                    for i in current_node._jac_entry_funcs_:
-                        if not i.trigger or isinstance(walker, i.trigger):
-                            if i.func:
-                                i.func(current_node, walker)
-                            else:
-                                raise ValueError(f"No function {i.name} to call.")
-                        if self.disengaged:
-                            return walker
-                    for i in walker._jac_entry_funcs_:
-                        if not i.trigger or isinstance(current_node, i.trigger):
-                            if i.func and i.trigger:
-                                i.func(walker, current_node)
-                            elif not i.trigger:
-                                continue
-                            else:
-                                raise ValueError(f"No function {i.name} to call.")
-                        if self.disengaged:
-                            return walker
-                    for i in walker._jac_exit_funcs_:
-                        if not i.trigger or isinstance(current_node, i.trigger):
-                            if i.func and i.trigger:
-                                i.func(walker, current_node)
-                            elif not i.trigger:
-                                continue
-                            else:
-                                raise ValueError(f"No function {i.name} to call.")
-                        if self.disengaged:
-                            return walker
-                    for i in current_node._jac_exit_funcs_:
-                        if not i.trigger or isinstance(walker, i.trigger):
-                            if i.func:
-                                i.func(current_node, walker)
-                            else:
-                                raise ValueError(f"No function {i.name} to call.")
-                        if self.disengaged:
-                            return walker
-            for i in walker._jac_exit_funcs_:
-                if not i.trigger:
-                    if i.func:
-                        i.func(walker, current_node)
-                    else:
-                        raise ValueError(f"No function {i.name} to call.")
-            self.ignores = []
-            return walker
-        raise Exception(f"Invalid Reference {self.id}")
-
 
 class Architype:
     """Architype Protocol."""
@@ -613,17 +255,6 @@ class EdgeArchitype(Architype):
 
     __jac__: EdgeAnchor
 
-    def __attach__(
-        self,
-        source: NodeAnchor,
-        target: NodeAnchor,
-        is_undirected: bool,
-    ) -> None:
-        """Attach EdgeAnchor properly."""
-        self.__jac__ = EdgeAnchor(
-            architype=self, source=source, target=target, is_undirected=is_undirected
-        )
-
 
 class WalkerArchitype(Architype):
     """Walker Architype Protocol."""
diff --git a/jac/jaclang/runtimelib/constructs.py b/jac/jaclang/runtimelib/constructs.py
index 655bd4bc00..b39b0abf0d 100644
--- a/jac/jaclang/runtimelib/constructs.py
+++ b/jac/jaclang/runtimelib/constructs.py
@@ -4,6 +4,7 @@
 
 
 from .architype import (
+    AccessLevel,
     Anchor,
     Architype,
     DSFunc,
@@ -21,6 +22,7 @@
 from .test import JacTestCheck, JacTestResult, JacTextTestRunner
 
 __all__ = [
+    "AccessLevel",
     "Anchor",
     "NodeAnchor",
     "EdgeAnchor",
diff --git a/jac/jaclang/runtimelib/context.py b/jac/jaclang/runtimelib/context.py
index 750ab83484..b300cb430a 100644
--- a/jac/jaclang/runtimelib/context.py
+++ b/jac/jaclang/runtimelib/context.py
@@ -42,10 +42,6 @@ def init_anchor(
             raise ValueError(f"Invalid anchor id {anchor_id} !")
         return default
 
-    def validate_access(self) -> bool:
-        """Validate access."""
-        return self.root.has_read_access(self.entry_node)
-
     def set_entry_node(self, entry_node: str | None) -> None:
         """Override entry."""
         self.entry_node = self.init_anchor(entry_node, self.root)
diff --git a/jac/jaclang/runtimelib/machine.py b/jac/jaclang/runtimelib/machine.py
index aace29097f..03e7283646 100644
--- a/jac/jaclang/runtimelib/machine.py
+++ b/jac/jaclang/runtimelib/machine.py
@@ -4,6 +4,7 @@
 import marshal
 import os
 import sys
+import tempfile
 import types
 from contextvars import ContextVar
 from typing import Optional, Union
@@ -111,6 +112,62 @@ def list_edges(self, module_name: str) -> list[str]:
             return nodes
         return []
 
+    def create_architype_from_source(
+        self,
+        source_code: str,
+        module_name: Optional[str] = None,
+        base_path: Optional[str] = None,
+        cachable: bool = False,
+        keep_temporary_files: bool = False,
+    ) -> Optional[types.ModuleType]:
+        """Dynamically creates architypes (nodes, walkers, etc.) from Jac source code."""
+        from jaclang.runtimelib.importer import JacImporter, ImportPathSpec
+
+        if not base_path:
+            base_path = self.base_path or os.getcwd()
+
+        if base_path and not os.path.exists(base_path):
+            os.makedirs(base_path)
+        if not module_name:
+            module_name = f"_dynamic_module_{len(self.loaded_modules)}"
+        with tempfile.NamedTemporaryFile(
+            mode="w",
+            suffix=".jac",
+            prefix=module_name + "_",
+            dir=base_path,
+            delete=False,
+        ) as tmp_file:
+            tmp_file_path = tmp_file.name
+            tmp_file.write(source_code)
+
+        try:
+            importer = JacImporter(self)
+            tmp_file_basename = os.path.basename(tmp_file_path)
+            tmp_module_name, _ = os.path.splitext(tmp_file_basename)
+
+            spec = ImportPathSpec(
+                target=tmp_module_name,
+                base_path=base_path,
+                absorb=False,
+                cachable=cachable,
+                mdl_alias=None,
+                override_name=module_name,
+                lng="jac",
+                items=None,
+            )
+
+            import_result = importer.run_import(spec, reload=False)
+            module = import_result.ret_mod
+
+            self.loaded_modules[module_name] = module
+            return module
+        except Exception as e:
+            logger.error(f"Error importing dynamic module '{module_name}': {e}")
+            return None
+        finally:
+            if not keep_temporary_files and os.path.exists(tmp_file_path):
+                os.remove(tmp_file_path)
+
     def update_walker(
         self, module_name: str, items: Optional[dict[str, Union[str, Optional[str]]]]
     ) -> tuple[types.ModuleType, ...]:
diff --git a/jac/jaclang/runtimelib/memory.py b/jac/jaclang/runtimelib/memory.py
index a65576468c..86773ed162 100644
--- a/jac/jaclang/runtimelib/memory.py
+++ b/jac/jaclang/runtimelib/memory.py
@@ -82,8 +82,6 @@ def close(self) -> None:
         if isinstance(self.__shelf__, Shelf):
             from jaclang.plugin.feature import JacFeature as Jac
 
-            root = Jac.get_root().__jac__
-
             for anchor in self.__gc__:
                 self.__shelf__.pop(str(anchor.id), None)
                 self.__mem__.pop(anchor.id, None)
@@ -96,14 +94,14 @@ def close(self) -> None:
                             isinstance(p_d, NodeAnchor)
                             and isinstance(d, NodeAnchor)
                             and p_d.edges != d.edges
-                            and root.has_connect_access(d)
+                            and Jac.check_connect_access(d)
                         ):
                             if not d.edges:
                                 self.__shelf__.pop(_id, None)
                                 continue
                             p_d.edges = d.edges
 
-                        if root.has_write_access(d):
+                        if Jac.check_write_access(d):
                             if hash(dumps(p_d.access)) != hash(dumps(d.access)):
                                 p_d.access = d.access
                             if hash(dumps(p_d.architype)) != hash(dumps(d.architype)):
diff --git a/jac/jaclang/settings.py b/jac/jaclang/settings.py
index e0be0e478d..3e3c14a04a 100644
--- a/jac/jaclang/settings.py
+++ b/jac/jaclang/settings.py
@@ -58,6 +58,9 @@ def load_env_vars(self) -> None:
         """Override settings from environment variables if available."""
         for key in [f.name for f in fields(self)]:
             env_value = os.getenv("JACLANG_" + key.upper())
+            env_value = (
+                env_value if env_value is not None else os.getenv("JAC_" + key.upper())
+            )
             if env_value is not None:
                 setattr(self, key, self.convert_type(env_value))
 
diff --git a/jac/pyproject.toml b/jac/pyproject.toml
index 8740ced155..6d3c29fd30 100644
--- a/jac/pyproject.toml
+++ b/jac/pyproject.toml
@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "jaclang"
-version = "0.7.22"
+version = "0.7.23"
 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/stubs/jaclang/__init__.pyi b/jac/stubs/jaclang/__init__.pyi
deleted file mode 100644
index ba25493b87..0000000000
--- a/jac/stubs/jaclang/__init__.pyi
+++ /dev/null
@@ -1,5 +0,0 @@
-from _typeshed import Incomplete
-
-__all__ = ["jac_import"]
-
-jac_import: Incomplete
diff --git a/jac/stubs/jaclang/cli/__init__.pyi b/jac/stubs/jaclang/cli/__init__.pyi
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/jac/stubs/jaclang/cli/cli.pyi b/jac/stubs/jaclang/cli/cli.pyi
deleted file mode 100644
index 8d660fb09a..0000000000
--- a/jac/stubs/jaclang/cli/cli.pyi
+++ /dev/null
@@ -1,58 +0,0 @@
-from jaclang import jac_import as jac_import
-from jaclang.cli.cmdreg import (
-    CommandShell as CommandShell,
-    cmd_registry as cmd_registry,
-)
-from jaclang.compiler.compile import jac_file_to_pass as jac_file_to_pass
-from jaclang.compiler.constant import Constants as Constants
-from jaclang.compiler.passes.main.pyast_load_pass import (
-    PyastBuildPass as PyastBuildPass,
-)
-from jaclang.compiler.passes.main.schedules import (
-    py_code_gen_typed as py_code_gen_typed,
-)
-from jaclang.compiler.passes.tool.schedules import format_pass as format_pass
-from jaclang.plugin.builtin import dotgen as dotgen
-from jaclang.runtimelib.constructs import Architype as Architype
-from jaclang.utils.lang_tools import AstTool as AstTool
-
-def format(path: str, outfile: str = "", debug: bool = False) -> None: ...
-def run(
-    filename: str,
-    session: str = "",
-    main: bool = True,
-    cache: bool = True,
-    walker: str = "",
-    node: str = "",
-) -> None: ...
-def get_object(id: str, session: str = "") -> dict: ...
-def build(filename: str) -> None: ...
-def check(filename: str, print_errs: bool = True) -> None: ...
-def lsp() -> None: ...
-def enter(filename: str, entrypoint: str, args: list) -> None: ...
-def test(
-    filepath: str,
-    filter: str = "",
-    xit: bool = False,
-    maxfail: int = None,
-    directory: str = "",
-    verbose: bool = False,
-) -> None: ...
-def tool(tool: str, args: list | None = None) -> None: ...
-def clean() -> None: ...
-def debug(filename: str, main: bool = True, cache: bool = False) -> None: ...
-def dot(
-    filename: str,
-    session: str = "",
-    initial: str = "",
-    depth: int = -1,
-    traverse: bool = False,
-    connection: list[str] = [],
-    bfs: bool = False,
-    edge_limit: int = 512,
-    node_limit: int = 512,
-    saveto: str = "",
-) -> None: ...
-def py2jac(filename: str) -> None: ...
-def jac2py(filename: str) -> None: ...
-def start_cli() -> None: ...
diff --git a/jac/stubs/jaclang/cli/cmdreg.pyi b/jac/stubs/jaclang/cli/cmdreg.pyi
deleted file mode 100644
index 349e509daa..0000000000
--- a/jac/stubs/jaclang/cli/cmdreg.pyi
+++ /dev/null
@@ -1,32 +0,0 @@
-import argparse
-import cmd
-import inspect
-from _typeshed import Incomplete
-from typing import Callable
-
-class Command:
-    func: Callable
-    sig: inspect.Signature
-    def __init__(self, func: Callable) -> None: ...
-    def call(self, *args: list, **kwargs: dict) -> str: ...
-
-class CommandRegistry:
-    registry: dict[str, Command]
-    sub_parsers: argparse._SubParsersAction
-    parser: argparse.ArgumentParser
-    args: argparse.Namespace
-    def __init__(self) -> None: ...
-    def register(self, func: Callable) -> Callable: ...
-    def get(self, name: str) -> Command | None: ...
-    def get_all_commands(self) -> dict: ...
-
-cmd_registry: Incomplete
-
-class CommandShell(cmd.Cmd):
-    intro: str
-    prompt: str
-    cmd_reg: CommandRegistry
-    def __init__(self, cmd_reg: CommandRegistry) -> None: ...
-    def do_exit(self, arg: list) -> bool: ...
-    def default(self, line: str) -> None: ...
-    def do_help(self, arg: str) -> None: ...
diff --git a/jac/stubs/jaclang/compiler/__init__.pyi b/jac/stubs/jaclang/compiler/__init__.pyi
deleted file mode 100644
index 4cccc4d122..0000000000
--- a/jac/stubs/jaclang/compiler/__init__.pyi
+++ /dev/null
@@ -1,6 +0,0 @@
-from _typeshed import Incomplete
-from jaclang.compiler.generated import jac_parser as jac_lark
-
-__all__ = ["jac_lark", "TOKEN_MAP"]
-
-TOKEN_MAP: Incomplete
diff --git a/jac/stubs/jaclang/compiler/absyntree.pyi b/jac/stubs/jaclang/compiler/absyntree.pyi
deleted file mode 100644
index cea6564bac..0000000000
--- a/jac/stubs/jaclang/compiler/absyntree.pyi
+++ /dev/null
@@ -1,1248 +0,0 @@
-import ast as ast3
-from _typeshed import Incomplete
-from jaclang.compiler import TOKEN_MAP as TOKEN_MAP
-from jaclang.compiler.codeloc import (
-    CodeGenTarget as CodeGenTarget,
-    CodeLocInfo as CodeLocInfo,
-)
-from jaclang.compiler.constant import (
-    DELIM_MAP as DELIM_MAP,
-    EdgeDir as EdgeDir,
-    JacSemTokenModifier as SemTokMod,
-    JacSemTokenType as SemTokType,
-    SymbolAccess as SymbolAccess,
-    SymbolType as SymbolType,
-    Tokens as Tok,
-)
-from jaclang.compiler.semtable import SemRegistry as SemRegistry
-from jaclang.compiler.symtable import Symbol as Symbol, SymbolTable as SymbolTable
-from jaclang.utils.treeprinter import (
-    dotgen_ast_tree as dotgen_ast_tree,
-    print_ast_tree as print_ast_tree,
-)
-from types import EllipsisType
-from typing import Any, Callable, Generic, Sequence, TypeVar
-
-class AstNode:
-    parent: Incomplete
-    kid: Incomplete
-    gen: Incomplete
-    meta: Incomplete
-    loc: Incomplete
-    def __init__(self, kid: Sequence[AstNode]) -> None: ...
-    @property
-    def sym_tab(self) -> SymbolTable: ...
-    @sym_tab.setter
-    def sym_tab(self, sym_tab: SymbolTable) -> None: ...
-    def add_kids_left(
-        self, nodes: Sequence[AstNode], pos_update: bool = True
-    ) -> AstNode: ...
-    def add_kids_right(
-        self, nodes: Sequence[AstNode], pos_update: bool = True
-    ) -> AstNode: ...
-    def insert_kids_at_pos(
-        self, nodes: Sequence[AstNode], pos: int, pos_update: bool = True
-    ) -> AstNode: ...
-    def set_kids(self, nodes: Sequence[AstNode]) -> AstNode: ...
-    def set_parent(self, parent: AstNode) -> AstNode: ...
-    def resolve_tok_range(self) -> tuple[Token, Token]: ...
-    def gen_token(self, name: Tok, value: str | None = None) -> Token: ...
-    def get_all_sub_nodes(self, typ: type[T], brute_force: bool = True) -> list[T]: ...
-    def find_parent_of_type(self, typ: type[T]) -> T | None: ...
-    def parent_of_type(self, typ: type[T]) -> T: ...
-    def format(self) -> str: ...
-    def to_dict(self) -> dict[str, str]: ...
-    def pp(self, depth: int | None = None) -> str: ...
-    def dotgen(self) -> str: ...
-    def flatten(self) -> list[AstNode]: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-    def unparse(self) -> str: ...
-
-class AstSymbolNode(AstNode):
-    name_spec: Incomplete
-    def __init__(
-        self, sym_name: str, name_spec: NameAtom, sym_category: SymbolType
-    ) -> None: ...
-    @property
-    def sym(self) -> Symbol | None: ...
-    @property
-    def sym_name(self) -> str: ...
-    @property
-    def sym_category(self) -> SymbolType: ...
-    @property
-    def py_ctx_func(self) -> type[ast3.AST]: ...
-    @property
-    def sym_type(self) -> str: ...
-    @property
-    def type_sym_tab(self) -> SymbolTable | None: ...
-
-class AstSymbolStubNode(AstSymbolNode):
-    def __init__(self, sym_type: SymbolType) -> None: ...
-
-class AstAccessNode(AstNode):
-    access: Incomplete
-    def __init__(self, access: SubTag[Token] | None) -> None: ...
-    @property
-    def access_type(self) -> SymbolAccess: ...
-
-T = TypeVar("T", bound=AstNode)
-
-class AstDocNode(AstNode):
-    doc: Incomplete
-    def __init__(self, doc: String | None) -> None: ...
-
-class AstSemStrNode(AstNode):
-    semstr: Incomplete
-    def __init__(self, semstr: String | None) -> None: ...
-
-class AstAsyncNode(AstNode):
-    is_async: Incomplete
-    def __init__(self, is_async: bool) -> None: ...
-
-class AstElseBodyNode(AstNode):
-    else_body: Incomplete
-    def __init__(self, else_body: ElseStmt | ElseIf | None) -> None: ...
-
-class AstTypedVarNode(AstNode):
-    type_tag: Incomplete
-    def __init__(self, type_tag: SubTag[Expr] | None) -> None: ...
-
-class WalkerStmtOnlyNode(AstNode):
-    from_walker: bool
-    def __init__(self) -> None: ...
-
-class Expr(AstNode): ...
-class AtomExpr(Expr, AstSymbolStubNode): ...
-class ElementStmt(AstDocNode): ...
-class ArchBlockStmt(AstNode): ...
-class EnumBlockStmt(AstNode): ...
-class CodeBlockStmt(AstNode): ...
-
-class AstImplOnlyNode(CodeBlockStmt, ElementStmt, AstSymbolNode):
-    target: Incomplete
-    body: Incomplete
-    decl_link: Incomplete
-    def __init__(
-        self, target: ArchRefChain, body: SubNodeList, decl_link: AstNode | None
-    ) -> None: ...
-    @property
-    def sym_tab(self) -> SymbolTable: ...
-    @sym_tab.setter
-    def sym_tab(self, sym_tab: SymbolTable) -> None: ...
-    def create_impl_name_node(self) -> Name: ...
-
-class AstImplNeedingNode(AstSymbolNode, Generic[T]):
-    body: Incomplete
-    def __init__(self, body: T | None) -> None: ...
-    @property
-    def needs_impl(self) -> bool: ...
-
-class NameAtom(AtomExpr, EnumBlockStmt):
-    name_of: Incomplete
-    def __init__(self) -> None: ...
-    @property
-    def sym(self) -> Symbol | None: ...
-    @sym.setter
-    def sym(self, sym: Symbol) -> None: ...
-    @property
-    def sym_name(self) -> str: ...
-    @property
-    def sym_category(self) -> SymbolType: ...
-    @property
-    def clean_type(self) -> str: ...
-    @property
-    def py_ctx_func(self) -> type[ast3.AST]: ...
-    @py_ctx_func.setter
-    def py_ctx_func(self, py_ctx_func: type[ast3.AST]) -> None: ...
-    @property
-    def sym_type(self) -> str: ...
-    @sym_type.setter
-    def sym_type(self, sym_type: str) -> None: ...
-    @property
-    def type_sym_tab(self) -> SymbolTable | None: ...
-    @type_sym_tab.setter
-    def type_sym_tab(self, type_sym_tab: SymbolTable) -> None: ...
-    @property
-    def sem_token(self) -> tuple[SemTokType, SemTokMod] | None: ...
-
-class ArchSpec(ElementStmt, CodeBlockStmt, AstSymbolNode, AstDocNode, AstSemStrNode):
-    decorators: Incomplete
-    def __init__(self, decorators: SubNodeList[Expr] | None = None) -> None: ...
-
-class MatchPattern(AstNode): ...
-
-class SubTag(AstNode, Generic[T]):
-    tag: Incomplete
-    def __init__(self, tag: T, kid: Sequence[AstNode]) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class SubNodeList(AstNode, Generic[T]):
-    items: Incomplete
-    delim: Incomplete
-    left_enc: Incomplete
-    right_enc: Incomplete
-    def __init__(
-        self,
-        items: list[T],
-        delim: Tok | None,
-        kid: Sequence[AstNode],
-        left_enc: Token | None = None,
-        right_enc: Token | None = None,
-    ) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class Module(AstDocNode):
-    name: Incomplete
-    source: Incomplete
-    body: Incomplete
-    is_imported: Incomplete
-    stub_only: Incomplete
-    impl_mod: Incomplete
-    test_mod: Incomplete
-    mod_deps: Incomplete
-    registry: Incomplete
-    terminals: Incomplete
-    def __init__(
-        self,
-        name: str,
-        source: JacSource,
-        doc: String | None,
-        body: Sequence[ElementStmt | String | EmptyToken],
-        is_imported: bool,
-        terminals: list[Token],
-        kid: Sequence[AstNode],
-        stub_only: bool = False,
-        registry: SemRegistry | None = None,
-    ) -> None: ...
-    @property
-    def annexable_by(self) -> str | None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-    def unparse(self) -> str: ...
-
-class GlobalVars(ElementStmt, AstAccessNode):
-    assignments: Incomplete
-    is_frozen: Incomplete
-    def __init__(
-        self,
-        access: SubTag[Token] | None,
-        assignments: SubNodeList[Assignment],
-        is_frozen: bool,
-        kid: Sequence[AstNode],
-        doc: String | None = None,
-    ) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class Test(AstSymbolNode, ElementStmt):
-    TEST_COUNT: int
-    name: Incomplete
-    body: Incomplete
-    def __init__(
-        self,
-        name: Name | Token,
-        body: SubNodeList[CodeBlockStmt],
-        kid: Sequence[AstNode],
-        doc: String | None = None,
-    ) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class ModuleCode(ElementStmt, ArchBlockStmt, EnumBlockStmt):
-    name: Incomplete
-    body: Incomplete
-    def __init__(
-        self,
-        name: SubTag[Name] | None,
-        body: SubNodeList[CodeBlockStmt],
-        kid: Sequence[AstNode],
-        doc: String | None = None,
-    ) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class PyInlineCode(ElementStmt, ArchBlockStmt, EnumBlockStmt, CodeBlockStmt):
-    code: Incomplete
-    def __init__(
-        self, code: Token, kid: Sequence[AstNode], doc: String | None = None
-    ) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class Import(ElementStmt, CodeBlockStmt):
-    hint: Incomplete
-    from_loc: Incomplete
-    items: Incomplete
-    is_absorb: Incomplete
-    def __init__(
-        self,
-        hint: SubTag[Name] | None,
-        from_loc: ModulePath | None,
-        items: SubNodeList[ModuleItem] | SubNodeList[ModulePath],
-        is_absorb: bool,
-        kid: Sequence[AstNode],
-        doc: String | None = None,
-    ) -> None: ...
-    @property
-    def is_py(self) -> bool: ...
-    @property
-    def is_jac(self) -> bool: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class ModulePath(AstSymbolNode):
-    path: Incomplete
-    level: Incomplete
-    alias: Incomplete
-    sub_module: Incomplete
-    def __init__(
-        self,
-        path: list[Name] | None,
-        level: int,
-        alias: Name | None,
-        kid: Sequence[AstNode],
-    ) -> None: ...
-    @property
-    def path_str(self) -> str: ...
-    def resolve_relative_path(self, target_item: str | None = None) -> str: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class ModuleItem(AstSymbolNode):
-    name: Incomplete
-    alias: Incomplete
-    sub_module: Incomplete
-    def __init__(
-        self, name: Name, alias: Name | None, kid: Sequence[AstNode]
-    ) -> None: ...
-    @property
-    def from_parent(self) -> Import: ...
-    @property
-    def from_mod_path(self) -> ModulePath: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class Architype(ArchSpec, AstAccessNode, ArchBlockStmt, AstImplNeedingNode):
-    name: Incomplete
-    arch_type: Incomplete
-    base_classes: Incomplete
-    def __init__(
-        self,
-        name: Name,
-        arch_type: Token,
-        access: SubTag[Token] | None,
-        base_classes: SubNodeList[Expr] | None,
-        body: SubNodeList[ArchBlockStmt] | ArchDef | None,
-        kid: Sequence[AstNode],
-        doc: String | None = None,
-        semstr: String | None = None,
-        decorators: SubNodeList[Expr] | None = None,
-    ) -> None: ...
-    @property
-    def is_abstract(self) -> bool: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class ArchDef(AstImplOnlyNode):
-    def __init__(
-        self,
-        target: ArchRefChain,
-        body: SubNodeList[ArchBlockStmt],
-        kid: Sequence[AstNode],
-        doc: String | None = None,
-        decl_link: Architype | None = None,
-    ) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class Enum(ArchSpec, AstAccessNode, AstImplNeedingNode, ArchBlockStmt):
-    name: Incomplete
-    base_classes: Incomplete
-    def __init__(
-        self,
-        name: Name,
-        access: SubTag[Token] | None,
-        base_classes: SubNodeList[Expr] | None,
-        body: SubNodeList[EnumBlockStmt] | EnumDef | None,
-        kid: Sequence[AstNode],
-        doc: String | None = None,
-        semstr: String | None = None,
-        decorators: SubNodeList[Expr] | None = None,
-    ) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class EnumDef(AstImplOnlyNode):
-    def __init__(
-        self,
-        target: ArchRefChain,
-        body: SubNodeList[EnumBlockStmt],
-        kid: Sequence[AstNode],
-        doc: String | None = None,
-        decorators: SubNodeList[Expr] | None = None,
-        decl_link: Enum | None = None,
-    ) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class Ability(
-    AstAccessNode,
-    ElementStmt,
-    AstAsyncNode,
-    ArchBlockStmt,
-    EnumBlockStmt,
-    CodeBlockStmt,
-    AstSemStrNode,
-    AstImplNeedingNode,
-):
-    name_ref: Incomplete
-    is_override: Incomplete
-    is_static: Incomplete
-    is_abstract: Incomplete
-    decorators: Incomplete
-    signature: Incomplete
-    def __init__(
-        self,
-        name_ref: NameAtom,
-        is_async: bool,
-        is_override: bool,
-        is_static: bool,
-        is_abstract: bool,
-        access: SubTag[Token] | None,
-        signature: FuncSignature | EventSignature,
-        body: SubNodeList[CodeBlockStmt] | AbilityDef | FuncCall | None,
-        kid: Sequence[AstNode],
-        semstr: String | None = None,
-        doc: String | None = None,
-        decorators: SubNodeList[Expr] | None = None,
-    ) -> None: ...
-    @property
-    def is_method(self) -> bool: ...
-    @property
-    def owner_method(self) -> Architype | Enum | None: ...
-    @property
-    def is_genai_ability(self) -> bool: ...
-    def py_resolve_name(self) -> str: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class AbilityDef(AstImplOnlyNode):
-    signature: Incomplete
-    decorators: Incomplete
-    def __init__(
-        self,
-        target: ArchRefChain,
-        signature: FuncSignature | EventSignature,
-        body: SubNodeList[CodeBlockStmt],
-        kid: Sequence[AstNode],
-        doc: String | None = None,
-        decorators: SubNodeList[Expr] | None = None,
-        decl_link: Ability | None = None,
-    ) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class FuncSignature(AstSemStrNode):
-    params: Incomplete
-    return_type: Incomplete
-    is_method: bool
-    def __init__(
-        self,
-        params: SubNodeList[ParamVar] | None,
-        return_type: Expr | None,
-        kid: Sequence[AstNode],
-        semstr: String | None = None,
-    ) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-    @property
-    def is_static(self) -> bool: ...
-
-class EventSignature(AstSemStrNode):
-    event: Incomplete
-    arch_tag_info: Incomplete
-    return_type: Incomplete
-    is_method: bool
-    def __init__(
-        self,
-        event: Token,
-        arch_tag_info: Expr | None,
-        return_type: Expr | None,
-        kid: Sequence[AstNode],
-        semstr: String | None = None,
-    ) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class ArchRefChain(AstNode):
-    archs: Incomplete
-    def __init__(self, archs: list[ArchRef], kid: Sequence[AstNode]) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-    def py_resolve_name(self) -> str: ...
-    def flat_name(self) -> str: ...
-
-class ParamVar(AstSymbolNode, AstTypedVarNode, AstSemStrNode):
-    name: Incomplete
-    unpack: Incomplete
-    value: Incomplete
-    def __init__(
-        self,
-        name: Name,
-        unpack: Token | None,
-        type_tag: SubTag[Expr],
-        value: Expr | None,
-        kid: Sequence[AstNode],
-        semstr: String | None = None,
-    ) -> None: ...
-    def normalize(self, deep: bool = True) -> bool: ...
-
-class ArchHas(AstAccessNode, AstDocNode, ArchBlockStmt):
-    is_static: Incomplete
-    vars: Incomplete
-    is_frozen: Incomplete
-    def __init__(
-        self,
-        is_static: bool,
-        access: SubTag[Token] | None,
-        vars: SubNodeList[HasVar],
-        is_frozen: bool,
-        kid: Sequence[AstNode],
-        doc: String | None = None,
-    ) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class HasVar(AstSymbolNode, AstTypedVarNode, AstSemStrNode):
-    name: Incomplete
-    value: Incomplete
-    defer: Incomplete
-    def __init__(
-        self,
-        name: Name,
-        type_tag: SubTag[Expr],
-        value: Expr | None,
-        defer: bool,
-        kid: Sequence[AstNode],
-        semstr: String | None = None,
-    ) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class TypedCtxBlock(CodeBlockStmt):
-    type_ctx: Incomplete
-    body: Incomplete
-    def __init__(
-        self, type_ctx: Expr, body: SubNodeList[CodeBlockStmt], kid: Sequence[AstNode]
-    ) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class IfStmt(CodeBlockStmt, AstElseBodyNode):
-    condition: Incomplete
-    body: Incomplete
-    def __init__(
-        self,
-        condition: Expr,
-        body: SubNodeList[CodeBlockStmt],
-        else_body: ElseStmt | ElseIf | None,
-        kid: Sequence[AstNode],
-    ) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class ElseIf(IfStmt):
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class ElseStmt(AstNode):
-    body: Incomplete
-    def __init__(
-        self, body: SubNodeList[CodeBlockStmt], kid: Sequence[AstNode]
-    ) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class ExprStmt(CodeBlockStmt):
-    expr: Incomplete
-    in_fstring: Incomplete
-    def __init__(
-        self, expr: Expr, in_fstring: bool, kid: Sequence[AstNode]
-    ) -> None: ...
-    def normalize(self, deep: bool = True) -> bool: ...
-
-class TryStmt(AstElseBodyNode, CodeBlockStmt):
-    body: Incomplete
-    excepts: Incomplete
-    finally_body: Incomplete
-    def __init__(
-        self,
-        body: SubNodeList[CodeBlockStmt],
-        excepts: SubNodeList[Except] | None,
-        else_body: ElseStmt | None,
-        finally_body: FinallyStmt | None,
-        kid: Sequence[AstNode],
-    ) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class Except(CodeBlockStmt):
-    ex_type: Incomplete
-    name: Incomplete
-    body: Incomplete
-    def __init__(
-        self,
-        ex_type: Expr,
-        name: Name | None,
-        body: SubNodeList[CodeBlockStmt],
-        kid: Sequence[AstNode],
-    ) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class FinallyStmt(CodeBlockStmt):
-    body: Incomplete
-    def __init__(
-        self, body: SubNodeList[CodeBlockStmt], kid: Sequence[AstNode]
-    ) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class IterForStmt(AstAsyncNode, AstElseBodyNode, CodeBlockStmt):
-    iter: Incomplete
-    condition: Incomplete
-    count_by: Incomplete
-    body: Incomplete
-    def __init__(
-        self,
-        iter: Assignment,
-        is_async: bool,
-        condition: Expr,
-        count_by: Assignment,
-        body: SubNodeList[CodeBlockStmt],
-        else_body: ElseStmt | None,
-        kid: Sequence[AstNode],
-    ) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class InForStmt(AstAsyncNode, AstElseBodyNode, CodeBlockStmt):
-    target: Incomplete
-    collection: Incomplete
-    body: Incomplete
-    def __init__(
-        self,
-        target: Expr,
-        is_async: bool,
-        collection: Expr,
-        body: SubNodeList[CodeBlockStmt],
-        else_body: ElseStmt | None,
-        kid: Sequence[AstNode],
-    ) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class WhileStmt(CodeBlockStmt):
-    condition: Incomplete
-    body: Incomplete
-    def __init__(
-        self, condition: Expr, body: SubNodeList[CodeBlockStmt], kid: Sequence[AstNode]
-    ) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class WithStmt(AstAsyncNode, CodeBlockStmt):
-    exprs: Incomplete
-    body: Incomplete
-    def __init__(
-        self,
-        is_async: bool,
-        exprs: SubNodeList[ExprAsItem],
-        body: SubNodeList[CodeBlockStmt],
-        kid: Sequence[AstNode],
-    ) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class ExprAsItem(AstNode):
-    expr: Incomplete
-    alias: Incomplete
-    def __init__(
-        self, expr: Expr, alias: Expr | None, kid: Sequence[AstNode]
-    ) -> None: ...
-    def normalize(self, deep: bool = True) -> bool: ...
-
-class RaiseStmt(CodeBlockStmt):
-    cause: Incomplete
-    from_target: Incomplete
-    def __init__(
-        self, cause: Expr | None, from_target: Expr | None, kid: Sequence[AstNode]
-    ) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class AssertStmt(CodeBlockStmt):
-    condition: Incomplete
-    error_msg: Incomplete
-    def __init__(
-        self, condition: Expr, error_msg: Expr | None, kid: Sequence[AstNode]
-    ) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class CheckStmt(CodeBlockStmt):
-    target: Incomplete
-    def __init__(self, target: Expr, kid: Sequence[AstNode]) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class CtrlStmt(CodeBlockStmt):
-    ctrl: Incomplete
-    def __init__(self, ctrl: Token, kid: Sequence[AstNode]) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class DeleteStmt(CodeBlockStmt):
-    target: Incomplete
-    def __init__(self, target: Expr, kid: Sequence[AstNode]) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class ReportStmt(CodeBlockStmt):
-    expr: Incomplete
-    def __init__(self, expr: Expr, kid: Sequence[AstNode]) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class ReturnStmt(CodeBlockStmt):
-    expr: Incomplete
-    def __init__(self, expr: Expr | None, kid: Sequence[AstNode]) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class IgnoreStmt(WalkerStmtOnlyNode, CodeBlockStmt):
-    target: Incomplete
-    def __init__(self, target: Expr, kid: Sequence[AstNode]) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class VisitStmt(WalkerStmtOnlyNode, AstElseBodyNode, CodeBlockStmt):
-    vis_type: Incomplete
-    target: Incomplete
-    def __init__(
-        self,
-        vis_type: SubNodeList[Expr] | None,
-        target: Expr,
-        else_body: ElseStmt | None,
-        kid: Sequence[AstNode],
-    ) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class RevisitStmt(WalkerStmtOnlyNode, AstElseBodyNode, CodeBlockStmt):
-    hops: Incomplete
-    def __init__(
-        self, hops: Expr | None, else_body: ElseStmt | None, kid: Sequence[AstNode]
-    ) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class DisengageStmt(WalkerStmtOnlyNode, CodeBlockStmt):
-    def __init__(self, kid: Sequence[AstNode]) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class AwaitExpr(Expr):
-    target: Incomplete
-    def __init__(self, target: Expr, kid: Sequence[AstNode]) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class GlobalStmt(CodeBlockStmt):
-    target: Incomplete
-    def __init__(
-        self, target: SubNodeList[NameAtom], kid: Sequence[AstNode]
-    ) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class NonLocalStmt(GlobalStmt):
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class Assignment(AstSemStrNode, AstTypedVarNode, EnumBlockStmt, CodeBlockStmt):
-    target: Incomplete
-    value: Incomplete
-    mutable: Incomplete
-    aug_op: Incomplete
-    is_enum_stmt: Incomplete
-    def __init__(
-        self,
-        target: SubNodeList[Expr],
-        value: Expr | YieldExpr | None,
-        type_tag: SubTag[Expr] | None,
-        kid: Sequence[AstNode],
-        mutable: bool = True,
-        aug_op: Token | None = None,
-        semstr: String | None = None,
-        is_enum_stmt: bool = False,
-    ) -> None: ...
-    def normalize(self, deep: bool = True) -> bool: ...
-
-class BinaryExpr(Expr):
-    left: Incomplete
-    right: Incomplete
-    op: Incomplete
-    def __init__(
-        self,
-        left: Expr,
-        right: Expr,
-        op: Token | DisconnectOp | ConnectOp,
-        kid: Sequence[AstNode],
-    ) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class CompareExpr(Expr):
-    left: Incomplete
-    rights: Incomplete
-    ops: Incomplete
-    def __init__(
-        self, left: Expr, rights: list[Expr], ops: list[Token], kid: Sequence[AstNode]
-    ) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class BoolExpr(Expr):
-    values: Incomplete
-    op: Incomplete
-    def __init__(
-        self, op: Token, values: list[Expr], kid: Sequence[AstNode]
-    ) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class LambdaExpr(Expr):
-    signature: Incomplete
-    body: Incomplete
-    def __init__(
-        self, body: Expr, kid: Sequence[AstNode], signature: FuncSignature | None = None
-    ) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class UnaryExpr(Expr):
-    operand: Incomplete
-    op: Incomplete
-    def __init__(self, operand: Expr, op: Token, kid: Sequence[AstNode]) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class IfElseExpr(Expr):
-    condition: Incomplete
-    value: Incomplete
-    else_value: Incomplete
-    def __init__(
-        self, condition: Expr, value: Expr, else_value: Expr, kid: Sequence[AstNode]
-    ) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class MultiString(AtomExpr):
-    strings: Incomplete
-    def __init__(
-        self, strings: Sequence[String | FString], kid: Sequence[AstNode]
-    ) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class FString(AtomExpr):
-    parts: Incomplete
-    def __init__(
-        self, parts: SubNodeList[String | ExprStmt] | None, kid: Sequence[AstNode]
-    ) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class ListVal(AtomExpr):
-    values: Incomplete
-    def __init__(
-        self, values: SubNodeList[Expr] | None, kid: Sequence[AstNode]
-    ) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class SetVal(AtomExpr):
-    values: Incomplete
-    def __init__(
-        self, values: SubNodeList[Expr] | None, kid: Sequence[AstNode]
-    ) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class TupleVal(AtomExpr):
-    values: Incomplete
-    def __init__(
-        self, values: SubNodeList[Expr | KWPair] | None, kid: Sequence[AstNode]
-    ) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class DictVal(AtomExpr):
-    kv_pairs: Incomplete
-    def __init__(self, kv_pairs: Sequence[KVPair], kid: Sequence[AstNode]) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class KVPair(AstNode):
-    key: Incomplete
-    value: Incomplete
-    def __init__(
-        self, key: Expr | None, value: Expr, kid: Sequence[AstNode]
-    ) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class KWPair(AstNode):
-    key: Incomplete
-    value: Incomplete
-    def __init__(
-        self, key: NameAtom | None, value: Expr, kid: Sequence[AstNode]
-    ) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class InnerCompr(AstAsyncNode):
-    target: Incomplete
-    collection: Incomplete
-    conditional: Incomplete
-    def __init__(
-        self,
-        is_async: bool,
-        target: Expr,
-        collection: Expr,
-        conditional: list[Expr] | None,
-        kid: Sequence[AstNode],
-    ) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class ListCompr(AtomExpr):
-    out_expr: Incomplete
-    compr: Incomplete
-    def __init__(
-        self, out_expr: Expr, compr: list[InnerCompr], kid: Sequence[AstNode]
-    ) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class GenCompr(ListCompr):
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class SetCompr(ListCompr):
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class DictCompr(AtomExpr):
-    kv_pair: Incomplete
-    compr: Incomplete
-    def __init__(
-        self, kv_pair: KVPair, compr: list[InnerCompr], kid: Sequence[AstNode]
-    ) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class AtomTrailer(Expr):
-    target: Incomplete
-    right: Incomplete
-    is_attr: Incomplete
-    is_null_ok: Incomplete
-    is_genai: Incomplete
-    def __init__(
-        self,
-        target: Expr,
-        right: AtomExpr | Expr,
-        is_attr: bool,
-        is_null_ok: bool,
-        kid: Sequence[AstNode],
-        is_genai: bool = False,
-    ) -> None: ...
-    def normalize(self, deep: bool = True) -> bool: ...
-    @property
-    def as_attr_list(self) -> list[AstSymbolNode]: ...
-
-class AtomUnit(Expr):
-    value: Incomplete
-    def __init__(self, value: Expr | YieldExpr, kid: Sequence[AstNode]) -> None: ...
-    def normalize(self, deep: bool = True) -> bool: ...
-
-class YieldExpr(Expr):
-    expr: Incomplete
-    with_from: Incomplete
-    def __init__(
-        self, expr: Expr | None, with_from: bool, kid: Sequence[AstNode]
-    ) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class FuncCall(Expr):
-    target: Incomplete
-    params: Incomplete
-    genai_call: Incomplete
-    def __init__(
-        self,
-        target: Expr,
-        params: SubNodeList[Expr | KWPair] | None,
-        genai_call: FuncCall | None,
-        kid: Sequence[AstNode],
-    ) -> None: ...
-    def normalize(self, deep: bool = True) -> bool: ...
-
-class IndexSlice(AtomExpr):
-    start: Incomplete
-    stop: Incomplete
-    step: Incomplete
-    is_range: Incomplete
-    def __init__(
-        self,
-        start: Expr | None,
-        stop: Expr | None,
-        step: Expr | None,
-        is_range: bool,
-        kid: Sequence[AstNode],
-    ) -> None: ...
-    def normalize(self, deep: bool = True) -> bool: ...
-
-class ArchRef(AtomExpr):
-    arch_name: Incomplete
-    arch_type: Incomplete
-    def __init__(
-        self, arch_name: NameAtom, arch_type: Token, kid: Sequence[AstNode]
-    ) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class EdgeRefTrailer(Expr):
-    chain: Incomplete
-    edges_only: Incomplete
-    def __init__(
-        self, chain: list[Expr | FilterCompr], edges_only: bool, kid: Sequence[AstNode]
-    ) -> None: ...
-    def normalize(self, deep: bool = True) -> bool: ...
-
-class EdgeOpRef(WalkerStmtOnlyNode, AtomExpr):
-    filter_cond: Incomplete
-    edge_dir: Incomplete
-    def __init__(
-        self, filter_cond: FilterCompr | None, edge_dir: EdgeDir, kid: Sequence[AstNode]
-    ) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class DisconnectOp(WalkerStmtOnlyNode):
-    edge_spec: Incomplete
-    def __init__(self, edge_spec: EdgeOpRef, kid: Sequence[AstNode]) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class ConnectOp(AstNode):
-    conn_type: Incomplete
-    conn_assign: Incomplete
-    edge_dir: Incomplete
-    def __init__(
-        self,
-        conn_type: Expr | None,
-        conn_assign: AssignCompr | None,
-        edge_dir: EdgeDir,
-        kid: Sequence[AstNode],
-    ) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class FilterCompr(AtomExpr):
-    f_type: Incomplete
-    compares: Incomplete
-    def __init__(
-        self,
-        f_type: Expr | None,
-        compares: SubNodeList[CompareExpr] | None,
-        kid: Sequence[AstNode],
-    ) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class AssignCompr(AtomExpr):
-    assigns: Incomplete
-    def __init__(
-        self, assigns: SubNodeList[KWPair], kid: Sequence[AstNode]
-    ) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class MatchStmt(CodeBlockStmt):
-    target: Incomplete
-    cases: Incomplete
-    def __init__(
-        self, target: Expr, cases: list[MatchCase], kid: Sequence[AstNode]
-    ) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class MatchCase(AstNode):
-    pattern: Incomplete
-    guard: Incomplete
-    body: Incomplete
-    def __init__(
-        self,
-        pattern: MatchPattern,
-        guard: Expr | None,
-        body: list[CodeBlockStmt],
-        kid: Sequence[AstNode],
-    ) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class MatchOr(MatchPattern):
-    patterns: Incomplete
-    def __init__(
-        self, patterns: list[MatchPattern], kid: Sequence[AstNode]
-    ) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class MatchAs(MatchPattern):
-    name: Incomplete
-    pattern: Incomplete
-    def __init__(
-        self, name: NameAtom, pattern: MatchPattern | None, kid: Sequence[AstNode]
-    ) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class MatchWild(MatchPattern):
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class MatchValue(MatchPattern):
-    value: Incomplete
-    def __init__(self, value: Expr, kid: Sequence[AstNode]) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class MatchSingleton(MatchPattern):
-    value: Incomplete
-    def __init__(self, value: Bool | Null, kid: Sequence[AstNode]) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class MatchSequence(MatchPattern):
-    values: Incomplete
-    def __init__(self, values: list[MatchPattern], kid: Sequence[AstNode]) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class MatchMapping(MatchPattern):
-    values: Incomplete
-    def __init__(
-        self, values: list[MatchKVPair | MatchStar], kid: Sequence[AstNode]
-    ) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class MatchKVPair(MatchPattern):
-    key: Incomplete
-    value: Incomplete
-    def __init__(
-        self, key: MatchPattern | NameAtom, value: MatchPattern, kid: Sequence[AstNode]
-    ) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class MatchStar(MatchPattern):
-    name: Incomplete
-    is_list: Incomplete
-    def __init__(
-        self, name: NameAtom, is_list: bool, kid: Sequence[AstNode]
-    ) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class MatchArch(MatchPattern):
-    name: Incomplete
-    arg_patterns: Incomplete
-    kw_patterns: Incomplete
-    def __init__(
-        self,
-        name: AtomTrailer | NameAtom,
-        arg_patterns: SubNodeList[MatchPattern] | None,
-        kw_patterns: SubNodeList[MatchKVPair] | None,
-        kid: Sequence[AstNode],
-    ) -> None: ...
-    def normalize(self, deep: bool = False) -> bool: ...
-
-class Token(AstNode):
-    file_path: Incomplete
-    name: Incomplete
-    value: Incomplete
-    line_no: Incomplete
-    end_line: Incomplete
-    c_start: Incomplete
-    c_end: Incomplete
-    pos_start: Incomplete
-    pos_end: Incomplete
-    def __init__(
-        self,
-        file_path: str,
-        name: str,
-        value: str,
-        line: int,
-        end_line: int,
-        col_start: int,
-        col_end: int,
-        pos_start: int,
-        pos_end: int,
-    ) -> None: ...
-    def normalize(self, deep: bool = True) -> bool: ...
-    def unparse(self) -> str: ...
-
-class Name(Token, NameAtom):
-    is_enum_singleton: Incomplete
-    is_kwesc: Incomplete
-    def __init__(
-        self,
-        file_path: str,
-        name: str,
-        value: str,
-        line: int,
-        end_line: int,
-        col_start: int,
-        col_end: int,
-        pos_start: int,
-        pos_end: int,
-        is_enum_singleton: bool = False,
-        is_kwesc: bool = False,
-    ) -> None: ...
-    def unparse(self) -> str: ...
-    @staticmethod
-    def gen_stub_from_node(
-        node: AstSymbolNode, name_str: str, set_name_of: AstSymbolNode | None = None
-    ) -> Name: ...
-
-class SpecialVarRef(Name):
-    orig: Incomplete
-    def __init__(self, var: Name) -> None: ...
-    def py_resolve_name(self) -> str: ...
-
-class Literal(Token, AtomExpr):
-    SYMBOL_TYPE: Incomplete
-    type_map: Incomplete
-    def __init__(
-        self,
-        file_path: str,
-        name: str,
-        value: str,
-        line: int,
-        end_line: int,
-        col_start: int,
-        col_end: int,
-        pos_start: int,
-        pos_end: int,
-    ) -> None: ...
-    @property
-    def lit_value(
-        self,
-    ) -> int | str | float | bool | None | Callable[[], Any] | EllipsisType: ...
-
-class BuiltinType(Name, Literal, NameAtom):
-    SYMBOL_TYPE: Incomplete
-    @property
-    def lit_value(self) -> Callable[[], Any]: ...
-
-class Float(Literal):
-    SYMBOL_TYPE: Incomplete
-    @property
-    def lit_value(self) -> float: ...
-
-class Int(Literal):
-    SYMBOL_TYPE: Incomplete
-    @property
-    def lit_value(self) -> int: ...
-
-class String(Literal):
-    SYMBOL_TYPE: Incomplete
-    @property
-    def lit_value(self) -> str: ...
-    value: Incomplete
-    def normalize(self, deep: bool = True) -> bool: ...
-    def unparse(self) -> str: ...
-
-class Bool(Literal):
-    SYMBOL_TYPE: Incomplete
-    @property
-    def lit_value(self) -> bool: ...
-
-class Null(Literal):
-    SYMBOL_TYPE: Incomplete
-    @property
-    def lit_value(self) -> None: ...
-
-class Ellipsis(Literal):
-    SYMBOL_TYPE: Incomplete
-    @property
-    def lit_value(self) -> EllipsisType: ...
-
-class EmptyToken(Token):
-    def __init__(self) -> None: ...
-
-class Semi(Token, CodeBlockStmt): ...
-
-class CommentToken(Token):
-    is_inline: Incomplete
-    def __init__(
-        self,
-        file_path: str,
-        name: str,
-        value: str,
-        line: int,
-        end_line: int,
-        col_start: int,
-        col_end: int,
-        pos_start: int,
-        pos_end: int,
-        kid: Sequence[AstNode],
-        is_inline: bool = False,
-    ) -> None: ...
-
-class JacSource(EmptyToken):
-    value: Incomplete
-    hash: Incomplete
-    file_path: Incomplete
-    comments: Incomplete
-    def __init__(self, source: str, mod_path: str) -> None: ...
-    @property
-    def code(self) -> str: ...
-
-class PythonModuleAst(EmptyToken):
-    ast: Incomplete
-    file_path: Incomplete
-    def __init__(self, ast: ast3.Module, mod_path: str) -> None: ...
diff --git a/jac/stubs/jaclang/compiler/codeloc.pyi b/jac/stubs/jaclang/compiler/codeloc.pyi
deleted file mode 100644
index 625dd0936e..0000000000
--- a/jac/stubs/jaclang/compiler/codeloc.pyi
+++ /dev/null
@@ -1,45 +0,0 @@
-import ast as ast3
-from _typeshed import Incomplete
-from dataclasses import dataclass
-from jaclang.compiler.absyntree import Token as Token
-from jaclang.vendor.mypy.nodes import Node as MypyNode
-
-@dataclass
-class CodeGenTarget:
-    py: str = ...
-    jac: str = ...
-    py_ast: list[ast3.AST] = ...
-    mypy_ast: list[MypyNode] = ...
-    py_bytecode: bytes | None = ...
-    def clean(self) -> None: ...
-    def __init__(
-        self, py=..., jac=..., py_ast=..., mypy_ast=..., py_bytecode=...
-    ) -> None: ...
-
-class CodeLocInfo:
-    first_tok: Incomplete
-    last_tok: Incomplete
-    def __init__(self, first_tok: Token, last_tok: Token) -> None: ...
-    @property
-    def mod_path(self) -> str: ...
-    @property
-    def first_line(self) -> int: ...
-    @property
-    def last_line(self) -> int: ...
-    @property
-    def col_start(self) -> int: ...
-    @property
-    def col_end(self) -> int: ...
-    @property
-    def pos_start(self) -> int: ...
-    @property
-    def pos_end(self) -> int: ...
-    @property
-    def tok_range(self) -> tuple[Token, Token]: ...
-    @property
-    def first_token(self) -> Token: ...
-    @property
-    def last_token(self) -> Token: ...
-    def update_token_range(self, first_tok: Token, last_tok: Token) -> None: ...
-    def update_first_token(self, first_tok: Token) -> None: ...
-    def update_last_token(self, last_tok: Token) -> None: ...
diff --git a/jac/stubs/jaclang/compiler/compile.pyi b/jac/stubs/jaclang/compiler/compile.pyi
deleted file mode 100644
index c595b15a70..0000000000
--- a/jac/stubs/jaclang/compiler/compile.pyi
+++ /dev/null
@@ -1,29 +0,0 @@
-import jaclang.compiler.absyntree as ast
-from jaclang.compiler.parser import JacParser as JacParser
-from jaclang.compiler.passes import Pass as Pass
-from jaclang.compiler.passes.main import (
-    PyOutPass as PyOutPass,
-    pass_schedule as pass_schedule,
-)
-from jaclang.compiler.passes.tool import JacFormatPass as JacFormatPass
-from jaclang.compiler.passes.tool.schedules import format_pass as format_pass
-
-def compile_jac(file_path: str, cache_result: bool = False) -> Pass: ...
-def jac_file_to_pass(
-    file_path: str, target: type[Pass] | None = None, schedule: list[type[Pass]] = ...
-) -> Pass: ...
-def jac_str_to_pass(
-    jac_str: str,
-    file_path: str,
-    target: type[Pass] | None = None,
-    schedule: list[type[Pass]] = ...,
-) -> Pass: ...
-def jac_ir_to_pass(
-    ir: ast.AstNode, target: type[Pass] | None = None, schedule: list[type[Pass]] = ...
-) -> Pass: ...
-def jac_pass_to_pass(
-    in_pass: Pass, target: type[Pass] | None = None, schedule: list[type[Pass]] = ...
-) -> Pass: ...
-def jac_file_formatter(
-    file_path: str, schedule: list[type[Pass]] = ...
-) -> JacFormatPass: ...
diff --git a/jac/stubs/jaclang/compiler/constant.pyi b/jac/stubs/jaclang/compiler/constant.pyi
deleted file mode 100644
index 912d225397..0000000000
--- a/jac/stubs/jaclang/compiler/constant.pyi
+++ /dev/null
@@ -1,287 +0,0 @@
-from _typeshed import Incomplete
-from enum import Enum, IntEnum, IntFlag, StrEnum
-
-class SymbolType(Enum):
-    MODULE: str
-    MOD_VAR: str
-    VAR: str
-    IMM_VAR: str
-    ABILITY: str
-    OBJECT_ARCH: str
-    NODE_ARCH: str
-    EDGE_ARCH: str
-    WALKER_ARCH: str
-    ENUM_ARCH: str
-    TEST: str
-    TYPE: str
-    IMPL: str
-    HAS_VAR: str
-    METHOD: str
-    CONSTRUCTOR: str
-    ENUM_MEMBER: str
-    NUMBER: str
-    STRING: str
-    BOOL: str
-    SEQUENCE: str
-    NULL: str
-    UNKNOWN: str
-
-class JacSemTokenType(IntEnum):
-    NAMESPACE: int
-    TYPE: int
-    CLASS: int
-    ENUM: int
-    INTERFACE: int
-    STRUCT: int
-    TYPE_PARAMETER: int
-    PARAMETER: int
-    VARIABLE: int
-    PROPERTY: int
-    ENUM_MEMBER: int
-    EVENT: int
-    FUNCTION: int
-    METHOD: int
-    MACRO: int
-    KEYWORD: int
-    MODIFIER: int
-    COMMENT: int
-    STRING: int
-    NUMBER: int
-    REGEXP: int
-    OPERATOR: int
-    @staticmethod
-    def as_str_list() -> list[str]: ...
-
-class JacSemTokenModifier(IntFlag):
-    DECLARATION: Incomplete
-    DEFINITION: Incomplete
-    READONLY: Incomplete
-    STATIC: Incomplete
-    DEPRECATED: Incomplete
-    ABSTRACT: Incomplete
-    ASYNC: Incomplete
-    MODIFICATION: Incomplete
-    DOCUMENTATION: Incomplete
-    DEFAULT_LIBRARY: Incomplete
-    @staticmethod
-    def as_str_list() -> list[str]: ...
-
-class Constants(StrEnum):
-    JAC_LANG_IMP: str
-    HERE: str
-    JAC_FEATURE: str
-    ROOT: Incomplete
-    EDGES_TO_NODE: str
-    EDGE_REF: str
-    CONNECT_NODE: str
-    DISCONNECT_NODE: str
-    WALKER_VISIT: str
-    WALKER_IGNORE: str
-    DISENGAGE: str
-    OBJECT_CLASS: str
-    NODE_CLASS: str
-    EDGE_CLASS: str
-    WALKER_CLASS: str
-    WITH_DIR: str
-    EDGE_DIR: str
-    ON_ENTRY: str
-    ON_EXIT: str
-    PYNLINE: str
-    JAC_GEN_DIR: str
-    JAC_MYPY_CACHE: str
-
-class EdgeDir(Enum):
-    IN: int
-    OUT: int
-    ANY: int
-
-class Values(int, Enum):
-    JAC_ERROR_LINE_RANGE: int
-
-class SymbolAccess(Enum):
-    PRIVATE: str
-    PUBLIC: str
-    PROTECTED: str
-
-class Tokens(str, Enum):
-    FLOAT: str
-    STRING: str
-    DOC_STRING: str
-    PYNLINE: str
-    BOOL: str
-    INT: str
-    HEX: str
-    BIN: str
-    OCT: str
-    NULL: str
-    NAME: str
-    KWESC_NAME: str
-    TYP_STRING: str
-    TYP_INT: str
-    TYP_FLOAT: str
-    TYP_LIST: str
-    TYP_TUPLE: str
-    TYP_SET: str
-    TYP_DICT: str
-    TYP_BOOL: str
-    TYP_BYTES: str
-    TYP_ANY: str
-    TYP_TYPE: str
-    KW_LET: str
-    KW_ABSTRACT: str
-    KW_OBJECT: str
-    KW_CLASS: str
-    KW_ENUM: str
-    KW_NODE: str
-    KW_IGNORE: str
-    KW_VISIT: str
-    KW_REVISIT: str
-    KW_SPAWN: str
-    KW_WITH: str
-    KW_ENTRY: str
-    KW_EXIT: str
-    KW_IMPORT: str
-    KW_INCLUDE: str
-    KW_FROM: str
-    KW_AS: str
-    KW_EDGE: str
-    KW_WALKER: str
-    KW_ASYNC: str
-    KW_AWAIT: str
-    KW_TEST: str
-    KW_ASSERT: str
-    KW_CHECK: str
-    COLON: str
-    PIPE_FWD: str
-    PIPE_BKWD: str
-    DOT_FWD: str
-    DOT_BKWD: str
-    LBRACE: str
-    RBRACE: str
-    SEMI: str
-    EQ: str
-    ADD_EQ: str
-    SUB_EQ: str
-    MUL_EQ: str
-    STAR_POW_EQ: str
-    FLOOR_DIV_EQ: str
-    DIV_EQ: str
-    MOD_EQ: str
-    BW_AND_EQ: str
-    BW_OR_EQ: str
-    BW_XOR_EQ: str
-    BW_NOT_EQ: str
-    LSHIFT_EQ: str
-    RSHIFT_EQ: str
-    WALRUS_EQ: str
-    MATMUL_EQ: str
-    KW_AND: str
-    KW_OR: str
-    KW_IF: str
-    KW_ELIF: str
-    KW_ELSE: str
-    KW_FOR: str
-    KW_TO: str
-    KW_BY: str
-    KW_WHILE: str
-    KW_CONTINUE: str
-    KW_BREAK: str
-    KW_DISENGAGE: str
-    KW_YIELD: str
-    KW_SKIP: str
-    KW_REPORT: str
-    KW_RETURN: str
-    KW_DELETE: str
-    KW_TRY: str
-    KW_EXCEPT: str
-    KW_FINALLY: str
-    KW_RAISE: str
-    ELLIPSIS: str
-    DOT: str
-    NOT: str
-    EE: str
-    LT: str
-    GT: str
-    LTE: str
-    GTE: str
-    NE: str
-    KW_IN: str
-    KW_IS: str
-    KW_NIN: str
-    KW_ISN: str
-    KW_PRIV: str
-    KW_PUB: str
-    KW_PROT: str
-    KW_HAS: str
-    KW_GLOBAL: str
-    COMMA: str
-    KW_CAN: str
-    KW_STATIC: str
-    KW_OVERRIDE: str
-    KW_MATCH: str
-    KW_CASE: str
-    PLUS: str
-    MINUS: str
-    STAR_MUL: str
-    FLOOR_DIV: str
-    DIV: str
-    MOD: str
-    BW_AND: str
-    BW_OR: str
-    BW_XOR: str
-    BW_NOT: str
-    LSHIFT: str
-    RSHIFT: str
-    STAR_POW: str
-    LPAREN: str
-    RPAREN: str
-    LSQUARE: str
-    RSQUARE: str
-    ARROW_L: str
-    ARROW_R: str
-    ARROW_BI: str
-    ARROW_L_P1: str
-    ARROW_L_P2: str
-    ARROW_R_P1: str
-    ARROW_R_P2: str
-    CARROW_L: str
-    CARROW_R: str
-    CARROW_BI: str
-    CARROW_L_P1: str
-    CARROW_L_P2: str
-    CARROW_R_P1: str
-    CARROW_R_P2: str
-    GLOBAL_OP: str
-    NONLOCAL_OP: str
-    KW_HERE: str
-    KW_SELF: str
-    KW_INIT: str
-    KW_SUPER: str
-    KW_ROOT: str
-    KW_POST_INIT: str
-    WALKER_OP: str
-    NODE_OP: str
-    EDGE_OP: str
-    CLASS_OP: str
-    OBJECT_OP: str
-    TYPE_OP: str
-    ENUM_OP: str
-    ABILITY_OP: str
-    A_PIPE_FWD: str
-    A_PIPE_BKWD: str
-    ELVIS_OP: str
-    RETURN_HINT: str
-    NULL_OK: str
-    DECOR_OP: str
-    FSTR_START: str
-    FSTR_END: str
-    FSTR_SQ_START: str
-    FSTR_SQ_END: str
-    FSTR_PIECE: str
-    FSTR_SQ_PIECE: str
-    FSTR_BESC: str
-    COMMENT: str
-    WS: str
-
-DELIM_MAP: Incomplete
-colors: Incomplete
diff --git a/jac/stubs/jaclang/compiler/generated/__init__.pyi b/jac/stubs/jaclang/compiler/generated/__init__.pyi
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/jac/stubs/jaclang/compiler/generated/jac_parser.pyi b/jac/stubs/jaclang/compiler/generated/jac_parser.pyi
deleted file mode 100644
index 7478ad3aa2..0000000000
--- a/jac/stubs/jaclang/compiler/generated/jac_parser.pyi
+++ /dev/null
@@ -1,898 +0,0 @@
-import abc
-import logging
-from _typeshed import Incomplete
-from abc import ABC, abstractmethod
-from collections.abc import Generator
-from types import ModuleType
-from typing import (
-    Any,
-    Callable,
-    ClassVar,
-    Collection,
-    Generic,
-    IO,
-    Iterable,
-    Iterator,
-    Mapping,
-    Sequence,
-    TypeVar,
-    overload,
-)
-
-__version__: str
-
-class LarkError(Exception): ...
-class ConfigurationError(LarkError, ValueError): ...
-
-def assert_config(
-    value, options: Collection, msg: str = "Got %r, expected one of %s"
-): ...
-
-class GrammarError(LarkError): ...
-class ParseError(LarkError): ...
-class LexError(LarkError): ...
-
-T = TypeVar("T")
-
-class UnexpectedInput(LarkError):
-    line: int
-    column: int
-    pos_in_stream: Incomplete
-    state: Any
-    interactive_parser: InteractiveParser
-    def get_context(self, text: str, span: int = 40) -> str: ...
-    def match_examples(
-        self,
-        parse_fn: Callable[[str], Tree],
-        examples: Mapping[T, Iterable[str]] | Iterable[tuple[T, Iterable[str]]],
-        token_type_match_fallback: bool = False,
-        use_accepts: bool = True,
-    ) -> T | None: ...
-
-class UnexpectedEOF(ParseError, UnexpectedInput):
-    expected: list[Token]
-    state: Incomplete
-    token: Incomplete
-    pos_in_stream: int
-    line: int
-    column: int
-    def __init__(
-        self,
-        expected,
-        state: Incomplete | None = None,
-        terminals_by_name: Incomplete | None = None,
-    ) -> None: ...
-
-class UnexpectedCharacters(LexError, UnexpectedInput):
-    allowed: set[str]
-    considered_tokens: set[Any]
-    line: Incomplete
-    column: Incomplete
-    pos_in_stream: Incomplete
-    state: Incomplete
-    considered_rules: Incomplete
-    token_history: Incomplete
-    char: Incomplete
-    def __init__(
-        self,
-        seq,
-        lex_pos,
-        line,
-        column,
-        allowed: Incomplete | None = None,
-        considered_tokens: Incomplete | None = None,
-        state: Incomplete | None = None,
-        token_history: Incomplete | None = None,
-        terminals_by_name: Incomplete | None = None,
-        considered_rules: Incomplete | None = None,
-    ) -> None: ...
-
-class UnexpectedToken(ParseError, UnexpectedInput):
-    expected: set[str]
-    considered_rules: set[str]
-    line: Incomplete
-    column: Incomplete
-    pos_in_stream: Incomplete
-    state: Incomplete
-    token: Incomplete
-    interactive_parser: Incomplete
-    token_history: Incomplete
-    def __init__(
-        self,
-        token,
-        expected,
-        considered_rules: Incomplete | None = None,
-        state: Incomplete | None = None,
-        interactive_parser: Incomplete | None = None,
-        terminals_by_name: Incomplete | None = None,
-        token_history: Incomplete | None = None,
-    ) -> None: ...
-    @property
-    def accepts(self) -> set[str]: ...
-
-class VisitError(LarkError):
-    obj: Tree | Token
-    orig_exc: Exception
-    rule: Incomplete
-    def __init__(self, rule, obj, orig_exc) -> None: ...
-
-class MissingVariableError(LarkError): ...
-
-logger: logging.Logger
-NO_VALUE: Incomplete
-T = TypeVar("T")
-
-def classify(
-    seq: Iterable, key: Callable | None = None, value: Callable | None = None
-) -> dict: ...
-
-class Serialize:
-    def memo_serialize(self, types_to_memoize: list) -> Any: ...
-    def serialize(self, memo: Incomplete | None = None) -> dict[str, Any]: ...
-    @classmethod
-    def deserialize(cls, data: dict[str, Any], memo: dict[int, Any]) -> _T: ...
-
-class SerializeMemoizer(Serialize):
-    __serialize_fields__: Incomplete
-    types_to_memoize: Incomplete
-    memoized: Incomplete
-    def __init__(self, types_to_memoize: list) -> None: ...
-    def in_types(self, value: Serialize) -> bool: ...
-    def serialize(self) -> dict[int, Any]: ...
-    @classmethod
-    def deserialize(
-        cls, data: dict[int, Any], namespace: dict[str, Any], memo: dict[Any, Any]
-    ) -> dict[int, Any]: ...
-
-categ_pattern: Incomplete
-
-def get_regexp_width(expr: str) -> tuple[int, int] | list[int]: ...
-
-class Meta:
-    empty: bool
-    line: int
-    column: int
-    start_pos: int
-    end_line: int
-    end_column: int
-    end_pos: int
-    orig_expansion: list[TerminalDef]
-    match_tree: bool
-    def __init__(self) -> None: ...
-
-Branch: Incomplete
-
-class Tree(Generic[_Leaf_T]):
-    data: str
-    children: list[Branch[_Leaf_T]]
-    def __init__(
-        self, data: str, children: list[Branch[_Leaf_T]], meta: Meta | None = None
-    ) -> None: ...
-    @property
-    def meta(self) -> Meta: ...
-    def pretty(self, indent_str: str = "  ") -> str: ...
-    def __rich__(self, parent: rich.tree.Tree | None = None) -> rich.tree.Tree: ...
-    def __eq__(self, other): ...
-    def __ne__(self, other): ...
-    def __hash__(self) -> int: ...
-    def iter_subtrees(self) -> Iterator[Tree[_Leaf_T]]: ...
-    def iter_subtrees_topdown(self) -> Generator[Incomplete, None, None]: ...
-    def find_pred(
-        self, pred: Callable[[Tree[_Leaf_T]], bool]
-    ) -> Iterator[Tree[_Leaf_T]]: ...
-    def find_data(self, data: str) -> Iterator[Tree[_Leaf_T]]: ...
-
-class _DiscardType: ...
-
-Discard: Incomplete
-
-class _Decoratable:
-    def __class_getitem__(cls, _): ...
-
-class Transformer(_Decoratable, ABC, Generic[_Leaf_T, _Return_T]):
-    __visit_tokens__: bool
-    def __init__(self, visit_tokens: bool = True) -> None: ...
-    def transform(self, tree: Tree[_Leaf_T]) -> _Return_T: ...
-    def __mul__(
-        self,
-        other: Transformer[_Leaf_U, _Return_V] | TransformerChain[_Leaf_U, _Return_V],
-    ) -> TransformerChain[_Leaf_T, _Return_V]: ...
-    def __default__(self, data, children, meta): ...
-    def __default_token__(self, token): ...
-
-def merge_transformers(
-    base_transformer: Incomplete | None = None, **transformers_to_merge
-): ...
-
-class InlineTransformer(Transformer): ...
-
-class TransformerChain(Generic[_Leaf_T, _Return_T]):
-    transformers: tuple[Transformer | TransformerChain, ...]
-    def __init__(self, *transformers: Transformer | TransformerChain) -> None: ...
-    def transform(self, tree: Tree[_Leaf_T]) -> _Return_T: ...
-    def __mul__(
-        self,
-        other: Transformer[_Leaf_U, _Return_V] | TransformerChain[_Leaf_U, _Return_V],
-    ) -> TransformerChain[_Leaf_T, _Return_V]: ...
-
-class Transformer_InPlace(Transformer[_Leaf_T, _Return_T]):
-    def transform(self, tree: Tree[_Leaf_T]) -> _Return_T: ...
-
-class Transformer_NonRecursive(Transformer[_Leaf_T, _Return_T]):
-    def transform(self, tree: Tree[_Leaf_T]) -> _Return_T: ...
-
-class Transformer_InPlaceRecursive(Transformer): ...
-
-class VisitorBase:
-    def __default__(self, tree): ...
-    def __class_getitem__(cls, _): ...
-
-class Visitor(VisitorBase, ABC, Generic[_Leaf_T]):
-    def visit(self, tree: Tree[_Leaf_T]) -> Tree[_Leaf_T]: ...
-    def visit_topdown(self, tree: Tree[_Leaf_T]) -> Tree[_Leaf_T]: ...
-
-class Visitor_Recursive(VisitorBase, Generic[_Leaf_T]):
-    def visit(self, tree: Tree[_Leaf_T]) -> Tree[_Leaf_T]: ...
-    def visit_topdown(self, tree: Tree[_Leaf_T]) -> Tree[_Leaf_T]: ...
-
-class Interpreter(_Decoratable, ABC, Generic[_Leaf_T, _Return_T]):
-    def visit(self, tree: Tree[_Leaf_T]) -> _Return_T: ...
-    def visit_children(self, tree: Tree[_Leaf_T]) -> list: ...
-    def __getattr__(self, name): ...
-    def __default__(self, tree): ...
-
-def visit_children_decor(func: _InterMethod) -> _InterMethod: ...
-
-class _VArgsWrapper:
-    base_func: Callable
-    visit_wrapper: Incomplete
-    def __init__(
-        self, func: Callable, visit_wrapper: Callable[[Callable, str, list, Any], Any]
-    ) -> None: ...
-    def __call__(self, *args, **kwargs): ...
-    def __get__(self, instance, owner: Incomplete | None = None): ...
-    def __set_name__(self, owner, name) -> None: ...
-
-def v_args(
-    inline: bool = False,
-    meta: bool = False,
-    tree: bool = False,
-    wrapper: Callable | None = None,
-) -> Callable[[_DECORATED], _DECORATED]: ...
-
-TOKEN_DEFAULT_PRIORITY: int
-
-class Symbol(Serialize):
-    name: str
-    is_term: ClassVar[bool]
-    def __init__(self, name: str) -> None: ...
-    def __eq__(self, other): ...
-    def __ne__(self, other): ...
-    def __hash__(self): ...
-    fullrepr: Incomplete
-    def renamed(self, f): ...
-
-class Terminal(Symbol):
-    __serialize_fields__: Incomplete
-    is_term: ClassVar[bool]
-    name: Incomplete
-    filter_out: Incomplete
-    def __init__(self, name, filter_out: bool = False) -> None: ...
-    @property
-    def fullrepr(self): ...
-    def renamed(self, f): ...
-
-class NonTerminal(Symbol):
-    __serialize_fields__: Incomplete
-    is_term: ClassVar[bool]
-
-class RuleOptions(Serialize):
-    __serialize_fields__: Incomplete
-    keep_all_tokens: bool
-    expand1: bool
-    priority: int | None
-    template_source: str | None
-    empty_indices: tuple[bool, ...]
-    def __init__(
-        self,
-        keep_all_tokens: bool = False,
-        expand1: bool = False,
-        priority: int | None = None,
-        template_source: str | None = None,
-        empty_indices: tuple[bool, ...] = (),
-    ) -> None: ...
-
-class Rule(Serialize):
-    __serialize_fields__: Incomplete
-    __serialize_namespace__: Incomplete
-    origin: NonTerminal
-    expansion: Sequence[Symbol]
-    order: int
-    alias: str | None
-    options: RuleOptions
-    def __init__(
-        self,
-        origin: NonTerminal,
-        expansion: Sequence[Symbol],
-        order: int = 0,
-        alias: str | None = None,
-        options: RuleOptions | None = None,
-    ) -> None: ...
-    def __hash__(self): ...
-    def __eq__(self, other): ...
-
-has_interegular: Incomplete
-
-class Pattern(Serialize, ABC, metaclass=abc.ABCMeta):
-    value: str
-    flags: Collection[str]
-    raw: str | None
-    type: ClassVar[str]
-    def __init__(
-        self, value: str, flags: Collection[str] = (), raw: str | None = None
-    ) -> None: ...
-    def __hash__(self): ...
-    def __eq__(self, other): ...
-    @abstractmethod
-    def to_regexp(self) -> str: ...
-    @property
-    @abstractmethod
-    def min_width(self) -> int: ...
-    @property
-    @abstractmethod
-    def max_width(self) -> int: ...
-
-class PatternStr(Pattern):
-    __serialize_fields__: Incomplete
-    type: ClassVar[str]
-    def to_regexp(self) -> str: ...
-    @property
-    def min_width(self) -> int: ...
-    @property
-    def max_width(self) -> int: ...
-
-class PatternRE(Pattern):
-    __serialize_fields__: Incomplete
-    type: ClassVar[str]
-    def to_regexp(self) -> str: ...
-    @property
-    def min_width(self) -> int: ...
-    @property
-    def max_width(self) -> int: ...
-
-class TerminalDef(Serialize):
-    __serialize_fields__: Incomplete
-    __serialize_namespace__: Incomplete
-    name: str
-    pattern: Pattern
-    priority: int
-    def __init__(self, name: str, pattern: Pattern, priority: int = ...) -> None: ...
-    def user_repr(self) -> str: ...
-
-class Token(str):
-    __match_args__: Incomplete
-    type: str
-    start_pos: int | None
-    value: Any
-    line: int | None
-    column: int | None
-    end_line: int | None
-    end_column: int | None
-    end_pos: int | None
-    @overload
-    def __new__(
-        cls,
-        type: str,
-        value: Any,
-        start_pos: int | None = None,
-        line: int | None = None,
-        column: int | None = None,
-        end_line: int | None = None,
-        end_column: int | None = None,
-        end_pos: int | None = None,
-    ) -> Token: ...
-    @overload
-    def __new__(
-        cls,
-        type_: str,
-        value: Any,
-        start_pos: int | None = None,
-        line: int | None = None,
-        column: int | None = None,
-        end_line: int | None = None,
-        end_column: int | None = None,
-        end_pos: int | None = None,
-    ) -> Token: ...
-    @overload
-    def update(self, type: str | None = None, value: Any | None = None) -> Token: ...
-    @overload
-    def update(self, type_: str | None = None, value: Any | None = None) -> Token: ...
-    @classmethod
-    def new_borrow_pos(cls, type_: str, value: Any, borrow_t: Token) -> _T: ...
-    def __reduce__(self): ...
-    def __deepcopy__(self, memo): ...
-    def __eq__(self, other): ...
-    __hash__: Incomplete
-
-class LineCounter:
-    newline_char: Incomplete
-    char_pos: int
-    line: int
-    column: int
-    line_start_pos: int
-    def __init__(self, newline_char) -> None: ...
-    def __eq__(self, other): ...
-    def feed(self, token: Token, test_newline: bool = True): ...
-
-class UnlessCallback:
-    scanner: Incomplete
-    def __init__(self, scanner) -> None: ...
-    def __call__(self, t): ...
-
-class CallChain:
-    callback1: Incomplete
-    callback2: Incomplete
-    cond: Incomplete
-    def __init__(self, callback1, callback2, cond) -> None: ...
-    def __call__(self, t): ...
-
-class Scanner:
-    terminals: Incomplete
-    g_regex_flags: Incomplete
-    re_: Incomplete
-    use_bytes: Incomplete
-    match_whole: Incomplete
-    allowed_types: Incomplete
-    def __init__(
-        self, terminals, g_regex_flags, re_, use_bytes, match_whole: bool = False
-    ) -> None: ...
-    def match(self, text, pos): ...
-
-class LexerState:
-    text: str
-    line_ctr: LineCounter
-    last_token: Token | None
-    def __init__(
-        self,
-        text: str,
-        line_ctr: LineCounter | None = None,
-        last_token: Token | None = None,
-    ) -> None: ...
-    def __eq__(self, other): ...
-    def __copy__(self): ...
-
-class LexerThread:
-    lexer: Incomplete
-    state: Incomplete
-    def __init__(self, lexer: Lexer, lexer_state: LexerState) -> None: ...
-    @classmethod
-    def from_text(cls, lexer: Lexer, text: str) -> LexerThread: ...
-    def lex(self, parser_state): ...
-    def __copy__(self): ...
-
-class Lexer(ABC, metaclass=abc.ABCMeta):
-    @abstractmethod
-    def lex(self, lexer_state: LexerState, parser_state: Any) -> Iterator[Token]: ...
-    def make_lexer_state(self, text): ...
-
-class AbstractBasicLexer(Lexer, metaclass=abc.ABCMeta):
-    terminals_by_name: dict[str, TerminalDef]
-    @abstractmethod
-    def __init__(self, conf: LexerConf, comparator: Incomplete | None = None): ...
-    @abstractmethod
-    def next_token(self, lex_state: LexerState, parser_state: Any = None) -> Token: ...
-    def lex(self, state: LexerState, parser_state: Any) -> Iterator[Token]: ...
-
-class BasicLexer(AbstractBasicLexer):
-    terminals: Collection[TerminalDef]
-    ignore_types: frozenset[str]
-    newline_types: frozenset[str]
-    user_callbacks: dict[str, _Callback]
-    callback: dict[str, _Callback]
-    re: ModuleType
-    g_regex_flags: Incomplete
-    use_bytes: Incomplete
-    terminals_by_name: Incomplete
-    def __init__(
-        self, conf: LexerConf, comparator: Incomplete | None = None
-    ) -> None: ...
-    @property
-    def scanner(self): ...
-    def match(self, text, pos): ...
-    def next_token(self, lex_state: LexerState, parser_state: Any = None) -> Token: ...
-
-class ContextualLexer(Lexer):
-    lexers: dict[int, AbstractBasicLexer]
-    root_lexer: AbstractBasicLexer
-    BasicLexer: type[AbstractBasicLexer]
-    def __init__(
-        self,
-        conf: LexerConf,
-        states: dict[int, Collection[str]],
-        always_accept: Collection[str] = (),
-    ) -> None: ...
-    def lex(
-        self, lexer_state: LexerState, parser_state: ParserState
-    ) -> Iterator[Token]: ...
-
-ParserCallbacks = dict[str, Callable]
-
-class LexerConf(Serialize):
-    __serialize_fields__: Incomplete
-    __serialize_namespace__: Incomplete
-    terminals: Collection[TerminalDef]
-    re_module: ModuleType
-    ignore: Collection[str]
-    postlex: PostLex | None
-    callbacks: dict[str, _LexerCallback]
-    g_regex_flags: int
-    skip_validation: bool
-    use_bytes: bool
-    lexer_type: _LexerArgType | None
-    strict: bool
-    terminals_by_name: Incomplete
-    def __init__(
-        self,
-        terminals: Collection[TerminalDef],
-        re_module: ModuleType,
-        ignore: Collection[str] = (),
-        postlex: PostLex | None = None,
-        callbacks: dict[str, _LexerCallback] | None = None,
-        g_regex_flags: int = 0,
-        skip_validation: bool = False,
-        use_bytes: bool = False,
-        strict: bool = False,
-    ) -> None: ...
-    def __deepcopy__(self, memo: Incomplete | None = None): ...
-
-class ParserConf(Serialize):
-    __serialize_fields__: Incomplete
-    rules: list["Rule"]
-    callbacks: ParserCallbacks
-    start: list[str]
-    parser_type: _ParserArgType
-    def __init__(
-        self, rules: list["Rule"], callbacks: ParserCallbacks, start: list[str]
-    ) -> None: ...
-
-class ExpandSingleChild:
-    node_builder: Incomplete
-    def __init__(self, node_builder) -> None: ...
-    def __call__(self, children): ...
-
-class PropagatePositions:
-    node_builder: Incomplete
-    node_filter: Incomplete
-    def __init__(self, node_builder, node_filter: Incomplete | None = None) -> None: ...
-    def __call__(self, children): ...
-
-def make_propagate_positions(option): ...
-
-class ChildFilter:
-    node_builder: Incomplete
-    to_include: Incomplete
-    append_none: Incomplete
-    def __init__(self, to_include, append_none, node_builder) -> None: ...
-    def __call__(self, children): ...
-
-class ChildFilterLALR(ChildFilter):
-    def __call__(self, children): ...
-
-class ChildFilterLALR_NoPlaceholders(ChildFilter):
-    node_builder: Incomplete
-    to_include: Incomplete
-    def __init__(self, to_include, node_builder) -> None: ...
-    def __call__(self, children): ...
-
-def maybe_create_child_filter(
-    expansion, keep_all_tokens, ambiguous, _empty_indices: list[bool]
-): ...
-
-class AmbiguousExpander:
-    node_builder: Incomplete
-    tree_class: Incomplete
-    to_expand: Incomplete
-    def __init__(self, to_expand, tree_class, node_builder) -> None: ...
-    def __call__(self, children): ...
-
-def maybe_create_ambiguous_expander(tree_class, expansion, keep_all_tokens): ...
-
-class AmbiguousIntermediateExpander:
-    node_builder: Incomplete
-    tree_class: Incomplete
-    def __init__(self, tree_class, node_builder) -> None: ...
-    def __call__(self, children): ...
-
-def inplace_transformer(func): ...
-def apply_visit_wrapper(func, name, wrapper): ...
-
-class ParseTreeBuilder:
-    tree_class: Incomplete
-    propagate_positions: Incomplete
-    ambiguous: Incomplete
-    maybe_placeholders: Incomplete
-    rule_builders: Incomplete
-    def __init__(
-        self,
-        rules,
-        tree_class,
-        propagate_positions: bool = False,
-        ambiguous: bool = False,
-        maybe_placeholders: bool = False,
-    ) -> None: ...
-    def create_callback(self, transformer: Incomplete | None = None): ...
-
-class Action:
-    name: Incomplete
-    def __init__(self, name) -> None: ...
-
-Shift: Incomplete
-Reduce: Incomplete
-StateT = TypeVar("StateT")
-
-class ParseTableBase(Generic[StateT]):
-    states: dict[StateT, dict[str, tuple]]
-    start_states: dict[str, StateT]
-    end_states: dict[str, StateT]
-    def __init__(self, states, start_states, end_states) -> None: ...
-    def serialize(self, memo): ...
-    @classmethod
-    def deserialize(cls, data, memo): ...
-
-class ParseTable(ParseTableBase["State"]): ...
-
-class IntParseTable(ParseTableBase[int]):
-    @classmethod
-    def from_ParseTable(cls, parse_table: ParseTable): ...
-
-class ParseConf(Generic[StateT]):
-    parse_table: ParseTableBase[StateT]
-    callbacks: ParserCallbacks
-    start: str
-    start_state: StateT
-    end_state: StateT
-    states: dict[StateT, dict[str, tuple]]
-    def __init__(
-        self,
-        parse_table: ParseTableBase[StateT],
-        callbacks: ParserCallbacks,
-        start: str,
-    ) -> None: ...
-
-class ParserState(Generic[StateT]):
-    parse_conf: ParseConf[StateT]
-    lexer: LexerThread
-    state_stack: list[StateT]
-    value_stack: list
-    def __init__(
-        self,
-        parse_conf: ParseConf[StateT],
-        lexer: LexerThread,
-        state_stack: Incomplete | None = None,
-        value_stack: Incomplete | None = None,
-    ) -> None: ...
-    @property
-    def position(self) -> StateT: ...
-    def __eq__(self, other) -> bool: ...
-    def __copy__(self): ...
-    def copy(self) -> ParserState[StateT]: ...
-    def feed_token(self, token: Token, is_end: bool = False) -> Any: ...
-
-class LALR_Parser(Serialize):
-    parser_conf: Incomplete
-    parser: Incomplete
-    def __init__(
-        self, parser_conf: ParserConf, debug: bool = False, strict: bool = False
-    ) -> None: ...
-    @classmethod
-    def deserialize(cls, data, memo, callbacks, debug: bool = False): ...
-    def serialize(self, memo: Any = None) -> dict[str, Any]: ...
-    def parse_interactive(self, lexer: LexerThread, start: str): ...
-    def parse(self, lexer, start, on_error: Incomplete | None = None): ...
-
-class _Parser:
-    parse_table: ParseTableBase
-    callbacks: ParserCallbacks
-    debug: bool
-    def __init__(
-        self,
-        parse_table: ParseTableBase,
-        callbacks: ParserCallbacks,
-        debug: bool = False,
-    ) -> None: ...
-    def parse(
-        self,
-        lexer: LexerThread,
-        start: str,
-        value_stack: Incomplete | None = None,
-        state_stack: Incomplete | None = None,
-        start_interactive: bool = False,
-    ): ...
-    def parse_from_state(self, state: ParserState, last_token: Token | None = None): ...
-
-class InteractiveParser:
-    parser: Incomplete
-    parser_state: Incomplete
-    lexer_thread: Incomplete
-    result: Incomplete
-    def __init__(self, parser, parser_state, lexer_thread: LexerThread) -> None: ...
-    @property
-    def lexer_state(self) -> LexerThread: ...
-    def feed_token(self, token: Token): ...
-    def iter_parse(self) -> Iterator[Token]: ...
-    def exhaust_lexer(self) -> list[Token]: ...
-    def feed_eof(self, last_token: Incomplete | None = None): ...
-    def __copy__(self): ...
-    def copy(self): ...
-    def __eq__(self, other): ...
-    def as_immutable(self): ...
-    def pretty(self): ...
-    def choices(self): ...
-    def accepts(self): ...
-    def resume_parse(self): ...
-
-class ImmutableInteractiveParser(InteractiveParser):
-    result: Incomplete
-    def __hash__(self): ...
-    def feed_token(self, token): ...
-    def exhaust_lexer(self): ...
-    def as_mutable(self): ...
-
-class ParsingFrontend(Serialize):
-    __serialize_fields__: Incomplete
-    lexer_conf: LexerConf
-    parser_conf: ParserConf
-    options: Any
-    parser: Incomplete
-    skip_lexer: bool
-    lexer: Incomplete
-    def __init__(
-        self,
-        lexer_conf: LexerConf,
-        parser_conf: ParserConf,
-        options,
-        parser: Incomplete | None = None,
-    ) -> None: ...
-    def parse(
-        self,
-        text: str,
-        start: Incomplete | None = None,
-        on_error: Incomplete | None = None,
-    ): ...
-    def parse_interactive(
-        self, text: str | None = None, start: Incomplete | None = None
-    ): ...
-
-class PostLexConnector:
-    lexer: Incomplete
-    postlexer: Incomplete
-    def __init__(self, lexer, postlexer) -> None: ...
-    def lex(self, lexer_state, parser_state): ...
-
-def create_basic_lexer(lexer_conf, parser, postlex, options) -> BasicLexer: ...
-def create_contextual_lexer(
-    lexer_conf: LexerConf, parser, postlex, options
-) -> ContextualLexer: ...
-def create_lalr_parser(
-    lexer_conf: LexerConf, parser_conf: ParserConf, options: Incomplete | None = None
-) -> LALR_Parser: ...
-
-class PostLex(ABC, metaclass=abc.ABCMeta):
-    @abstractmethod
-    def process(self, stream: Iterator[Token]) -> Iterator[Token]: ...
-    always_accept: Iterable[str]
-
-class LarkOptions(Serialize):
-    start: list[str]
-    debug: bool
-    strict: bool
-    transformer: Transformer | None
-    propagate_positions: bool | str
-    maybe_placeholders: bool
-    cache: bool | str
-    regex: bool
-    g_regex_flags: int
-    keep_all_tokens: bool
-    tree_class: Callable[[str, list], Any] | None
-    parser: _ParserArgType
-    lexer: _LexerArgType
-    ambiguity: Literal["auto", "resolve", "explicit", "forest"]
-    postlex: PostLex | None
-    priority: Literal["auto", "normal", "invert"] | None
-    lexer_callbacks: dict[str, Callable[[Token], Token]]
-    use_bytes: bool
-    ordered_sets: bool
-    edit_terminals: Callable[[TerminalDef], TerminalDef] | None
-    import_paths: list[
-        str | Callable[[None | str | PackageResource, str], tuple[str, str]]
-    ]
-    source_path: str | None
-    OPTIONS_DOC: str
-    def __init__(self, options_dict: dict[str, Any]) -> None: ...
-    def __getattr__(self, name: str) -> Any: ...
-    def __setattr__(self, name: str, value: str) -> None: ...
-    def serialize(self, memo: Incomplete | None = None) -> dict[str, Any]: ...
-    @classmethod
-    def deserialize(
-        cls, data: dict[str, Any], memo: dict[int, TerminalDef | Rule]
-    ) -> LarkOptions: ...
-
-class Lark(Serialize):
-    source_path: str
-    source_grammar: str
-    grammar: Grammar
-    options: LarkOptions
-    lexer: Lexer
-    parser: ParsingFrontend
-    terminals: Collection[TerminalDef]
-    lexer_conf: Incomplete
-    def __init__(self, grammar: Grammar | str | IO[str], **options) -> None: ...
-    __serialize_fields__: Incomplete
-    def save(self, f, exclude_options: Collection[str] = ()) -> None: ...
-    @classmethod
-    def load(cls, f) -> _T: ...
-    @classmethod
-    def open(
-        cls, grammar_filename: str, rel_to: str | None = None, **options
-    ) -> _T: ...
-    @classmethod
-    def open_from_package(
-        cls,
-        package: str,
-        grammar_path: str,
-        search_paths: Sequence[str] = [""],
-        **options
-    ) -> _T: ...
-    def lex(self, text: str, dont_ignore: bool = False) -> Iterator[Token]: ...
-    def get_terminal(self, name: str) -> TerminalDef: ...
-    def parse_interactive(
-        self, text: str | None = None, start: str | None = None
-    ) -> InteractiveParser: ...
-    def parse(
-        self,
-        text: str,
-        start: str | None = None,
-        on_error: Callable[[UnexpectedInput], bool] | None = None,
-    ) -> ParseTree: ...
-
-class DedentError(LarkError): ...
-
-class Indenter(PostLex, ABC, metaclass=abc.ABCMeta):
-    paren_level: int
-    indent_level: list[int]
-    def __init__(self) -> None: ...
-    def handle_NL(self, token: Token) -> Iterator[Token]: ...
-    def process(self, stream): ...
-    @property
-    def always_accept(self): ...
-    @property
-    @abstractmethod
-    def NL_type(self) -> str: ...
-    @property
-    @abstractmethod
-    def OPEN_PAREN_types(self) -> list[str]: ...
-    @property
-    @abstractmethod
-    def CLOSE_PAREN_types(self) -> list[str]: ...
-    @property
-    @abstractmethod
-    def INDENT_type(self) -> str: ...
-    @property
-    @abstractmethod
-    def DEDENT_type(self) -> str: ...
-    @property
-    @abstractmethod
-    def tab_len(self) -> int: ...
-
-class PythonIndenter(Indenter):
-    NL_type: str
-    OPEN_PAREN_types: Incomplete
-    CLOSE_PAREN_types: Incomplete
-    INDENT_type: str
-    DEDENT_type: str
-    tab_len: int
-
-DATA: bytes
-MEMO: bytes
-
-def Lark_StandAlone(**kwargs): ...
diff --git a/jac/stubs/jaclang/compiler/parser.pyi b/jac/stubs/jaclang/compiler/parser.pyi
deleted file mode 100644
index 48c4659bdf..0000000000
--- a/jac/stubs/jaclang/compiler/parser.pyi
+++ /dev/null
@@ -1,266 +0,0 @@
-import jaclang.compiler.absyntree as ast
-from _typeshed import Incomplete
-from jaclang.compiler import jac_lark as jl
-from jaclang.compiler.constant import EdgeDir as EdgeDir
-from jaclang.compiler.passes.ir_pass import Pass as Pass
-from jaclang.vendor.lark import (
-    Lark as Lark,
-    Transformer as Transformer,
-    Tree as Tree,
-    logger as logger,
-)
-from typing import Callable, TypeAlias
-
-class JacParser(Pass):
-    dev_mode: bool
-    source: Incomplete
-    mod_path: Incomplete
-    node_list: Incomplete
-    def __init__(self, input_ir: ast.JacSource) -> None: ...
-    def transform(self, ir: ast.AstNode) -> ast.Module: ...
-    @staticmethod
-    def proc_comment(token: jl.Token, mod: ast.AstNode) -> ast.CommentToken: ...
-    def error_callback(self, e: jl.UnexpectedInput) -> bool: ...
-    @staticmethod
-    def parse(
-        ir: str, on_error: Callable[[jl.UnexpectedInput], bool]
-    ) -> tuple[jl.Tree[jl.Tree[str]], list[jl.Token]]: ...
-    @staticmethod
-    def make_dev() -> None: ...
-    comment_cache: list[jl.Token]
-    parser: Incomplete
-    JacTransformer: TypeAlias
-
-    class TreeToAST(JacTransformer):
-        parse_ref: Incomplete
-        terminals: Incomplete
-        def __init__(self, parser: JacParser, *args: bool, **kwargs: bool) -> None: ...
-        def ice(self) -> Exception: ...
-        def nu(self, node: ast.T) -> ast.T: ...
-        def start(self, kid: list[ast.Module]) -> ast.Module: ...
-        def module(
-            self, kid: list[ast.ElementStmt | ast.String | ast.EmptyToken]
-        ) -> ast.Module: ...
-        def element_with_doc(
-            self, kid: list[ast.ElementStmt | ast.String]
-        ) -> ast.ElementStmt: ...
-        def element(self, kid: list[ast.AstNode]) -> ast.ElementStmt: ...
-        def global_var(self, kid: list[ast.AstNode]) -> ast.GlobalVars: ...
-        def access_tag(self, kid: list[ast.AstNode]) -> ast.SubTag[ast.Token]: ...
-        def test(self, kid: list[ast.AstNode]) -> ast.Test: ...
-        def free_code(self, kid: list[ast.AstNode]) -> ast.ModuleCode: ...
-        def doc_tag(self, kid: list[ast.AstNode]) -> ast.String: ...
-        def py_code_block(self, kid: list[ast.AstNode]) -> ast.PyInlineCode: ...
-        def import_stmt(self, kid: list[ast.AstNode]) -> ast.Import: ...
-        def from_path(self, kid: list[ast.AstNode]) -> ast.ModulePath: ...
-        def include_stmt(self, kid: list[ast.AstNode]) -> ast.Import: ...
-        def import_path(self, kid: list[ast.AstNode]) -> ast.ModulePath: ...
-        def import_items(
-            self, kid: list[ast.AstNode]
-        ) -> ast.SubNodeList[ast.ModuleItem]: ...
-        def import_item(self, kid: list[ast.AstNode]) -> ast.ModuleItem: ...
-        def architype(
-            self, kid: list[ast.AstNode]
-        ) -> ast.ArchSpec | ast.ArchDef | ast.Enum | ast.EnumDef: ...
-        def architype_decl(self, kid: list[ast.AstNode]) -> ast.ArchSpec: ...
-        def architype_def(self, kid: list[ast.AstNode]) -> ast.ArchDef: ...
-        def arch_type(self, kid: list[ast.AstNode]) -> ast.Token: ...
-        def decorators(self, kid: list[ast.AstNode]) -> ast.SubNodeList[ast.Expr]: ...
-        def inherited_archs(
-            self, kid: list[ast.AstNode]
-        ) -> ast.SubNodeList[ast.Expr]: ...
-        def sub_name(self, kid: list[ast.AstNode]) -> ast.SubTag[ast.Name]: ...
-        def named_ref(self, kid: list[ast.AstNode]) -> ast.NameAtom: ...
-        def special_ref(self, kid: list[ast.AstNode]) -> ast.SpecialVarRef: ...
-        def enum(self, kid: list[ast.AstNode]) -> ast.Enum | ast.EnumDef: ...
-        def enum_decl(self, kid: list[ast.AstNode]) -> ast.Enum: ...
-        def enum_def(self, kid: list[ast.AstNode]) -> ast.EnumDef: ...
-        def enum_block(
-            self, kid: list[ast.AstNode]
-        ) -> ast.SubNodeList[ast.EnumBlockStmt]: ...
-        def enum_stmt(self, kid: list[ast.AstNode]) -> ast.EnumBlockStmt: ...
-        def ability(
-            self, kid: list[ast.AstNode]
-        ) -> ast.Ability | ast.AbilityDef | ast.FuncCall: ...
-        def ability_decl(self, kid: list[ast.AstNode]) -> ast.Ability: ...
-        def ability_def(self, kid: list[ast.AstNode]) -> ast.AbilityDef: ...
-        def abstract_ability(self, kid: list[ast.AstNode]) -> ast.Ability: ...
-        def genai_ability(self, kid: list[ast.AstNode]) -> ast.Ability: ...
-        def event_clause(self, kid: list[ast.AstNode]) -> ast.EventSignature: ...
-        def func_decl(self, kid: list[ast.AstNode]) -> ast.FuncSignature: ...
-        def func_decl_params(
-            self, kid: list[ast.AstNode]
-        ) -> ast.SubNodeList[ast.ParamVar]: ...
-        def param_var(self, kid: list[ast.AstNode]) -> ast.ParamVar: ...
-        def member_block(
-            self, kid: list[ast.AstNode]
-        ) -> ast.SubNodeList[ast.ArchBlockStmt]: ...
-        def member_stmt(self, kid: list[ast.AstNode]) -> ast.ArchBlockStmt: ...
-        def has_stmt(self, kid: list[ast.AstNode]) -> ast.ArchHas: ...
-        def has_assign_list(
-            self, kid: list[ast.AstNode]
-        ) -> ast.SubNodeList[ast.HasVar]: ...
-        def typed_has_clause(self, kid: list[ast.AstNode]) -> ast.HasVar: ...
-        def type_tag(self, kid: list[ast.AstNode]) -> ast.SubTag[ast.Expr]: ...
-        def builtin_type(self, kid: list[ast.AstNode]) -> ast.Token: ...
-        def code_block(
-            self, kid: list[ast.AstNode]
-        ) -> ast.SubNodeList[ast.CodeBlockStmt]: ...
-        def statement(self, kid: list[ast.AstNode]) -> ast.CodeBlockStmt: ...
-        def typed_ctx_block(self, kid: list[ast.AstNode]) -> ast.TypedCtxBlock: ...
-        def if_stmt(self, kid: list[ast.AstNode]) -> ast.IfStmt: ...
-        def elif_stmt(self, kid: list[ast.AstNode]) -> ast.ElseIf: ...
-        def else_stmt(self, kid: list[ast.AstNode]) -> ast.ElseStmt: ...
-        def try_stmt(self, kid: list[ast.AstNode]) -> ast.TryStmt: ...
-        def except_list(
-            self, kid: list[ast.AstNode]
-        ) -> ast.SubNodeList[ast.Except]: ...
-        def except_def(self, kid: list[ast.AstNode]) -> ast.Except: ...
-        def finally_stmt(self, kid: list[ast.AstNode]) -> ast.FinallyStmt: ...
-        def for_stmt(
-            self, kid: list[ast.AstNode]
-        ) -> ast.IterForStmt | ast.InForStmt: ...
-        def while_stmt(self, kid: list[ast.AstNode]) -> ast.WhileStmt: ...
-        def with_stmt(self, kid: list[ast.AstNode]) -> ast.WithStmt: ...
-        def expr_as_list(
-            self, kid: list[ast.AstNode]
-        ) -> ast.SubNodeList[ast.ExprAsItem]: ...
-        def expr_as(self, kid: list[ast.AstNode]) -> ast.ExprAsItem: ...
-        def raise_stmt(self, kid: list[ast.AstNode]) -> ast.RaiseStmt: ...
-        def assert_stmt(self, kid: list[ast.AstNode]) -> ast.AssertStmt: ...
-        def check_stmt(self, kid: list[ast.AstNode]) -> ast.CheckStmt: ...
-        def ctrl_stmt(self, kid: list[ast.AstNode]) -> ast.CtrlStmt: ...
-        def delete_stmt(self, kid: list[ast.AstNode]) -> ast.DeleteStmt: ...
-        def report_stmt(self, kid: list[ast.AstNode]) -> ast.ReportStmt: ...
-        def return_stmt(self, kid: list[ast.AstNode]) -> ast.ReturnStmt: ...
-        def walker_stmt(self, kid: list[ast.AstNode]) -> ast.CodeBlockStmt: ...
-        def ignore_stmt(self, kid: list[ast.AstNode]) -> ast.IgnoreStmt: ...
-        def visit_stmt(self, kid: list[ast.AstNode]) -> ast.VisitStmt: ...
-        def revisit_stmt(self, kid: list[ast.AstNode]) -> ast.RevisitStmt: ...
-        def disengage_stmt(self, kid: list[ast.AstNode]) -> ast.DisengageStmt: ...
-        def global_ref(self, kid: list[ast.AstNode]) -> ast.GlobalStmt: ...
-        def nonlocal_ref(self, kid: list[ast.AstNode]) -> ast.NonLocalStmt: ...
-        def assignment(self, kid: list[ast.AstNode]) -> ast.Assignment: ...
-        def expression(self, kid: list[ast.AstNode]) -> ast.Expr: ...
-        def walrus_assign(self, kid: list[ast.AstNode]) -> ast.Expr: ...
-        def binary_expr_unwind(self, kid: list[ast.AstNode]) -> ast.Expr: ...
-        def lambda_expr(self, kid: list[ast.AstNode]) -> ast.LambdaExpr: ...
-        def pipe(self, kid: list[ast.AstNode]) -> ast.Expr: ...
-        def pipe_back(self, kid: list[ast.AstNode]) -> ast.Expr: ...
-        def elvis_check(self, kid: list[ast.AstNode]) -> ast.Expr: ...
-        def bitwise_or(self, kid: list[ast.AstNode]) -> ast.Expr: ...
-        def bitwise_xor(self, kid: list[ast.AstNode]) -> ast.Expr: ...
-        def bitwise_and(self, kid: list[ast.AstNode]) -> ast.Expr: ...
-        def shift(self, kid: list[ast.AstNode]) -> ast.Expr: ...
-        def logical_or(self, kid: list[ast.AstNode]) -> ast.Expr: ...
-        def logical_and(self, kid: list[ast.AstNode]) -> ast.Expr: ...
-        def logical_not(self, kid: list[ast.AstNode]) -> ast.Expr: ...
-        def compare(self, kid: list[ast.AstNode]) -> ast.Expr: ...
-        def cmp_op(self, kid: list[ast.AstNode]) -> ast.Token: ...
-        def arithmetic(self, kid: list[ast.AstNode]) -> ast.Expr: ...
-        def term(self, kid: list[ast.AstNode]) -> ast.Expr: ...
-        def factor(self, kid: list[ast.AstNode]) -> ast.Expr: ...
-        def power(self, kid: list[ast.AstNode]) -> ast.Expr: ...
-        def connect(self, kid: list[ast.AstNode]) -> ast.Expr: ...
-        def atomic_pipe(self, kid: list[ast.AstNode]) -> ast.Expr: ...
-        def atomic_pipe_back(self, kid: list[ast.AstNode]) -> ast.Expr: ...
-        def ds_spawn(self, kid: list[ast.AstNode]) -> ast.Expr: ...
-        def unpack(self, kid: list[ast.AstNode]) -> ast.Expr: ...
-        def ref(self, kid: list[ast.AstNode]) -> ast.Expr: ...
-        def pipe_call(self, kid: list[ast.AstNode]) -> ast.Expr: ...
-        def aug_op(self, kid: list[ast.AstNode]) -> ast.Token: ...
-        def atomic_chain(self, kid: list[ast.AstNode]) -> ast.Expr: ...
-        def atomic_call(self, kid: list[ast.AstNode]) -> ast.FuncCall: ...
-        def index_slice(self, kid: list[ast.AstNode]) -> ast.IndexSlice: ...
-        def atom(self, kid: list[ast.AstNode]) -> ast.Expr: ...
-        def yield_expr(self, kid: list[ast.AstNode]) -> ast.YieldExpr: ...
-        def atom_literal(self, kid: list[ast.AstNode]) -> ast.AtomExpr: ...
-        def atom_collection(self, kid: list[ast.AstNode]) -> ast.AtomExpr: ...
-        def multistring(self, kid: list[ast.AstNode]) -> ast.AtomExpr: ...
-        def fstring(self, kid: list[ast.AstNode]) -> ast.FString: ...
-        def fstr_parts(
-            self, kid: list[ast.AstNode]
-        ) -> ast.SubNodeList[ast.String | ast.ExprStmt]: ...
-        def fstr_sq_parts(
-            self, kid: list[ast.AstNode]
-        ) -> ast.SubNodeList[ast.String | ast.ExprStmt]: ...
-        def list_val(self, kid: list[ast.AstNode]) -> ast.ListVal: ...
-        def tuple_val(self, kid: list[ast.AstNode]) -> ast.TupleVal: ...
-        def set_val(self, kid: list[ast.AstNode]) -> ast.SetVal: ...
-        def expr_list(self, kid: list[ast.AstNode]) -> ast.SubNodeList[ast.Expr]: ...
-        def kw_expr_list(
-            self, kid: list[ast.AstNode]
-        ) -> ast.SubNodeList[ast.KWPair]: ...
-        def kw_expr(self, kid: list[ast.AstNode]) -> ast.KWPair: ...
-        def name_list(self, kid: list[ast.AstNode]) -> ast.SubNodeList[ast.Name]: ...
-        def tuple_list(
-            self, kid: list[ast.AstNode]
-        ) -> ast.SubNodeList[ast.Expr | ast.KWPair]: ...
-        def dict_val(self, kid: list[ast.AstNode]) -> ast.DictVal: ...
-        def kv_pair(self, kid: list[ast.AstNode]) -> ast.KVPair: ...
-        def list_compr(self, kid: list[ast.AstNode]) -> ast.ListCompr: ...
-        def gen_compr(self, kid: list[ast.AstNode]) -> ast.GenCompr: ...
-        def set_compr(self, kid: list[ast.AstNode]) -> ast.SetCompr: ...
-        def dict_compr(self, kid: list[ast.AstNode]) -> ast.DictCompr: ...
-        def inner_compr(self, kid: list[ast.AstNode]) -> ast.InnerCompr: ...
-        def param_list(
-            self, kid: list[ast.AstNode]
-        ) -> ast.SubNodeList[ast.Expr | ast.KWPair]: ...
-        def assignment_list(
-            self, kid: list[ast.AstNode]
-        ) -> ast.SubNodeList[ast.Assignment]: ...
-        def arch_ref(self, kid: list[ast.AstNode]) -> ast.ArchRef: ...
-        def node_ref(self, kid: list[ast.AstNode]) -> ast.ArchRef: ...
-        def edge_ref(self, kid: list[ast.AstNode]) -> ast.ArchRef: ...
-        def walker_ref(self, kid: list[ast.AstNode]) -> ast.ArchRef: ...
-        def class_ref(self, kid: list[ast.AstNode]) -> ast.ArchRef: ...
-        def object_ref(self, kid: list[ast.AstNode]) -> ast.ArchRef: ...
-        def type_ref(self, kid: list[ast.AstNode]) -> ast.ArchRef: ...
-        def enum_ref(self, kid: list[ast.AstNode]) -> ast.ArchRef: ...
-        def ability_ref(self, kid: list[ast.AstNode]) -> ast.ArchRef: ...
-        def arch_or_ability_chain(self, kid: list[ast.AstNode]) -> ast.ArchRefChain: ...
-        def abil_to_arch_chain(self, kid: list[ast.AstNode]) -> ast.ArchRefChain: ...
-        def arch_to_abil_chain(self, kid: list[ast.AstNode]) -> ast.ArchRefChain: ...
-        def arch_to_enum_chain(self, kid: list[ast.AstNode]) -> ast.ArchRefChain: ...
-        def edge_ref_chain(self, kid: list[ast.AstNode]) -> ast.EdgeRefTrailer: ...
-        def edge_op_ref(self, kid: list[ast.AstNode]) -> ast.EdgeOpRef: ...
-        def edge_to(self, kid: list[ast.AstNode]) -> ast.EdgeOpRef: ...
-        def edge_from(self, kid: list[ast.AstNode]) -> ast.EdgeOpRef: ...
-        def edge_any(self, kid: list[ast.AstNode]) -> ast.EdgeOpRef: ...
-        def connect_op(self, kid: list[ast.AstNode]) -> ast.ConnectOp: ...
-        def disconnect_op(self, kid: list[ast.AstNode]) -> ast.DisconnectOp: ...
-        def connect_to(self, kid: list[ast.AstNode]) -> ast.ConnectOp: ...
-        def connect_from(self, kid: list[ast.AstNode]) -> ast.ConnectOp: ...
-        def connect_any(self, kid: list[ast.AstNode]) -> ast.ConnectOp: ...
-        def filter_compr(self, kid: list[ast.AstNode]) -> ast.FilterCompr: ...
-        def filter_compare_list(
-            self, kid: list[ast.AstNode]
-        ) -> ast.SubNodeList[ast.CompareExpr]: ...
-        def typed_filter_compare_list(
-            self, kid: list[ast.AstNode]
-        ) -> ast.FilterCompr: ...
-        def filter_compare_item(self, kid: list[ast.AstNode]) -> ast.CompareExpr: ...
-        def assign_compr(self, kid: list[ast.AstNode]) -> ast.AssignCompr: ...
-        def match_stmt(self, kid: list[ast.AstNode]) -> ast.MatchStmt: ...
-        def match_case_block(self, kid: list[ast.AstNode]) -> ast.MatchCase: ...
-        def pattern_seq(self, kid: list[ast.AstNode]) -> ast.MatchPattern: ...
-        def or_pattern(self, kid: list[ast.AstNode]) -> ast.MatchPattern: ...
-        def as_pattern(self, kid: list[ast.AstNode]) -> ast.MatchPattern: ...
-        def pattern(self, kid: list[ast.AstNode]) -> ast.MatchPattern: ...
-        def literal_pattern(self, kid: list[ast.AstNode]) -> ast.MatchPattern: ...
-        def singleton_pattern(self, kid: list[ast.AstNode]) -> ast.MatchPattern: ...
-        def capture_pattern(self, kid: list[ast.AstNode]) -> ast.MatchPattern: ...
-        def sequence_pattern(self, kid: list[ast.AstNode]) -> ast.MatchPattern: ...
-        def mapping_pattern(self, kid: list[ast.AstNode]) -> ast.MatchMapping: ...
-        def list_inner_pattern(self, kid: list[ast.AstNode]) -> ast.MatchPattern: ...
-        def dict_inner_pattern(
-            self, kid: list[ast.AstNode]
-        ) -> ast.MatchKVPair | ast.MatchStar: ...
-        def class_pattern(self, kid: list[ast.AstNode]) -> ast.MatchArch: ...
-        def pattern_list(
-            self, kid: list[ast.AstNode]
-        ) -> ast.SubNodeList[ast.MatchPattern]: ...
-        def kw_pattern_list(
-            self, kid: list[ast.AstNode]
-        ) -> ast.SubNodeList[ast.MatchKVPair]: ...
-        def __default_token__(self, token: jl.Token) -> ast.Token: ...
diff --git a/jac/stubs/jaclang/compiler/passes/__init__.pyi b/jac/stubs/jaclang/compiler/passes/__init__.pyi
deleted file mode 100644
index 9cbed3ce61..0000000000
--- a/jac/stubs/jaclang/compiler/passes/__init__.pyi
+++ /dev/null
@@ -1,3 +0,0 @@
-from .ir_pass import Pass as Pass
-
-__all__ = ["Pass"]
diff --git a/jac/stubs/jaclang/compiler/passes/ir_pass.pyi b/jac/stubs/jaclang/compiler/passes/ir_pass.pyi
deleted file mode 100644
index 46f054550c..0000000000
--- a/jac/stubs/jaclang/compiler/passes/ir_pass.pyi
+++ /dev/null
@@ -1,40 +0,0 @@
-import jaclang.compiler.absyntree as ast
-from _typeshed import Incomplete
-from jaclang.compiler.passes.transform import Transform as Transform
-from jaclang.settings import settings as settings
-from jaclang.utils.helpers import pascal_to_snake as pascal_to_snake
-from typing import TypeVar
-
-T = TypeVar("T", bound=ast.AstNode)
-
-class Pass(Transform[T]):
-    term_signal: bool
-    prune_signal: bool
-    ir: Incomplete
-    time_taken: float
-    def __init__(self, input_ir: T, prior: Transform | None) -> None: ...
-    def before_pass(self) -> None: ...
-    def after_pass(self) -> None: ...
-    def enter_node(self, node: ast.AstNode) -> None: ...
-    def exit_node(self, node: ast.AstNode) -> None: ...
-    def terminate(self) -> None: ...
-    def prune(self) -> None: ...
-    @staticmethod
-    def get_all_sub_nodes(
-        node: ast.AstNode, typ: type[T], brute_force: bool = False
-    ) -> list[T]: ...
-    @staticmethod
-    def has_parent_of_type(node: ast.AstNode, typ: type[T]) -> T | None: ...
-    @staticmethod
-    def has_parent_of_node(node: ast.AstNode, parent: ast.AstNode) -> bool: ...
-    def recalculate_parents(self, node: ast.AstNode) -> None: ...
-    def transform(self, ir: T) -> ast.AstNode: ...
-    cur_node: Incomplete
-    def traverse(self, node: ast.AstNode) -> ast.AstNode: ...
-    def error(self, msg: str, node_override: ast.AstNode | None = None) -> None: ...
-    def warning(self, msg: str, node_override: ast.AstNode | None = None) -> None: ...
-    def ice(self, msg: str = "Something went horribly wrong!") -> RuntimeError: ...
-
-class PrinterPass(Pass):
-    def enter_node(self, node: ast.AstNode) -> None: ...
-    def exit_node(self, node: ast.AstNode) -> None: ...
diff --git a/jac/stubs/jaclang/compiler/passes/main/__init__.pyi b/jac/stubs/jaclang/compiler/passes/main/__init__.pyi
deleted file mode 100644
index cf5584db3a..0000000000
--- a/jac/stubs/jaclang/compiler/passes/main/__init__.pyi
+++ /dev/null
@@ -1,27 +0,0 @@
-from .def_impl_match_pass import DeclImplMatchPass as DeclImplMatchPass
-from .def_use_pass import DefUsePass as DefUsePass
-from .import_pass import JacImportPass as JacImportPass, PyImportPass as PyImportPass
-from .pyast_gen_pass import PyastGenPass as PyastGenPass
-from .pyast_load_pass import PyastBuildPass as PyastBuildPass
-from .pyout_pass import PyOutPass as PyOutPass
-from .registry_pass import RegistryPass as RegistryPass
-from .schedules import py_code_gen
-from .sub_node_tab_pass import SubNodeTabPass as SubNodeTabPass
-from .sym_tab_build_pass import SymTabBuildPass as SymTabBuildPass
-from .type_check_pass import JacTypeCheckPass as JacTypeCheckPass
-
-__all__ = [
-    "SubNodeTabPass",
-    "JacImportPass",
-    "PyImportPass",
-    "SymTabBuildPass",
-    "DeclImplMatchPass",
-    "DefUsePass",
-    "PyOutPass",
-    "PyastBuildPass",
-    "PyastGenPass",
-    "JacTypeCheckPass",
-    "RegistryPass",
-]
-
-pass_schedule = py_code_gen
diff --git a/jac/stubs/jaclang/compiler/passes/main/access_modifier_pass.pyi b/jac/stubs/jaclang/compiler/passes/main/access_modifier_pass.pyi
deleted file mode 100644
index de1c2e01ed..0000000000
--- a/jac/stubs/jaclang/compiler/passes/main/access_modifier_pass.pyi
+++ /dev/null
@@ -1,23 +0,0 @@
-import jaclang.compiler.absyntree as ast
-from jaclang.compiler.constant import SymbolAccess as SymbolAccess
-from jaclang.compiler.passes import Pass as Pass
-from jaclang.compiler.symtable import SymbolTable as SymbolTable
-from jaclang.settings import settings as settings
-
-class AccessCheckPass(Pass):
-    def after_pass(self) -> None: ...
-    def exit_node(self, node: ast.AstNode) -> None: ...
-    def access_check(self, node: ast.Name) -> None: ...
-    def access_register(
-        self, node: ast.AstSymbolNode, acc_tag: SymbolAccess | None = None
-    ) -> None: ...
-    def enter_global_vars(self, node: ast.GlobalVars) -> None: ...
-    def enter_module(self, node: ast.Module) -> None: ...
-    def enter_architype(self, node: ast.Architype) -> None: ...
-    def enter_enum(self, node: ast.Enum) -> None: ...
-    def enter_ability(self, node: ast.Ability) -> None: ...
-    def enter_sub_node_list(self, node: ast.SubNodeList) -> None: ...
-    def enter_arch_has(self, node: ast.ArchHas) -> None: ...
-    def enter_atom_trailer(self, node: ast.AtomTrailer) -> None: ...
-    def enter_func_call(self, node: ast.FuncCall) -> None: ...
-    def enter_name(self, node: ast.Name) -> None: ...
diff --git a/jac/stubs/jaclang/compiler/passes/main/def_impl_match_pass.pyi b/jac/stubs/jaclang/compiler/passes/main/def_impl_match_pass.pyi
deleted file mode 100644
index 46f498857e..0000000000
--- a/jac/stubs/jaclang/compiler/passes/main/def_impl_match_pass.pyi
+++ /dev/null
@@ -1,12 +0,0 @@
-import jaclang.compiler.absyntree as ast
-from _typeshed import Incomplete
-from jaclang.compiler.passes import Pass as Pass
-from jaclang.compiler.passes.main import SubNodeTabPass as SubNodeTabPass
-from jaclang.compiler.symtable import Symbol as Symbol, SymbolTable as SymbolTable
-
-class DeclImplMatchPass(Pass):
-    def enter_module(self, node: ast.Module) -> None: ...
-    ir: Incomplete
-    def after_pass(self) -> None: ...
-    def defn_lookup(self, lookup: Symbol) -> ast.NameAtom | None: ...
-    def connect_def_impl(self, sym_tab: SymbolTable) -> None: ...
diff --git a/jac/stubs/jaclang/compiler/passes/main/def_use_pass.pyi b/jac/stubs/jaclang/compiler/passes/main/def_use_pass.pyi
deleted file mode 100644
index 8cc9e919e3..0000000000
--- a/jac/stubs/jaclang/compiler/passes/main/def_use_pass.pyi
+++ /dev/null
@@ -1,31 +0,0 @@
-import jaclang.compiler.absyntree as ast
-from jaclang.compiler.passes import Pass as Pass
-
-class DefUsePass(Pass):
-    def after_pass(self) -> None: ...
-    def enter_architype(self, node: ast.Architype) -> None: ...
-    def enter_enum(self, node: ast.Enum) -> None: ...
-    def enter_arch_ref(self, node: ast.ArchRef) -> None: ...
-    def enter_arch_ref_chain(self, node: ast.ArchRefChain) -> None: ...
-    def enter_param_var(self, node: ast.ParamVar) -> None: ...
-    def enter_has_var(self, node: ast.HasVar) -> None: ...
-    def enter_assignment(self, node: ast.Assignment) -> None: ...
-    def enter_inner_compr(self, node: ast.InnerCompr) -> None: ...
-    def enter_atom_trailer(self, node: ast.AtomTrailer) -> None: ...
-    def enter_func_call(self, node: ast.FuncCall) -> None: ...
-    def enter_index_slice(self, node: ast.IndexSlice) -> None: ...
-    def enter_special_var_ref(self, node: ast.SpecialVarRef) -> None: ...
-    def enter_edge_op_ref(self, node: ast.EdgeOpRef) -> None: ...
-    def enter_disconnect_op(self, node: ast.DisconnectOp) -> None: ...
-    def enter_connect_op(self, node: ast.ConnectOp) -> None: ...
-    def enter_filter_compr(self, node: ast.FilterCompr) -> None: ...
-    def enter_token(self, node: ast.Token) -> None: ...
-    def enter_float(self, node: ast.Float) -> None: ...
-    def enter_int(self, node: ast.Int) -> None: ...
-    def enter_string(self, node: ast.String) -> None: ...
-    def enter_bool(self, node: ast.Bool) -> None: ...
-    def enter_builtin_type(self, node: ast.BuiltinType) -> None: ...
-    def enter_name(self, node: ast.Name) -> None: ...
-    def enter_in_for_stmt(self, node: ast.InForStmt) -> None: ...
-    def enter_delete_stmt(self, node: ast.DeleteStmt) -> None: ...
-    def enter_expr_as_item(self, node: ast.ExprAsItem) -> None: ...
diff --git a/jac/stubs/jaclang/compiler/passes/main/fuse_typeinfo_pass.pyi b/jac/stubs/jaclang/compiler/passes/main/fuse_typeinfo_pass.pyi
deleted file mode 100644
index f06f541119..0000000000
--- a/jac/stubs/jaclang/compiler/passes/main/fuse_typeinfo_pass.pyi
+++ /dev/null
@@ -1,66 +0,0 @@
-import jaclang.compiler.absyntree as ast
-import mypy.nodes as MypyNodes
-import mypy.types as MypyTypes
-from jaclang.compiler.passes import Pass as Pass
-from jaclang.compiler.symtable import SymbolTable as SymbolTable
-from jaclang.settings import settings as settings
-from jaclang.utils.helpers import pascal_to_snake as pascal_to_snake
-from jaclang.vendor.mypy.nodes import Node as VNode
-from mypy.checkexpr import Type as MyType
-from typing import TypeVar
-
-T = TypeVar("T", bound=ast.AstSymbolNode)
-
-class FuseTypeInfoPass(Pass):
-    node_type_hash: dict[MypyNodes.Node | VNode, MyType]
-    def enter_name(self, node: ast.NameAtom) -> None: ...
-    def enter_module_path(self, node: ast.ModulePath) -> None: ...
-    def enter_module_item(self, node: ast.ModuleItem) -> None: ...
-    def enter_architype(self, node: ast.Architype) -> None: ...
-    def enter_arch_def(self, node: ast.ArchDef) -> None: ...
-    def enter_enum(self, node: ast.Enum) -> None: ...
-    def enter_enum_def(self, node: ast.EnumDef) -> None: ...
-    def enter_ability(self, node: ast.Ability) -> None: ...
-    def enter_ability_def(self, node: ast.AbilityDef) -> None: ...
-    def enter_param_var(self, node: ast.ParamVar) -> None: ...
-    def enter_has_var(self, node: ast.HasVar) -> None: ...
-    def exit_has_var(self, node: ast.HasVar) -> None: ...
-    def enter_multi_string(self, node: ast.MultiString) -> None: ...
-    def enter_f_string(self, node: ast.FString) -> None: ...
-    def enter_list_val(self, node: ast.ListVal) -> None: ...
-    def enter_set_val(self, node: ast.SetVal) -> None: ...
-    def enter_tuple_val(self, node: ast.TupleVal) -> None: ...
-    def enter_dict_val(self, node: ast.DictVal) -> None: ...
-    def enter_list_compr(self, node: ast.ListCompr) -> None: ...
-    def enter_dict_compr(self, node: ast.DictCompr) -> None: ...
-    def enter_index_slice(self, node: ast.IndexSlice) -> None: ...
-    def enter_arch_ref(self, node: ast.ArchRef) -> None: ...
-    def enter_special_var_ref(self, node: ast.SpecialVarRef) -> None: ...
-    def enter_edge_op_ref(self, node: ast.EdgeOpRef) -> None: ...
-    def enter_filter_compr(self, node: ast.FilterCompr) -> None: ...
-    def enter_assign_compr(self, node: ast.AssignCompr) -> None: ...
-    def enter_int(self, node: ast.Int) -> None: ...
-    def enter_float(self, node: ast.Float) -> None: ...
-    def enter_string(self, node: ast.String) -> None: ...
-    def enter_bool(self, node: ast.Bool) -> None: ...
-    def enter_builtin_type(self, node: ast.BuiltinType) -> None: ...
-    def get_type_from_instance(
-        self, node: ast.AstSymbolNode, mypy_type: MypyTypes.Instance
-    ) -> None: ...
-    def get_type_from_callable_type(
-        self, node: ast.AstSymbolNode, mypy_type: MypyTypes.CallableType
-    ) -> None: ...
-    def get_type_from_overloaded(
-        self, node: ast.AstSymbolNode, mypy_type: MypyTypes.Overloaded
-    ) -> None: ...
-    def get_type_from_none_type(
-        self, node: ast.AstSymbolNode, mypy_type: MypyTypes.NoneType
-    ) -> None: ...
-    def get_type_from_any_type(
-        self, node: ast.AstSymbolNode, mypy_type: MypyTypes.AnyType
-    ) -> None: ...
-    def get_type_from_tuple_type(
-        self, node: ast.AstSymbolNode, mypy_type: MypyTypes.TupleType
-    ) -> None: ...
-    def exit_assignment(self, node: ast.Assignment) -> None: ...
-    def exit_name(self, node: ast.Name) -> None: ...
diff --git a/jac/stubs/jaclang/compiler/passes/main/import_pass.pyi b/jac/stubs/jaclang/compiler/passes/main/import_pass.pyi
deleted file mode 100644
index 194b68d12a..0000000000
--- a/jac/stubs/jaclang/compiler/passes/main/import_pass.pyi
+++ /dev/null
@@ -1,34 +0,0 @@
-import jaclang.compiler.absyntree as ast
-from _typeshed import Incomplete
-from jaclang.compiler.passes import Pass as Pass
-from jaclang.compiler.passes.main import SubNodeTabPass as SubNodeTabPass
-from jaclang.settings import settings as settings
-from jaclang.utils.helpers import is_standard_lib_module as is_standard_lib_module
-from jaclang.utils.log import logging as logging
-
-logger: Incomplete
-
-class JacImportPass(Pass):
-    import_table: Incomplete
-    py_resolve_list: Incomplete
-    def before_pass(self) -> None: ...
-    cur_node: Incomplete
-    run_again: bool
-    def enter_module(self, node: ast.Module) -> None: ...
-    def process_import(self, node: ast.Module, i: ast.ModulePath) -> None: ...
-    def attach_mod_to_node(
-        self, node: ast.ModulePath | ast.ModuleItem, mod: ast.Module | None
-    ) -> None: ...
-    def enter_module_path(self, node: ast.ModulePath) -> None: ...
-    def enter_atom_trailer(self, node: ast.AtomTrailer) -> None: ...
-    def import_jac_module(self, node: ast.ModulePath) -> None: ...
-    def import_jac_mod_from_dir(self, target: str) -> ast.Module | None: ...
-    def import_jac_mod_from_file(self, target: str) -> ast.Module | None: ...
-
-class PyImportPass(JacImportPass):
-    def before_pass(self) -> None: ...
-    run_again: bool
-    def process_import(self, node: ast.Module, i: ast.ModulePath) -> None: ...
-    def import_py_module(
-        self, node: ast.ModulePath, mod_path: str
-    ) -> ast.Module | None: ...
diff --git a/jac/stubs/jaclang/compiler/passes/main/pyast_gen_pass.pyi b/jac/stubs/jaclang/compiler/passes/main/pyast_gen_pass.pyi
deleted file mode 100644
index 7f4ea9095d..0000000000
--- a/jac/stubs/jaclang/compiler/passes/main/pyast_gen_pass.pyi
+++ /dev/null
@@ -1,178 +0,0 @@
-import ast as ast3
-import jaclang.compiler.absyntree as ast
-from _typeshed import Incomplete
-from jaclang.compiler.constant import EdgeDir as EdgeDir
-from jaclang.compiler.passes import Pass as Pass
-from jaclang.runtimelib.utils import (
-    extract_params as extract_params,
-    extract_type as extract_type,
-    get_sem_scope as get_sem_scope,
-)
-from typing import Sequence, TypeVar
-
-T = TypeVar("T", bound=ast3.AST)
-
-class PyastGenPass(Pass):
-    debuginfo: Incomplete
-    already_added: Incomplete
-    preamble: Incomplete
-    def before_pass(self) -> None: ...
-    def enter_node(self, node: ast.AstNode) -> None: ...
-    def exit_node(self, node: ast.AstNode) -> None: ...
-    def needs_jac_import(self) -> None: ...
-    def needs_typing(self) -> None: ...
-    def needs_abc(self) -> None: ...
-    def needs_enum(self) -> None: ...
-    def needs_jac_feature(self) -> None: ...
-    def needs_dataclass(self) -> None: ...
-    def needs_dataclass_field(self) -> None: ...
-    def flatten(self, body: list[T | list[T] | None]) -> list[T]: ...
-    def sync(
-        self, py_node: T, jac_node: ast.AstNode | None = None, deep: bool = False
-    ) -> T: ...
-    def pyinline_sync(self, py_nodes: list[ast3.AST]) -> list[ast3.AST]: ...
-    def resolve_stmt_block(
-        self,
-        node: (
-            ast.SubNodeList[ast.CodeBlockStmt]
-            | ast.SubNodeList[ast.ArchBlockStmt]
-            | ast.SubNodeList[ast.EnumBlockStmt]
-            | None
-        ),
-        doc: ast.String | None = None,
-    ) -> list[ast3.AST]: ...
-    def sync_many(self, py_nodes: list[T], jac_node: ast.AstNode) -> list[T]: ...
-    def list_to_attrib(
-        self, attribute_list: list[str], sync_node_list: Sequence[ast.AstNode]
-    ) -> ast3.AST: ...
-    def exit_sub_tag(self, node: ast.SubTag[ast.T]) -> None: ...
-    def exit_sub_node_list(self, node: ast.SubNodeList[ast.T]) -> None: ...
-    def exit_module(self, node: ast.Module) -> None: ...
-    def exit_global_vars(self, node: ast.GlobalVars) -> None: ...
-    def exit_test(self, node: ast.Test) -> None: ...
-    def exit_module_code(self, node: ast.ModuleCode) -> None: ...
-    def exit_py_inline_code(self, node: ast.PyInlineCode) -> None: ...
-    def exit_import(self, node: ast.Import) -> None: ...
-    def exit_module_path(self, node: ast.ModulePath) -> None: ...
-    def exit_module_item(self, node: ast.ModuleItem) -> None: ...
-    def enter_architype(self, node: ast.Architype) -> None: ...
-    def exit_architype(self, node: ast.Architype) -> None: ...
-    def collect_events(
-        self, node: ast.Architype
-    ) -> tuple[list[ast3.AST], list[ast3.AST]]: ...
-    def exit_arch_def(self, node: ast.ArchDef) -> None: ...
-    def enter_enum(self, node: ast.Enum) -> None: ...
-    def exit_enum(self, node: ast.Enum) -> None: ...
-    def exit_enum_def(self, node: ast.EnumDef) -> None: ...
-    def enter_ability(self, node: ast.Ability) -> None: ...
-    def exit_ability(self, node: ast.Ability) -> None: ...
-    def gen_llm_body(self, node: ast.Ability) -> list[ast3.AST]: ...
-    def by_llm_call(
-        self,
-        model: ast3.AST,
-        model_params: dict[str, ast.Expr],
-        scope: ast3.AST,
-        inputs: Sequence[ast3.AST | None],
-        outputs: Sequence[ast3.AST | None] | ast3.Call,
-        action: ast3.AST | None,
-        include_info: list[tuple[str, ast3.AST]],
-        exclude_info: list[tuple[str, ast3.AST]],
-    ) -> ast3.Call: ...
-    def exit_ability_def(self, node: ast.AbilityDef) -> None: ...
-    def exit_func_signature(self, node: ast.FuncSignature) -> None: ...
-    def exit_event_signature(self, node: ast.EventSignature) -> None: ...
-    def exit_arch_ref(self, node: ast.ArchRef) -> None: ...
-    def exit_arch_ref_chain(self, node: ast.ArchRefChain) -> None: ...
-    def exit_param_var(self, node: ast.ParamVar) -> None: ...
-    def exit_arch_has(self, node: ast.ArchHas) -> None: ...
-    def exit_has_var(self, node: ast.HasVar) -> None: ...
-    def exit_typed_ctx_block(self, node: ast.TypedCtxBlock) -> None: ...
-    def exit_if_stmt(self, node: ast.IfStmt) -> None: ...
-    def exit_else_if(self, node: ast.ElseIf) -> None: ...
-    def exit_else_stmt(self, node: ast.ElseStmt) -> None: ...
-    def exit_expr_stmt(self, node: ast.ExprStmt) -> None: ...
-    def exit_try_stmt(self, node: ast.TryStmt) -> None: ...
-    def exit_except(self, node: ast.Except) -> None: ...
-    def exit_finally_stmt(self, node: ast.FinallyStmt) -> None: ...
-    def exit_iter_for_stmt(self, node: ast.IterForStmt) -> None: ...
-    def exit_in_for_stmt(self, node: ast.InForStmt) -> None: ...
-    def exit_while_stmt(self, node: ast.WhileStmt) -> None: ...
-    def exit_with_stmt(self, node: ast.WithStmt) -> None: ...
-    def exit_expr_as_item(self, node: ast.ExprAsItem) -> None: ...
-    def exit_raise_stmt(self, node: ast.RaiseStmt) -> None: ...
-    def exit_assert_stmt(self, node: ast.AssertStmt) -> None: ...
-    def exit_check_stmt(self, node: ast.CheckStmt) -> None: ...
-    def exit_ctrl_stmt(self, node: ast.CtrlStmt) -> None: ...
-    def exit_delete_stmt(self, node: ast.DeleteStmt) -> None: ...
-    def exit_report_stmt(self, node: ast.ReportStmt) -> None: ...
-    def exit_return_stmt(self, node: ast.ReturnStmt) -> None: ...
-    def exit_yield_expr(self, node: ast.YieldExpr) -> None: ...
-    def exit_ignore_stmt(self, node: ast.IgnoreStmt) -> None: ...
-    def exit_visit_stmt(self, node: ast.VisitStmt) -> None: ...
-    def exit_revisit_stmt(self, node: ast.RevisitStmt) -> None: ...
-    def exit_disengage_stmt(self, node: ast.DisengageStmt) -> None: ...
-    def exit_await_expr(self, node: ast.AwaitExpr) -> None: ...
-    def exit_global_stmt(self, node: ast.GlobalStmt) -> None: ...
-    def exit_non_local_stmt(self, node: ast.NonLocalStmt) -> None: ...
-    def exit_assignment(self, node: ast.Assignment) -> None: ...
-    def exit_binary_expr(self, node: ast.BinaryExpr) -> None: ...
-    def translate_jac_bin_op(self, node: ast.BinaryExpr) -> list[ast3.AST]: ...
-    def exit_compare_expr(self, node: ast.CompareExpr) -> None: ...
-    def exit_bool_expr(self, node: ast.BoolExpr) -> None: ...
-    def exit_lambda_expr(self, node: ast.LambdaExpr) -> None: ...
-    def exit_unary_expr(self, node: ast.UnaryExpr) -> None: ...
-    def exit_if_else_expr(self, node: ast.IfElseExpr) -> None: ...
-    def exit_multi_string(self, node: ast.MultiString) -> None: ...
-    def exit_f_string(self, node: ast.FString) -> None: ...
-    def exit_list_val(self, node: ast.ListVal) -> None: ...
-    def exit_set_val(self, node: ast.SetVal) -> None: ...
-    def exit_tuple_val(self, node: ast.TupleVal) -> None: ...
-    def exit_dict_val(self, node: ast.DictVal) -> None: ...
-    def exit_k_v_pair(self, node: ast.KVPair) -> None: ...
-    def exit_k_w_pair(self, node: ast.KWPair) -> None: ...
-    def exit_inner_compr(self, node: ast.InnerCompr) -> None: ...
-    def exit_list_compr(self, node: ast.ListCompr) -> None: ...
-    def exit_gen_compr(self, node: ast.GenCompr) -> None: ...
-    def exit_set_compr(self, node: ast.SetCompr) -> None: ...
-    def exit_dict_compr(self, node: ast.DictCompr) -> None: ...
-    def exit_atom_trailer(self, node: ast.AtomTrailer) -> None: ...
-    def exit_atom_unit(self, node: ast.AtomUnit) -> None: ...
-    def exit_func_call(self, node: ast.FuncCall) -> None: ...
-    def exit_index_slice(self, node: ast.IndexSlice) -> None: ...
-    def exit_special_var_ref(self, node: ast.SpecialVarRef) -> None: ...
-    def exit_edge_ref_trailer(self, node: ast.EdgeRefTrailer) -> None: ...
-    def exit_edge_op_ref(self, node: ast.EdgeOpRef) -> None: ...
-    def translate_edge_op_ref(
-        self,
-        loc: ast3.AST,
-        node: ast.EdgeOpRef,
-        targ: ast3.AST | None,
-        edges_only: bool,
-    ) -> ast3.AST: ...
-    def exit_disconnect_op(self, node: ast.DisconnectOp) -> None: ...
-    def exit_connect_op(self, node: ast.ConnectOp) -> None: ...
-    def exit_filter_compr(self, node: ast.FilterCompr) -> None: ...
-    def exit_assign_compr(self, node: ast.AssignCompr) -> None: ...
-    def exit_match_stmt(self, node: ast.MatchStmt) -> None: ...
-    def exit_match_case(self, node: ast.MatchCase) -> None: ...
-    def exit_match_or(self, node: ast.MatchOr) -> None: ...
-    def exit_match_as(self, node: ast.MatchAs) -> None: ...
-    def exit_match_wild(self, node: ast.MatchWild) -> None: ...
-    def exit_match_value(self, node: ast.MatchValue) -> None: ...
-    def exit_match_singleton(self, node: ast.MatchSingleton) -> None: ...
-    def exit_match_sequence(self, node: ast.MatchSequence) -> None: ...
-    def exit_match_mapping(self, node: ast.MatchMapping) -> None: ...
-    def exit_match_k_v_pair(self, node: ast.MatchKVPair) -> None: ...
-    def exit_match_star(self, node: ast.MatchStar) -> None: ...
-    def exit_match_arch(self, node: ast.MatchArch) -> None: ...
-    def exit_token(self, node: ast.Token) -> None: ...
-    def exit_name(self, node: ast.Name) -> None: ...
-    def exit_float(self, node: ast.Float) -> None: ...
-    def exit_int(self, node: ast.Int) -> None: ...
-    def exit_string(self, node: ast.String) -> None: ...
-    def exit_bool(self, node: ast.Bool) -> None: ...
-    def exit_builtin_type(self, node: ast.BuiltinType) -> None: ...
-    def exit_null(self, node: ast.Null) -> None: ...
-    def exit_ellipsis(self, node: ast.Ellipsis) -> None: ...
-    def exit_semi(self, node: ast.Semi) -> None: ...
-    def exit_comment_token(self, node: ast.CommentToken) -> None: ...
diff --git a/jac/stubs/jaclang/compiler/passes/main/pyast_load_pass.pyi b/jac/stubs/jaclang/compiler/passes/main/pyast_load_pass.pyi
deleted file mode 100644
index 28fa79c1f9..0000000000
--- a/jac/stubs/jaclang/compiler/passes/main/pyast_load_pass.pyi
+++ /dev/null
@@ -1,135 +0,0 @@
-import ast as py_ast
-import jaclang.compiler.absyntree as ast
-from _typeshed import Incomplete
-from jaclang.compiler.constant import Tokens as Tok
-from jaclang.compiler.passes.ir_pass import Pass as Pass
-from jaclang.utils.helpers import pascal_to_snake as pascal_to_snake
-from typing import TypeAlias, TypeVar
-
-T = TypeVar("T", bound=ast.AstNode)
-
-class PyastBuildPass(Pass[ast.PythonModuleAst]):
-    mod_path: Incomplete
-    def __init__(self, input_ir: ast.PythonModuleAst) -> None: ...
-    cur_node: Incomplete
-    def nu(self, node: T) -> T: ...
-    def pp(self, node: py_ast.AST) -> None: ...
-    def convert(self, node: py_ast.AST) -> ast.AstNode: ...
-    ir: Incomplete
-    def transform(self, ir: ast.PythonModuleAst) -> ast.Module: ...
-    def extract_with_entry(
-        self, body: list[ast.AstNode], exclude_types: TypeAlias = ...
-    ) -> list[T | ast.ModuleCode]: ...
-    def proc_module(self, node: py_ast.Module) -> ast.Module: ...
-    def proc_function_def(
-        self, node: py_ast.FunctionDef | py_ast.AsyncFunctionDef
-    ) -> ast.Ability: ...
-    def proc_async_function_def(self, node: py_ast.AsyncFunctionDef) -> ast.Ability: ...
-    def proc_class_def(self, node: py_ast.ClassDef) -> ast.Architype | ast.Enum: ...
-    def proc_return(self, node: py_ast.Return) -> ast.ReturnStmt | None: ...
-    def proc_delete(self, node: py_ast.Delete) -> ast.DeleteStmt: ...
-    def proc_assign(self, node: py_ast.Assign) -> ast.Assignment: ...
-    def proc_aug_assign(self, node: py_ast.AugAssign) -> ast.Assignment: ...
-    def proc_ann_assign(self, node: py_ast.AnnAssign) -> ast.Assignment: ...
-    def proc_for(self, node: py_ast.For) -> ast.InForStmt: ...
-    def proc_async_for(self, node: py_ast.AsyncFor) -> ast.InForStmt: ...
-    def proc_while(self, node: py_ast.While) -> ast.WhileStmt: ...
-    def proc_if(self, node: py_ast.If) -> ast.IfStmt: ...
-    def proc_with(self, node: py_ast.With) -> ast.WithStmt: ...
-    def proc_async_with(self, node: py_ast.AsyncWith) -> ast.WithStmt: ...
-    def proc_raise(self, node: py_ast.Raise) -> ast.RaiseStmt: ...
-    def proc_assert(self, node: py_ast.Assert) -> ast.AssertStmt: ...
-    def proc_attribute(self, node: py_ast.Attribute) -> ast.AtomTrailer: ...
-    def proc_await(self, node: py_ast.Await) -> ast.AwaitExpr: ...
-    def proc_bin_op(self, node: py_ast.BinOp) -> ast.AtomUnit: ...
-    def proc_unary_op(self, node: py_ast.UnaryOp) -> ast.UnaryExpr: ...
-    def proc_bool_op(self, node: py_ast.BoolOp) -> ast.BoolExpr: ...
-    def proc_break(self, node: py_ast.Break) -> ast.CtrlStmt: ...
-    def proc_call(self, node: py_ast.Call) -> ast.FuncCall: ...
-    def proc_compare(self, node: py_ast.Compare) -> ast.CompareExpr: ...
-    def proc_constant(self, node: py_ast.Constant) -> ast.Literal: ...
-    def proc_continue(self, node: py_ast.Continue) -> ast.CtrlStmt: ...
-    def proc_dict(self, node: py_ast.Dict) -> ast.DictVal: ...
-    def proc_dict_comp(self, node: py_ast.DictComp) -> ast.DictCompr: ...
-    def proc_ellipsis(self, node: py_ast.Ellipsis) -> None: ...
-    def proc_except_handler(self, node: py_ast.ExceptHandler) -> ast.Except: ...
-    def proc_expr(self, node: py_ast.Expr) -> ast.ExprStmt: ...
-    def proc_formatted_value(self, node: py_ast.FormattedValue) -> ast.ExprStmt: ...
-    def proc_function_type(self, node: py_ast.FunctionType) -> None: ...
-    def proc_generator_exp(self, node: py_ast.GeneratorExp) -> ast.GenCompr: ...
-    def proc_global(self, node: py_ast.Global) -> ast.GlobalStmt: ...
-    def proc_if_exp(self, node: py_ast.IfExp) -> ast.IfElseExpr: ...
-    def proc_import(self, node: py_ast.Import) -> ast.Import: ...
-    def proc_import_from(self, node: py_ast.ImportFrom) -> ast.Import: ...
-    def proc_joined_str(self, node: py_ast.JoinedStr) -> ast.FString: ...
-    def proc_lambda(self, node: py_ast.Lambda) -> ast.LambdaExpr: ...
-    def proc_list(self, node: py_ast.List) -> ast.ListVal: ...
-    def proc_list_comp(self, node: py_ast.ListComp) -> ast.ListCompr: ...
-    def proc_match(self, node: py_ast.Match) -> ast.MatchStmt: ...
-    def proc_match_as(self, node: py_ast.MatchAs) -> ast.MatchAs | ast.MatchWild: ...
-    def proc_match_class(self, node: py_ast.MatchClass) -> ast.MatchArch: ...
-    def proc_match_mapping(self, node: py_ast.MatchMapping) -> ast.MatchMapping: ...
-    def proc_match_or(self, node: py_ast.MatchOr) -> ast.MatchOr: ...
-    def proc_match_sequence(self, node: py_ast.MatchSequence) -> ast.MatchSequence: ...
-    def proc_match_singleton(
-        self, node: py_ast.MatchSingleton
-    ) -> ast.MatchSingleton: ...
-    def proc_match_star(self, node: py_ast.MatchStar) -> ast.MatchStar: ...
-    def proc_match_value(self, node: py_ast.MatchValue) -> ast.MatchValue: ...
-    def proc_name(self, node: py_ast.Name) -> ast.Name: ...
-    def proc_named_expr(self, node: py_ast.NamedExpr) -> ast.BinaryExpr: ...
-    def proc_nonlocal(self, node: py_ast.Nonlocal) -> ast.NonLocalStmt: ...
-    def proc_pass(self, node: py_ast.Pass) -> ast.Semi: ...
-    def proc_set(self, node: py_ast.Set) -> ast.SetVal: ...
-    def proc_set_comp(self, node: py_ast.SetComp) -> ast.ListCompr: ...
-    def proc_slice(self, node: py_ast.Slice) -> ast.IndexSlice: ...
-    def proc_starred(self, node: py_ast.Starred) -> ast.UnaryExpr: ...
-    def proc_subscript(self, node: py_ast.Subscript) -> ast.AtomTrailer: ...
-    def proc_try(self, node: py_ast.Try | py_ast.TryStar) -> ast.TryStmt: ...
-    def proc_try_star(self, node: py_ast.TryStar) -> ast.TryStmt: ...
-    def proc_tuple(self, node: py_ast.Tuple) -> ast.TupleVal: ...
-    def proc_yield(self, node: py_ast.Yield) -> ast.YieldExpr: ...
-    def proc_yield_from(self, node: py_ast.YieldFrom) -> ast.YieldExpr: ...
-    def proc_alias(self, node: py_ast.alias) -> ast.ExprAsItem: ...
-    def proc_arg(self, node: py_ast.arg) -> ast.ParamVar: ...
-    def proc_arguments(self, node: py_ast.arguments) -> ast.FuncSignature: ...
-    def operator(self, tok: Tok, value: str) -> ast.Token: ...
-    def proc_and(self, node: py_ast.And) -> ast.Token: ...
-    def proc_or(self, node: py_ast.Or) -> ast.Token: ...
-    def proc_add(self, node: py_ast.Add) -> ast.Token: ...
-    def proc_bit_and(self, node: py_ast.BitAnd) -> ast.Token: ...
-    def proc_bit_or(self, node: py_ast.BitOr) -> ast.Token: ...
-    def proc_bit_xor(self, node: py_ast.BitXor) -> ast.Token: ...
-    def proc_div(self, node: py_ast.Div) -> ast.Token: ...
-    def proc_floor_div(self, node: py_ast.FloorDiv) -> ast.Token: ...
-    def proc_l_shift(self, node: py_ast.LShift) -> ast.Token: ...
-    def proc_mod(self, node: py_ast.Mod) -> ast.Token: ...
-    def proc_mult(self, node: py_ast.Mult) -> ast.Token: ...
-    def proc_mat_mult(self, node: py_ast.MatMult) -> ast.Token: ...
-    def proc_pow(self, node: py_ast.Pow) -> ast.Token: ...
-    def proc_r_shift(self, node: py_ast.RShift) -> ast.Token: ...
-    def proc_sub(self, node: py_ast.Sub) -> ast.Token: ...
-    def proc_invert(self, node: py_ast.Invert) -> ast.Token: ...
-    def proc_not(self, node: py_ast.Not) -> ast.Token: ...
-    def proc_u_add(self, node: py_ast.UAdd) -> ast.Token: ...
-    def proc_u_sub(self, node: py_ast.USub) -> ast.Token: ...
-    def proc_eq(self, node: py_ast.Eq) -> ast.Token: ...
-    def proc_gt(self, node: py_ast.Gt) -> ast.Token: ...
-    def proc_gt_e(self, node: py_ast.GtE) -> ast.Token: ...
-    def proc_in(self, node: py_ast.In) -> ast.Token: ...
-    def proc_is(self, node: py_ast.Is) -> ast.Token: ...
-    def proc_is_not(self, node: py_ast.IsNot) -> ast.Token: ...
-    def proc_lt(self, node: py_ast.Lt) -> ast.Token: ...
-    def proc_lt_e(self, node: py_ast.LtE) -> ast.Token: ...
-    def proc_not_eq(self, node: py_ast.NotEq) -> ast.Token: ...
-    def proc_not_in(self, node: py_ast.NotIn) -> ast.Token: ...
-    def proc_comprehension(self, node: py_ast.comprehension) -> ast.InnerCompr: ...
-    def proc_keyword(self, node: py_ast.keyword) -> ast.KWPair: ...
-    def proc_match_case(self, node: py_ast.match_case) -> ast.MatchCase: ...
-    def proc_withitem(self, node: py_ast.withitem) -> ast.ExprAsItem: ...
-    def proc_param_spec(self, node: py_ast.ParamSpec) -> None: ...
-    def proc_type_alias(self, node: py_ast.TypeAlias) -> None: ...
-    def proc_type_var(self, node: py_ast.TypeVar) -> None: ...
-    def proc_type_var_tuple(self, node: py_ast.TypeVarTuple) -> None: ...
-    def convert_to_doc(self, string: ast.String) -> None: ...
-    def aug_op_map(self, tok_dict: dict, op: ast.Token) -> str: ...
diff --git a/jac/stubs/jaclang/compiler/passes/main/pybc_gen_pass.pyi b/jac/stubs/jaclang/compiler/passes/main/pybc_gen_pass.pyi
deleted file mode 100644
index e394a9c61c..0000000000
--- a/jac/stubs/jaclang/compiler/passes/main/pybc_gen_pass.pyi
+++ /dev/null
@@ -1,6 +0,0 @@
-import jaclang.compiler.absyntree as ast
-from jaclang.compiler.passes import Pass as Pass
-
-class PyBytecodeGenPass(Pass):
-    def before_pass(self) -> None: ...
-    def enter_module(self, node: ast.Module) -> None: ...
diff --git a/jac/stubs/jaclang/compiler/passes/main/pyjac_ast_link_pass.pyi b/jac/stubs/jaclang/compiler/passes/main/pyjac_ast_link_pass.pyi
deleted file mode 100644
index fa6590d23d..0000000000
--- a/jac/stubs/jaclang/compiler/passes/main/pyjac_ast_link_pass.pyi
+++ /dev/null
@@ -1,22 +0,0 @@
-import ast as ast3
-import jaclang.compiler.absyntree as ast
-from jaclang.compiler.passes import Pass as Pass
-
-class PyJacAstLinkPass(Pass):
-    def link_jac_py_nodes(
-        self, jac_node: ast.AstNode, py_nodes: list[ast3.AST]
-    ) -> None: ...
-    def exit_module_path(self, node: ast.ModulePath) -> None: ...
-    def exit_architype(self, node: ast.Architype) -> None: ...
-    def exit_arch_def(self, node: ast.ArchDef) -> None: ...
-    def exit_enum(self, node: ast.Enum) -> None: ...
-    def exit_enum_def(self, node: ast.EnumDef) -> None: ...
-    def exit_ability(self, node: ast.Ability) -> None: ...
-    def exit_ability_def(self, node: ast.AbilityDef) -> None: ...
-    def exit_param_var(self, node: ast.ParamVar) -> None: ...
-    def exit_except(self, node: ast.Except) -> None: ...
-    def exit_expr_as_item(self, node: ast.ExprAsItem) -> None: ...
-    def exit_global_stmt(self, node: ast.GlobalStmt) -> None: ...
-    def exit_non_local_stmt(self, node: ast.NonLocalStmt) -> None: ...
-    def exit_k_w_pair(self, node: ast.KWPair) -> None: ...
-    def exit_atom_trailer(self, node: ast.AtomTrailer) -> None: ...
diff --git a/jac/stubs/jaclang/compiler/passes/main/pyout_pass.pyi b/jac/stubs/jaclang/compiler/passes/main/pyout_pass.pyi
deleted file mode 100644
index e5d6057e8f..0000000000
--- a/jac/stubs/jaclang/compiler/passes/main/pyout_pass.pyi
+++ /dev/null
@@ -1,9 +0,0 @@
-import jaclang.compiler.absyntree as ast
-from jaclang.compiler.passes import Pass as Pass
-
-class PyOutPass(Pass):
-    def before_pass(self) -> None: ...
-    def enter_module(self, node: ast.Module) -> None: ...
-    def gen_python(self, node: ast.Module, out_path: str) -> None: ...
-    def dump_bytecode(self, node: ast.Module, mod_path: str, out_path: str) -> None: ...
-    def get_output_targets(self, node: ast.Module) -> tuple[str, str, str]: ...
diff --git a/jac/stubs/jaclang/compiler/passes/main/registry_pass.pyi b/jac/stubs/jaclang/compiler/passes/main/registry_pass.pyi
deleted file mode 100644
index 7842db541d..0000000000
--- a/jac/stubs/jaclang/compiler/passes/main/registry_pass.pyi
+++ /dev/null
@@ -1,15 +0,0 @@
-import jaclang.compiler.absyntree as ast
-from jaclang.compiler.passes import Pass as Pass
-from jaclang.compiler.semtable import SemInfo as SemInfo, SemRegistry as SemRegistry
-from jaclang.runtimelib.utils import get_sem_scope as get_sem_scope
-
-class RegistryPass(Pass):
-    modules_visited: list[ast.Module]
-    def enter_module(self, node: ast.Module) -> None: ...
-    def exit_module(self, node: ast.Module) -> None: ...
-    def exit_architype(self, node: ast.Architype) -> None: ...
-    def exit_enum(self, node: ast.Enum) -> None: ...
-    def exit_has_var(self, node: ast.HasVar) -> None: ...
-    def exit_assignment(self, node: ast.Assignment) -> None: ...
-    def exit_name(self, node: ast.Name) -> None: ...
-    def extract_type(self, node: ast.AstNode) -> list[str]: ...
diff --git a/jac/stubs/jaclang/compiler/passes/main/schedules.pyi b/jac/stubs/jaclang/compiler/passes/main/schedules.pyi
deleted file mode 100644
index 305d5e2e61..0000000000
--- a/jac/stubs/jaclang/compiler/passes/main/schedules.pyi
+++ /dev/null
@@ -1,19 +0,0 @@
-from .access_modifier_pass import AccessCheckPass as AccessCheckPass
-from .def_impl_match_pass import DeclImplMatchPass as DeclImplMatchPass
-from .def_use_pass import DefUsePass as DefUsePass
-from .fuse_typeinfo_pass import FuseTypeInfoPass as FuseTypeInfoPass
-from .import_pass import JacImportPass as JacImportPass, PyImportPass as PyImportPass
-from .pyast_gen_pass import PyastGenPass as PyastGenPass
-from .pybc_gen_pass import PyBytecodeGenPass as PyBytecodeGenPass
-from .pyjac_ast_link_pass import PyJacAstLinkPass as PyJacAstLinkPass
-from .pyout_pass import PyOutPass as PyOutPass
-from .registry_pass import RegistryPass as RegistryPass
-from .sub_node_tab_pass import SubNodeTabPass as SubNodeTabPass
-from .sym_tab_build_pass import SymTabBuildPass as SymTabBuildPass
-from .type_check_pass import JacTypeCheckPass as JacTypeCheckPass
-from _typeshed import Incomplete
-
-py_code_gen: Incomplete
-type_checker_sched: Incomplete
-py_code_gen_typed: Incomplete
-py_compiler: Incomplete
diff --git a/jac/stubs/jaclang/compiler/passes/main/sub_node_tab_pass.pyi b/jac/stubs/jaclang/compiler/passes/main/sub_node_tab_pass.pyi
deleted file mode 100644
index ab79bf23ea..0000000000
--- a/jac/stubs/jaclang/compiler/passes/main/sub_node_tab_pass.pyi
+++ /dev/null
@@ -1,6 +0,0 @@
-import jaclang.compiler.absyntree as ast
-from jaclang.compiler.passes import Pass as Pass
-
-class SubNodeTabPass(Pass):
-    def enter_node(self, node: ast.AstNode) -> None: ...
-    def exit_node(self, node: ast.AstNode) -> None: ...
diff --git a/jac/stubs/jaclang/compiler/passes/main/sym_tab_build_pass.pyi b/jac/stubs/jaclang/compiler/passes/main/sym_tab_build_pass.pyi
deleted file mode 100644
index e285a5c27a..0000000000
--- a/jac/stubs/jaclang/compiler/passes/main/sym_tab_build_pass.pyi
+++ /dev/null
@@ -1,147 +0,0 @@
-import jaclang.compiler.absyntree as ast
-from _typeshed import Incomplete
-from jaclang.compiler.passes import Pass as Pass
-from jaclang.compiler.symtable import SymbolTable as SymbolTable
-
-class SymTabBuildPass(Pass):
-    cur_sym_tab: Incomplete
-    def before_pass(self) -> None: ...
-    def push_scope(
-        self, name: str, key_node: ast.AstNode, fresh: bool = False
-    ) -> None: ...
-    def pop_scope(self) -> SymbolTable: ...
-    @property
-    def cur_scope(self) -> SymbolTable: ...
-    def sync_node_to_scope(self, node: ast.AstNode) -> None: ...
-    def enter_module(self, node: ast.Module) -> None: ...
-    def exit_module(self, node: ast.Module) -> None: ...
-    def enter_global_vars(self, node: ast.GlobalVars) -> None: ...
-    def exit_global_vars(self, node: ast.GlobalVars) -> None: ...
-    def enter_sub_tag(self, node: ast.SubTag) -> None: ...
-    def enter_sub_node_list(self, node: ast.SubNodeList) -> None: ...
-    def enter_test(self, node: ast.Test) -> None: ...
-    def exit_test(self, node: ast.Test) -> None: ...
-    def enter_module_code(self, node: ast.ModuleCode) -> None: ...
-    def exit_module_code(self, node: ast.ModuleCode) -> None: ...
-    def enter_py_inline_code(self, node: ast.PyInlineCode) -> None: ...
-    def enter_import(self, node: ast.Import) -> None: ...
-    def exit_import(self, node: ast.Import) -> None: ...
-    def enter_module_path(self, node: ast.ModulePath) -> None: ...
-    def exit_module_path(self, node: ast.ModulePath) -> None: ...
-    def enter_module_item(self, node: ast.ModuleItem) -> None: ...
-    def enter_architype(self, node: ast.Architype) -> None: ...
-    def exit_architype(self, node: ast.Architype) -> None: ...
-    def enter_arch_def(self, node: ast.ArchDef) -> None: ...
-    def exit_arch_def(self, node: ast.ArchDef) -> None: ...
-    def enter_ability(self, node: ast.Ability) -> None: ...
-    def exit_ability(self, node: ast.Ability) -> None: ...
-    def enter_ability_def(self, node: ast.AbilityDef) -> None: ...
-    def exit_ability_def(self, node: ast.AbilityDef) -> None: ...
-    def enter_event_signature(self, node: ast.EventSignature) -> None: ...
-    def enter_arch_ref_chain(self, node: ast.ArchRefChain) -> None: ...
-    def enter_func_signature(self, node: ast.FuncSignature) -> None: ...
-    def enter_param_var(self, node: ast.ParamVar) -> None: ...
-    def enter_enum(self, node: ast.Enum) -> None: ...
-    def exit_enum(self, node: ast.Enum) -> None: ...
-    def enter_enum_def(self, node: ast.EnumDef) -> None: ...
-    def exit_enum_def(self, node: ast.EnumDef) -> None: ...
-    def enter_arch_has(self, node: ast.ArchHas) -> None: ...
-    def enter_has_var(self, node: ast.HasVar) -> None: ...
-    def enter_typed_ctx_block(self, node: ast.TypedCtxBlock) -> None: ...
-    def exit_typed_ctx_block(self, node: ast.TypedCtxBlock) -> None: ...
-    def enter_if_stmt(self, node: ast.IfStmt) -> None: ...
-    def exit_if_stmt(self, node: ast.IfStmt) -> None: ...
-    def enter_else_if(self, node: ast.ElseIf) -> None: ...
-    def exit_else_if(self, node: ast.ElseIf) -> None: ...
-    def enter_else_stmt(self, node: ast.ElseStmt) -> None: ...
-    def exit_else_stmt(self, node: ast.ElseStmt) -> None: ...
-    def enter_expr_stmt(self, node: ast.ExprStmt) -> None: ...
-    def enter_try_stmt(self, node: ast.TryStmt) -> None: ...
-    def exit_try_stmt(self, node: ast.TryStmt) -> None: ...
-    def enter_except(self, node: ast.Except) -> None: ...
-    def exit_except(self, node: ast.Except) -> None: ...
-    def enter_finally_stmt(self, node: ast.FinallyStmt) -> None: ...
-    def exit_finally_stmt(self, node: ast.FinallyStmt) -> None: ...
-    def enter_iter_for_stmt(self, node: ast.IterForStmt) -> None: ...
-    def exit_iter_for_stmt(self, node: ast.IterForStmt) -> None: ...
-    def enter_in_for_stmt(self, node: ast.InForStmt) -> None: ...
-    def exit_in_for_stmt(self, node: ast.InForStmt) -> None: ...
-    def enter_name(self, node: ast.Name) -> None: ...
-    def enter_while_stmt(self, node: ast.WhileStmt) -> None: ...
-    def exit_while_stmt(self, node: ast.WhileStmt) -> None: ...
-    def enter_with_stmt(self, node: ast.WithStmt) -> None: ...
-    def exit_with_stmt(self, node: ast.WithStmt) -> None: ...
-    def enter_expr_as_item(self, node: ast.ExprAsItem) -> None: ...
-    def enter_raise_stmt(self, node: ast.RaiseStmt) -> None: ...
-    def enter_assert_stmt(self, node: ast.AssertStmt) -> None: ...
-    def enter_check_stmt(self, node: ast.CheckStmt) -> None: ...
-    def enter_ctrl_stmt(self, node: ast.CtrlStmt) -> None: ...
-    def enter_delete_stmt(self, node: ast.DeleteStmt) -> None: ...
-    def enter_report_stmt(self, node: ast.ReportStmt) -> None: ...
-    def enter_return_stmt(self, node: ast.ReturnStmt) -> None: ...
-    def enter_yield_expr(self, node: ast.YieldExpr) -> None: ...
-    def enter_ignore_stmt(self, node: ast.IgnoreStmt) -> None: ...
-    def enter_visit_stmt(self, node: ast.VisitStmt) -> None: ...
-    def enter_revisit_stmt(self, node: ast.RevisitStmt) -> None: ...
-    def enter_disengage_stmt(self, node: ast.DisengageStmt) -> None: ...
-    def enter_await_expr(self, node: ast.AwaitExpr) -> None: ...
-    def enter_global_stmt(self, node: ast.GlobalStmt) -> None: ...
-    def enter_non_local_stmt(self, node: ast.NonLocalStmt) -> None: ...
-    def enter_assignment(self, node: ast.Assignment) -> None: ...
-    def enter_binary_expr(self, node: ast.BinaryExpr) -> None: ...
-    def enter_compare_expr(self, node: ast.CompareExpr) -> None: ...
-    def enter_if_else_expr(self, node: ast.IfElseExpr) -> None: ...
-    def enter_unary_expr(self, node: ast.UnaryExpr) -> None: ...
-    def enter_bool_expr(self, node: ast.BoolExpr) -> None: ...
-    def enter_lambda_expr(self, node: ast.LambdaExpr) -> None: ...
-    def exit_lambda_expr(self, node: ast.LambdaExpr) -> None: ...
-    def enter_multi_string(self, node: ast.MultiString) -> None: ...
-    def enter_list_val(self, node: ast.ListVal) -> None: ...
-    def enter_set_val(self, node: ast.SetVal) -> None: ...
-    def enter_tuple_val(self, node: ast.TupleVal) -> None: ...
-    def enter_dict_val(self, node: ast.DictVal) -> None: ...
-    def enter_k_v_pair(self, node: ast.KVPair) -> None: ...
-    def enter_k_w_pair(self, node: ast.KWPair) -> None: ...
-    def enter_list_compr(self, node: ast.ListCompr) -> None: ...
-    def enter_gen_compr(self, node: ast.GenCompr) -> None: ...
-    def enter_set_compr(self, node: ast.SetCompr) -> None: ...
-    def enter_inner_compr(self, node: ast.InnerCompr) -> None: ...
-    def exit_inner_compr(self, node: ast.InnerCompr) -> None: ...
-    def enter_dict_compr(self, node: ast.DictCompr) -> None: ...
-    def exit_dict_compr(self, node: ast.DictCompr) -> None: ...
-    def enter_atom_trailer(self, node: ast.AtomTrailer) -> None: ...
-    def enter_atom_unit(self, node: ast.AtomUnit) -> None: ...
-    def enter_func_call(self, node: ast.FuncCall) -> None: ...
-    def enter_index_slice(self, node: ast.IndexSlice) -> None: ...
-    def enter_arch_ref(self, node: ast.ArchRef) -> None: ...
-    def enter_special_var_ref(self, node: ast.SpecialVarRef) -> None: ...
-    def enter_edge_ref_trailer(self, node: ast.EdgeRefTrailer) -> None: ...
-    def enter_edge_op_ref(self, node: ast.EdgeOpRef) -> None: ...
-    def enter_disconnect_op(self, node: ast.DisconnectOp) -> None: ...
-    def enter_connect_op(self, node: ast.ConnectOp) -> None: ...
-    def enter_filter_compr(self, node: ast.FilterCompr) -> None: ...
-    def enter_assign_compr(self, node: ast.AssignCompr) -> None: ...
-    def enter_f_string(self, node: ast.FString) -> None: ...
-    def enter_match_stmt(self, node: ast.MatchStmt) -> None: ...
-    def enter_match_case(self, node: ast.MatchCase) -> None: ...
-    def exit_match_case(self, node: ast.MatchCase) -> None: ...
-    def enter_match_or(self, node: ast.MatchOr) -> None: ...
-    def enter_match_as(self, node: ast.MatchAs) -> None: ...
-    def enter_match_wild(self, node: ast.MatchWild) -> None: ...
-    def enter_match_value(self, node: ast.MatchValue) -> None: ...
-    def enter_match_singleton(self, node: ast.MatchSingleton) -> None: ...
-    def enter_match_sequence(self, node: ast.MatchSequence) -> None: ...
-    def enter_match_mapping(self, node: ast.MatchMapping) -> None: ...
-    def enter_match_k_v_pair(self, node: ast.MatchKVPair) -> None: ...
-    def enter_match_star(self, node: ast.MatchStar) -> None: ...
-    def enter_match_arch(self, node: ast.MatchArch) -> None: ...
-    def enter_token(self, node: ast.Token) -> None: ...
-    def enter_float(self, node: ast.Float) -> None: ...
-    def enter_int(self, node: ast.Int) -> None: ...
-    def enter_string(self, node: ast.String) -> None: ...
-    def enter_bool(self, node: ast.Bool) -> None: ...
-    def enter_null(self, node: ast.Null) -> None: ...
-    def enter_ellipsis(self, node: ast.Ellipsis) -> None: ...
-    def enter_builtin_type(self, node: ast.BuiltinType) -> None: ...
-    def enter_semi(self, node: ast.Semi) -> None: ...
-    def enter_comment_token(self, node: ast.CommentToken) -> None: ...
diff --git a/jac/stubs/jaclang/compiler/passes/main/type_check_pass.pyi b/jac/stubs/jaclang/compiler/passes/main/type_check_pass.pyi
deleted file mode 100644
index 0eb7458e8e..0000000000
--- a/jac/stubs/jaclang/compiler/passes/main/type_check_pass.pyi
+++ /dev/null
@@ -1,11 +0,0 @@
-import jaclang.compiler.absyntree as ast
-from jaclang.compiler.passes import Pass as Pass
-
-class JacTypeCheckPass(Pass):
-    def before_pass(self) -> None: ...
-    def enter_module(self, node: ast.Module) -> None: ...
-    def after_pass(self) -> None: ...
-    def default_message_cb(
-        self, filename: str | None, new_messages: list[str], is_serious: bool
-    ) -> None: ...
-    def api(self) -> None: ...
diff --git a/jac/stubs/jaclang/compiler/passes/tool/__init__.pyi b/jac/stubs/jaclang/compiler/passes/tool/__init__.pyi
deleted file mode 100644
index 8d74596863..0000000000
--- a/jac/stubs/jaclang/compiler/passes/tool/__init__.pyi
+++ /dev/null
@@ -1,4 +0,0 @@
-from .fuse_comments_pass import FuseCommentsPass as FuseCommentsPass
-from .jac_formatter_pass import JacFormatPass as JacFormatPass
-
-__all__ = ["FuseCommentsPass", "JacFormatPass"]
diff --git a/jac/stubs/jaclang/compiler/passes/tool/fuse_comments_pass.pyi b/jac/stubs/jaclang/compiler/passes/tool/fuse_comments_pass.pyi
deleted file mode 100644
index 2f6002051d..0000000000
--- a/jac/stubs/jaclang/compiler/passes/tool/fuse_comments_pass.pyi
+++ /dev/null
@@ -1,12 +0,0 @@
-import jaclang.compiler.absyntree as ast
-from _typeshed import Incomplete
-from jaclang.compiler.passes import Pass as Pass
-
-class FuseCommentsPass(Pass):
-    all_tokens: Incomplete
-    comments: Incomplete
-    def before_pass(self) -> None: ...
-    def exit_node(self, node: ast.AstNode) -> None: ...
-    def after_pass(self) -> None: ...
-
-def is_comment_next(cmt: ast.CommentToken, code: ast.Token) -> bool: ...
diff --git a/jac/stubs/jaclang/compiler/passes/tool/jac_formatter_pass.pyi b/jac/stubs/jaclang/compiler/passes/tool/jac_formatter_pass.pyi
deleted file mode 100644
index 1f86554c26..0000000000
--- a/jac/stubs/jaclang/compiler/passes/tool/jac_formatter_pass.pyi
+++ /dev/null
@@ -1,134 +0,0 @@
-import jaclang.compiler.absyntree as ast
-from _typeshed import Incomplete
-from jaclang.compiler.absyntree import AstNode as AstNode
-from jaclang.compiler.passes import Pass as Pass
-from jaclang.settings import settings as settings
-
-class JacFormatPass(Pass):
-    comments: Incomplete
-    indent_size: int
-    indent_level: int
-    MAX_LINE_LENGTH: Incomplete
-    def before_pass(self) -> None: ...
-    def enter_node(self, node: ast.AstNode) -> None: ...
-    def token_before(self, node: ast.Token) -> ast.Token | None: ...
-    def token_after(self, node: ast.Token) -> ast.Token | None: ...
-    def indent_str(self) -> str: ...
-    def emit(self, node: ast.AstNode, s: str, strip_mode: bool = True) -> None: ...
-    def emit_ln(self, node: ast.AstNode, s: str) -> None: ...
-    def comma_sep_node_list(self, node: ast.SubNodeList) -> str: ...
-    def dot_sep_node_list(self, node: ast.SubNodeList) -> str: ...
-    def nl_sep_node_list(self, node: ast.SubNodeList) -> str: ...
-    def sep_node_list(self, node: ast.SubNodeList, delim: str = " ") -> str: ...
-    def enter_module(self, node: ast.Module) -> None: ...
-    def exit_module(self, node: ast.Module) -> None: ...
-    def exit_global_vars(self, node: ast.GlobalVars) -> None: ...
-    def exit_module_code(self, node: ast.ModuleCode) -> None: ...
-    def exit_sub_node_list(self, node: ast.SubNodeList) -> None: ...
-    def exit_sub_tag(self, node: ast.SubTag) -> None: ...
-    def exit_func_call(self, node: ast.FuncCall) -> None: ...
-    def exit_multi_string(self, node: ast.MultiString) -> None: ...
-    def exit_module_path(self, node: ast.ModulePath) -> None: ...
-    def exit_tuple_val(self, node: ast.TupleVal) -> None: ...
-    def exit_special_var_ref(self, node: ast.SpecialVarRef) -> None: ...
-    def exit_ability_def(self, node: ast.AbilityDef) -> None: ...
-    def exit_event_signature(self, node: ast.EventSignature) -> None: ...
-    def exit_import(self, node: ast.Import) -> None: ...
-    def exit_arch_def(self, node: ast.ArchDef) -> None: ...
-    def exit_ability(self, node: ast.Ability) -> None: ...
-    def exit_func_signature(self, node: ast.FuncSignature) -> None: ...
-    def exit_arch_has(self, node: ast.ArchHas) -> None: ...
-    def exit_arch_ref(self, node: ast.ArchRef) -> None: ...
-    def exit_param_var(self, node: ast.ParamVar) -> None: ...
-    def exit_enum(self, node: ast.Enum) -> None: ...
-    def exit_enum_def(self, node: ast.EnumDef) -> None: ...
-    def exit_atom_trailer(self, node: ast.AtomTrailer) -> None: ...
-    def exit_atom_unit(self, node: ast.AtomUnit) -> None: ...
-    def exit_yield_expr(self, node: ast.YieldExpr) -> None: ...
-    def is_line_break_needed(self, content: str, max_line_length: int = 0) -> bool: ...
-    def exit_binary_expr(self, node: ast.BinaryExpr) -> None: ...
-    def exit_compare_expr(self, node: ast.CompareExpr) -> None: ...
-    def exit_has_var(self, node: ast.HasVar) -> None: ...
-    def exit_if_stmt(self, node: ast.IfStmt) -> None: ...
-    def exit_else_if(self, node: ast.ElseIf) -> None: ...
-    def exit_disengage_stmt(self, node: ast.DisengageStmt) -> None: ...
-    def exit_else_stmt(self, node: ast.ElseStmt) -> None: ...
-    def exit_expr_stmt(self, node: ast.ExprStmt) -> None: ...
-    def exit_iter_for_stmt(self, node: ast.IterForStmt) -> None: ...
-    def exit_try_stmt(self, node: ast.TryStmt) -> None: ...
-    def exit_except(self, node: ast.Except) -> None: ...
-    def exit_finally_stmt(self, node: ast.FinallyStmt) -> None: ...
-    def exit_while_stmt(self, node: ast.WhileStmt) -> None: ...
-    def exit_with_stmt(self, node: ast.WithStmt) -> None: ...
-    def exit_module_item(self, node: ast.ModuleItem) -> None: ...
-    def exit_global_stmt(self, node: ast.GlobalStmt) -> None: ...
-    def exit_non_local_stmt(self, node: ast.GlobalStmt) -> None: ...
-    def handle_long_assignment(
-        self, node: ast.Assignment, kid: ast.AstNode
-    ) -> None: ...
-    def handle_long_expression(self, node: ast.AstNode, kid: ast.AstNode) -> None: ...
-    def exit_assignment(self, node: ast.Assignment) -> None: ...
-    def exit_architype(self, node: ast.Architype) -> None: ...
-    def exit_f_string(self, node: ast.FString) -> None: ...
-    def exit_if_else_expr(self, node: ast.IfElseExpr) -> None: ...
-    def decl_def_missing(self, decl: str = "this") -> None: ...
-    def exit_bool_expr(self, node: ast.BoolExpr) -> None: ...
-    def exit_lambda_expr(self, node: ast.LambdaExpr) -> None: ...
-    def exit_unary_expr(self, node: ast.UnaryExpr) -> None: ...
-    def exit_raise_stmt(self, node: ast.RaiseStmt) -> None: ...
-    def exit_edge_ref_trailer(self, node: ast.EdgeRefTrailer) -> None: ...
-    def exit_edge_op_ref(self, node: ast.EdgeOpRef) -> None: ...
-    def exit_index_slice(self, node: ast.IndexSlice) -> None: ...
-    def exit_list_val(self, node: ast.ListVal) -> None: ...
-    def exit_set_val(self, node: ast.ListVal) -> None: ...
-    def exit_dict_val(self, node: ast.DictVal) -> None: ...
-    def exit_inner_compr(self, node: ast.InnerCompr) -> None: ...
-    def exit_list_compr(self, node: ast.ListCompr) -> None: ...
-    def exit_gen_compr(self, node: ast.GenCompr) -> None: ...
-    def exit_set_compr(self, node: ast.SetCompr) -> None: ...
-    def exit_dict_compr(self, node: ast.DictCompr) -> None: ...
-    def exit_k_v_pair(self, node: ast.KVPair) -> None: ...
-    def exit_k_w_pair(self, node: ast.KWPair) -> None: ...
-    def exit_disconnect_op(self, node: ast.DisconnectOp) -> None: ...
-    def exit_connect_op(self, node: ast.ConnectOp) -> None: ...
-    def exit_filter_compr(self, node: ast.FilterCompr) -> None: ...
-    def exit_assign_compr(self, node: ast.AssignCompr) -> None: ...
-    def exit_await_expr(self, node: ast.AwaitExpr) -> None: ...
-    def exit_revisit_stmt(self, node: ast.RevisitStmt) -> None: ...
-    def exit_visit_stmt(self, node: ast.VisitStmt) -> None: ...
-    def exit_ignore_stmt(self, node: ast.IgnoreStmt) -> None: ...
-    def exit_return_stmt(self, node: ast.ReturnStmt) -> None: ...
-    def exit_assert_stmt(self, node: ast.AssertStmt) -> None: ...
-    def exit_check_stmt(self, node: ast.CheckStmt) -> None: ...
-    def exit_ctrl_stmt(self, node: ast.CtrlStmt) -> None: ...
-    def exit_delete_stmt(self, node: ast.DeleteStmt) -> None: ...
-    def exit_report_stmt(self, node: ast.ReportStmt) -> None: ...
-    def exit_expr_as_item(self, node: ast.ExprAsItem) -> None: ...
-    def exit_in_for_stmt(self, node: ast.InForStmt) -> None: ...
-    def exit_test(self, node: ast.Test) -> None: ...
-    def exit_py_inline_code(self, node: ast.PyInlineCode) -> None: ...
-    def exit_arch_ref_chain(self, node: ast.ArchRefChain) -> None: ...
-    def exit_typed_ctx_block(self, node: ast.TypedCtxBlock) -> None: ...
-    def exit_match_stmt(self, node: ast.MatchStmt) -> None: ...
-    def exit_match_case(self, node: ast.MatchCase) -> None: ...
-    def exit_match_or(self, node: ast.MatchOr) -> None: ...
-    def exit_match_as(self, node: ast.MatchAs) -> None: ...
-    def exit_match_wild(self, node: ast.MatchWild) -> None: ...
-    def exit_match_value(self, node: ast.MatchValue) -> None: ...
-    def exit_match_singleton(self, node: ast.MatchSingleton) -> None: ...
-    def exit_match_sequence(self, node: ast.MatchSequence) -> None: ...
-    def exit_match_mapping(self, node: ast.MatchMapping) -> None: ...
-    def exit_match_k_v_pair(self, node: ast.MatchKVPair) -> None: ...
-    def exit_match_star(self, node: ast.MatchStar) -> None: ...
-    def exit_match_arch(self, node: ast.MatchArch) -> None: ...
-    def exit_token(self, node: ast.Token) -> None: ...
-    def exit_name(self, node: ast.Name) -> None: ...
-    def enter_float(self, node: ast.Float) -> None: ...
-    def enter_int(self, node: ast.Int) -> None: ...
-    def enter_string(self, node: ast.String) -> None: ...
-    def enter_bool(self, node: ast.Bool) -> None: ...
-    def exit_builtin_type(self, node: ast.BuiltinType) -> None: ...
-    def exit_null(self, node: ast.Null) -> None: ...
-    def exit_ellipsis(self, node: ast.Ellipsis) -> None: ...
-    def exit_semi(self, node: ast.Semi) -> None: ...
-    def exit_comment_token(self, node: ast.CommentToken) -> None: ...
diff --git a/jac/stubs/jaclang/compiler/passes/tool/schedules.pyi b/jac/stubs/jaclang/compiler/passes/tool/schedules.pyi
deleted file mode 100644
index 4e1f2e14ff..0000000000
--- a/jac/stubs/jaclang/compiler/passes/tool/schedules.pyi
+++ /dev/null
@@ -1,11 +0,0 @@
-from jaclang.compiler.passes.ir_pass import Pass
-from jaclang.compiler.passes.tool.fuse_comments_pass import (
-    FuseCommentsPass as FuseCommentsPass,
-)
-from jaclang.compiler.passes.tool.jac_formatter_pass import (
-    JacFormatPass as JacFormatPass,
-)
-
-__all__ = ["FuseCommentsPass", "JacFormatPass", "format_pass"]
-
-format_pass: list[type[Pass]]
diff --git a/jac/stubs/jaclang/compiler/passes/transform.pyi b/jac/stubs/jaclang/compiler/passes/transform.pyi
deleted file mode 100644
index 7339a762ca..0000000000
--- a/jac/stubs/jaclang/compiler/passes/transform.pyi
+++ /dev/null
@@ -1,28 +0,0 @@
-import abc
-from _typeshed import Incomplete
-from abc import ABC, abstractmethod
-from jaclang.compiler.absyntree import AstNode as AstNode, T as T
-from jaclang.compiler.codeloc import CodeLocInfo as CodeLocInfo
-from jaclang.utils.log import logging as logging
-from typing import Generic
-
-class Alert:
-    msg: Incomplete
-    loc: Incomplete
-    from_pass: Incomplete
-    def __init__(
-        self, msg: str, loc: CodeLocInfo, from_pass: type[Transform]
-    ) -> None: ...
-
-class Transform(ABC, Generic[T], metaclass=abc.ABCMeta):
-    logger: Incomplete
-    errors_had: Incomplete
-    warnings_had: Incomplete
-    cur_node: Incomplete
-    ir: Incomplete
-    def __init__(self, input_ir: T, prior: Transform | None = None) -> None: ...
-    @abstractmethod
-    def transform(self, ir: T) -> AstNode: ...
-    def log_error(self, msg: str, node_override: AstNode | None = None) -> None: ...
-    def log_warning(self, msg: str, node_override: AstNode | None = None) -> None: ...
-    def log_info(self, msg: str) -> None: ...
diff --git a/jac/stubs/jaclang/compiler/passes/utils/__init__.pyi b/jac/stubs/jaclang/compiler/passes/utils/__init__.pyi
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/jac/stubs/jaclang/compiler/passes/utils/mypy_ast_build.pyi b/jac/stubs/jaclang/compiler/passes/utils/mypy_ast_build.pyi
deleted file mode 100644
index a7d352bb19..0000000000
--- a/jac/stubs/jaclang/compiler/passes/utils/mypy_ast_build.pyi
+++ /dev/null
@@ -1,151 +0,0 @@
-import ast
-import mypy.build as myb
-import mypy.checkexpr as mycke
-import mypy.errors as mye
-import mypy.fastparse as myfp
-from _typeshed import Incomplete
-from jaclang.compiler.passes import Pass
-from mypy.build import (
-    BuildSource as BuildSource,
-    BuildSourceSet as BuildSourceSet,
-    FileSystemCache as FileSystemCache,
-    Graph,
-    compute_search_paths as compute_search_paths,
-    load_plugins as load_plugins,
-    process_graph as process_graph,
-)
-from mypy.options import Options as Options
-from mypy.semanal_main import semantic_analysis_for_scc as semantic_analysis_for_scc
-
-__all__ = [
-    "BuildManager",
-    "State",
-    "BuildSource",
-    "BuildSourceSet",
-    "FileSystemCache",
-    "compute_search_paths",
-    "load_graph",
-    "load_plugins",
-    "process_graph",
-    "Errors",
-    "Options",
-    "ASTConverter",
-    "semantic_analysis_for_scc",
-]
-
-class BuildManager(myb.BuildManager):
-    def parse_file(
-        self,
-        id: str,
-        path: str,
-        source: str,
-        ignore_errors: bool,
-        options: myb.Options,
-        ast_override: myb.MypyFile | None = None,
-    ) -> myb.MypyFile: ...
-
-class ExpressionChecker(mycke.ExpressionChecker):
-    def __init__(
-        self,
-        tc: mycke.mypy.checker.TypeChecker,
-        msg: mycke.MessageBuilder,
-        plugin: mycke.Plugin,
-        per_line_checking_time_ns: dict[int, int],
-    ) -> None: ...
-    def visit_list_expr(self, e: mycke.ListExpr) -> mycke.Type: ...
-    def visit_set_expr(self, e: mycke.SetExpr) -> mycke.Type: ...
-    def visit_tuple_expr(self, e: myfp.TupleExpr) -> myb.Type: ...
-    def visit_dict_expr(self, e: myfp.DictExpr) -> myb.Type: ...
-    def visit_list_comprehension(self, e: myfp.ListComprehension) -> myb.Type: ...
-    def visit_set_comprehension(self, e: myfp.SetComprehension) -> myb.Type: ...
-    def visit_generator_expr(self, e: myfp.GeneratorExpr) -> myb.Type: ...
-    def visit_dictionary_comprehension(
-        self, e: myfp.DictionaryComprehension
-    ) -> myb.Type: ...
-    def visit_member_expr(
-        self, e: myfp.MemberExpr, is_lvalue: bool = False
-    ) -> myb.Type: ...
-
-class State(myb.State):
-    manager: BuildManager
-    tree: myb.MypyFile | None
-    order: Incomplete
-    caller_state: Incomplete
-    caller_line: Incomplete
-    import_context: Incomplete
-    id: Incomplete
-    options: Incomplete
-    early_errors: Incomplete
-    ignore_all: bool
-    path: Incomplete
-    abspath: Incomplete
-    xpath: Incomplete
-    meta: Incomplete
-    interface_hash: Incomplete
-    meta_source_hash: Incomplete
-    source: Incomplete
-    per_line_checking_time_ns: Incomplete
-    dependencies: Incomplete
-    dependencies_set: Incomplete
-    suppressed: Incomplete
-    suppressed_set: Incomplete
-    priorities: Incomplete
-    dep_line_map: Incomplete
-    def __init__(
-        self,
-        id: str | None,
-        path: str | None,
-        source: str | None,
-        manager: BuildManager,
-        caller_state: myb.State | None = None,
-        caller_line: int = 0,
-        ancestor_for: myb.State | None = None,
-        root_source: bool = False,
-        temporary: bool = False,
-        ast_override: myb.MypyFile | None = None,
-    ) -> None: ...
-    def type_checker(self) -> myb.TypeChecker: ...
-    source_hash: Incomplete
-    def parse_file(
-        self, *, temporary: bool = False, ast_override: myb.MypyFile | None = None
-    ) -> None: ...
-
-class ASTConverter(myfp.ASTConverter):
-    def visit(self, node: ast.AST | None) -> myfp.Any: ...
-    def make_argument(
-        self,
-        arg: ast.arg,
-        default: ast.expr | None,
-        kind: myfp.ArgKind,
-        no_type_check: bool,
-        pos_only: bool = False,
-    ) -> myfp.Argument: ...
-    def link_mypy_to_jac_node(self, node: ast.AST, ret: myfp.Any) -> None: ...
-
-class Errors(mye.Errors):
-    cur_pass: Incomplete
-    def __init__(self, cur_pass: Pass, *args, **kwargs) -> None: ...
-    def report(
-        self,
-        line: int,
-        column: int | None,
-        message: str,
-        code: mye.ErrorCode | None = None,
-        *,
-        blocker: bool = False,
-        severity: str = "error",
-        file: str | None = None,
-        only_once: bool = False,
-        allow_dups: bool = False,
-        origin_span: mye.Iterable[int] | None = None,
-        offset: int = 0,
-        end_line: int | None = None,
-        end_column: int | None = None
-    ) -> None: ...
-
-def load_graph(
-    sources: list[BuildSource],
-    manager: BuildManager,
-    old_graph: Graph | None = None,
-    new_modules: list[State] | None = None,
-) -> Graph: ...
diff --git a/jac/stubs/jaclang/compiler/semtable.pyi b/jac/stubs/jaclang/compiler/semtable.pyi
deleted file mode 100644
index d9f4b63431..0000000000
--- a/jac/stubs/jaclang/compiler/semtable.pyi
+++ /dev/null
@@ -1,35 +0,0 @@
-from _typeshed import Incomplete
-
-class SemInfo:
-    name: Incomplete
-    type: Incomplete
-    semstr: Incomplete
-    def __init__(
-        self, name: str, type: str | None = None, semstr: str = ""
-    ) -> None: ...
-
-class SemScope:
-    parent: Incomplete
-    type: Incomplete
-    scope: Incomplete
-    def __init__(
-        self, scope: str, type: str, parent: SemScope | None = None
-    ) -> None: ...
-    @staticmethod
-    def get_scope_from_str(scope_str: str) -> SemScope | None: ...
-    @property
-    def as_type_str(self) -> str | None: ...
-
-class SemRegistry:
-    registry: Incomplete
-    def __init__(self) -> None: ...
-    def add(self, scope: SemScope, seminfo: SemInfo) -> None: ...
-    def lookup(
-        self,
-        scope: SemScope | None = None,
-        name: str | None = None,
-        type: str | None = None,
-    ) -> tuple[SemScope | None, SemInfo | list[SemInfo] | None]: ...
-    @property
-    def module_scope(self) -> SemScope: ...
-    def pp(self) -> str: ...
diff --git a/jac/stubs/jaclang/compiler/symtable.pyi b/jac/stubs/jaclang/compiler/symtable.pyi
deleted file mode 100644
index cfc3e96d8b..0000000000
--- a/jac/stubs/jaclang/compiler/symtable.pyi
+++ /dev/null
@@ -1,65 +0,0 @@
-import jaclang.compiler.absyntree as ast
-from _typeshed import Incomplete
-from jaclang.compiler.constant import (
-    SymbolAccess as SymbolAccess,
-    SymbolType as SymbolType,
-)
-from typing import Sequence
-
-__all__ = ["Symbol", "SymbolTable", "SymbolType", "SymbolAccess"]
-
-class Symbol:
-    defn: Incomplete
-    uses: Incomplete
-    access: Incomplete
-    parent_tab: Incomplete
-    def __init__(
-        self, defn: ast.NameAtom, access: SymbolAccess, parent_tab: SymbolTable
-    ) -> None: ...
-    @property
-    def decl(self) -> ast.NameAtom: ...
-    @property
-    def sym_name(self) -> str: ...
-    @property
-    def sym_type(self) -> SymbolType: ...
-    @property
-    def sym_dotted_name(self) -> str: ...
-    def add_defn(self, node: ast.NameAtom) -> None: ...
-    def add_use(self, node: ast.NameAtom) -> None: ...
-
-class SymbolTable:
-    name: Incomplete
-    owner: Incomplete
-    parent: Incomplete
-    kid: Incomplete
-    tab: Incomplete
-    inherit: Incomplete
-    def __init__(
-        self, name: str, owner: ast.AstNode, parent: SymbolTable | None = None
-    ) -> None: ...
-    def get_parent(self) -> SymbolTable | None: ...
-    def lookup(self, name: str, deep: bool = True) -> Symbol | None: ...
-    def insert(
-        self,
-        node: ast.AstSymbolNode,
-        access_spec: ast.AstAccessNode | None | SymbolAccess = None,
-        single: bool = False,
-    ) -> ast.AstNode | None: ...
-    def find_scope(self, name: str) -> SymbolTable | None: ...
-    def push_scope(self, name: str, key_node: ast.AstNode) -> SymbolTable: ...
-    def inherit_sym_tab(self, target_sym_tab: SymbolTable) -> None: ...
-    def def_insert(
-        self,
-        node: ast.AstSymbolNode,
-        access_spec: ast.AstAccessNode | None | SymbolAccess = None,
-        single_decl: str | None = None,
-    ) -> Symbol | None: ...
-    def chain_def_insert(self, node_list: list[ast.AstSymbolNode]) -> None: ...
-    def use_lookup(
-        self, node: ast.AstSymbolNode, sym_table: SymbolTable | None = None
-    ) -> Symbol | None: ...
-    def chain_use_lookup(self, node_list: Sequence[ast.AstSymbolNode]) -> None: ...
-    def update_py_ctx_for_def(self, node: ast.AstSymbolNode) -> None: ...
-    def inherit_baseclasses_sym(self, node: ast.Architype | ast.Enum) -> None: ...
-    def pp(self, depth: int | None = None) -> str: ...
-    def dotgen(self) -> str: ...
diff --git a/jac/stubs/jaclang/langserve/__init__.pyi b/jac/stubs/jaclang/langserve/__init__.pyi
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/jac/stubs/jaclang/langserve/engine.pyi b/jac/stubs/jaclang/langserve/engine.pyi
deleted file mode 100644
index 5189bb8ba6..0000000000
--- a/jac/stubs/jaclang/langserve/engine.pyi
+++ /dev/null
@@ -1,73 +0,0 @@
-import jaclang.compiler.absyntree as ast
-import lsprotocol.types as lspt
-from _typeshed import Incomplete
-from jaclang.compiler.compile import jac_str_to_pass as jac_str_to_pass
-from jaclang.compiler.parser import JacParser as JacParser
-from jaclang.compiler.passes import Pass as Pass
-from jaclang.compiler.passes.main.schedules import (
-    py_code_gen_typed as py_code_gen_typed,
-)
-from jaclang.compiler.passes.tool import (
-    FuseCommentsPass as FuseCommentsPass,
-    JacFormatPass as JacFormatPass,
-)
-from jaclang.langserve.sem_manager import SemTokManager as SemTokManager
-from jaclang.langserve.utils import (
-    collect_all_symbols_in_scope as collect_all_symbols_in_scope,
-    create_range as create_range,
-    find_index as find_index,
-    find_node_by_position as find_node_by_position,
-    gen_diagnostics as gen_diagnostics,
-    get_item_path as get_item_path,
-    get_mod_path as get_mod_path,
-    get_symbols_for_outline as get_symbols_for_outline,
-    parse_symbol_path as parse_symbol_path,
-    resolve_completion_symbol_table as resolve_completion_symbol_table,
-)
-from jaclang.vendor.pygls import uris as uris
-from jaclang.vendor.pygls.server import LanguageServer as LanguageServer
-
-class ModuleInfo:
-    ir: Incomplete
-    impl_parent: Incomplete
-    sem_manager: Incomplete
-    def __init__(
-        self, ir: ast.Module, impl_parent: ModuleInfo | None = None
-    ) -> None: ...
-    @property
-    def uri(self) -> str: ...
-
-class JacLangServer(LanguageServer):
-    modules: Incomplete
-    executor: Incomplete
-    tasks: Incomplete
-    def __init__(self) -> None: ...
-    def update_modules(
-        self, file_path: str, build: Pass, refresh: bool = False
-    ) -> None: ...
-    def quick_check(self, file_path: str) -> bool: ...
-    def deep_check(self, file_path: str, annex_view: str | None = None) -> bool: ...
-    async def launch_quick_check(self, uri: str) -> None: ...
-    async def launch_deep_check(self, uri: str) -> None: ...
-    def get_completion(
-        self, file_path: str, position: lspt.Position, completion_trigger: str | None
-    ) -> lspt.CompletionList: ...
-    def rename_module(self, old_path: str, new_path: str) -> None: ...
-    def delete_module(self, uri: str) -> None: ...
-    def formatted_jac(self, file_path: str) -> list[lspt.TextEdit]: ...
-    def get_hover_info(
-        self, file_path: str, position: lspt.Position
-    ) -> lspt.Hover | None: ...
-    def get_node_info(self, node: ast.AstSymbolNode) -> str | None: ...
-    def get_outline(self, file_path: str) -> list[lspt.DocumentSymbol]: ...
-    def get_definition(
-        self, file_path: str, position: lspt.Position
-    ) -> lspt.Location | None: ...
-    def get_references(
-        self, file_path: str, position: lspt.Position
-    ) -> list[lspt.Location]: ...
-    def get_semantic_tokens(self, file_path: str) -> lspt.SemanticTokens: ...
-    def log_error(self, message: str) -> None: ...
-    def log_warning(self, message: str) -> None: ...
-    def log_info(self, message: str) -> None: ...
-    def log_py(self, message: str) -> None: ...
diff --git a/jac/stubs/jaclang/langserve/sem_manager.pyi b/jac/stubs/jaclang/langserve/sem_manager.pyi
deleted file mode 100644
index 4e427d17c6..0000000000
--- a/jac/stubs/jaclang/langserve/sem_manager.pyi
+++ /dev/null
@@ -1,89 +0,0 @@
-import jaclang.compiler.absyntree as ast
-import lsprotocol.types as lspt
-from _typeshed import Incomplete
-from jaclang.langserve.utils import (
-    find_surrounding_tokens as find_surrounding_tokens,
-    get_line_of_code as get_line_of_code,
-    get_token_start as get_token_start,
-)
-
-class SemTokManager:
-    sem_tokens: Incomplete
-    static_sem_tokens: Incomplete
-    def __init__(self, ir: ast.Module) -> None: ...
-    def gen_sem_tokens(self, ir: ast.Module) -> list[int]: ...
-    def gen_sem_tok_node(
-        self, ir: ast.Module
-    ) -> list[tuple[lspt.Position, int, int, ast.AstSymbolNode]]: ...
-    def update_sem_tokens(
-        self,
-        content_changes: lspt.DidChangeTextDocumentParams,
-        sem_tokens: list[int],
-        document_lines: list[str],
-    ) -> list[int]: ...
-    @staticmethod
-    def handle_multi_line_delete(
-        sem_tokens: list[int],
-        next_token_index: int,
-        nxt_tok_pos: tuple[int, int, int],
-        change_start_line: int,
-        change_end_line: int,
-        change_start_char: int,
-        change_end_char: int,
-        prev_tok_pos: tuple[int, int, int],
-        is_next_token_same_line: bool,
-    ) -> list[int]: ...
-    @staticmethod
-    def handle_single_line_delete_between_tokens(
-        sem_tokens: list[int],
-        next_token_index: int,
-        is_next_token_same_line: bool,
-        change: lspt.TextDocumentContentChangeEvent_Type1,
-        change_start_line: int,
-        change_end_line: int,
-    ) -> list[int]: ...
-    @staticmethod
-    def handle_single_line_delete(
-        sem_tokens: list[int],
-        next_token_index: int,
-        prev_token_index: int,
-        is_next_token_same_line: bool,
-        change: lspt.TextDocumentContentChangeEvent_Type1,
-    ) -> list[int]: ...
-    @staticmethod
-    def handle_single_line_insertion(
-        sem_tokens: list[int],
-        next_token_index: int,
-        is_next_token_same_line: bool,
-        change: lspt.TextDocumentContentChangeEvent_Type1,
-        tokens_on_same_line: bool,
-        nxt_tok_pos: tuple[int, int, int],
-        change_start_line: int,
-        line_delta: int,
-    ) -> list[int]: ...
-    @staticmethod
-    def handle_multi_line_insertion(
-        sem_tokens: list[int],
-        next_token_index: int,
-        nxt_tok_pos: tuple[int, int, int],
-        change_start_line: int,
-        change_end_line: int,
-        change_end_char: int,
-        prev_tok_pos: tuple[int, int, int],
-        tokens_on_same_line: bool,
-        changing_line_text: tuple[str, int],
-        line_delta: int,
-    ) -> list[int]: ...
-    @staticmethod
-    def handle_insert_inside_token(
-        change: lspt.TextDocumentContentChangeEvent_Type1,
-        sem_tokens: list[int],
-        prev_token_index: int,
-        changing_line_text: tuple[str, int],
-        line_delta: int,
-        prev_tok_pos: tuple[int, int, int],
-        change_start_char: int,
-        change_end_char: int,
-        is_token_boundary_edit: bool,
-        nxt_tok_pos: tuple[int, int, int],
-    ) -> tuple[list[int], bool, tuple[int, int, int], int | None]: ...
diff --git a/jac/stubs/jaclang/langserve/server.pyi b/jac/stubs/jaclang/langserve/server.pyi
deleted file mode 100644
index 7e15229076..0000000000
--- a/jac/stubs/jaclang/langserve/server.pyi
+++ /dev/null
@@ -1,38 +0,0 @@
-import lsprotocol.types as lspt
-from _typeshed import Incomplete
-from jaclang.langserve.engine import JacLangServer as JacLangServer
-from jaclang.settings import settings as settings
-
-server: Incomplete
-
-async def did_open(
-    ls: JacLangServer, params: lspt.DidOpenTextDocumentParams
-) -> None: ...
-async def did_change(
-    ls: JacLangServer, params: lspt.DidChangeTextDocumentParams
-) -> None: ...
-def formatting(
-    ls: JacLangServer, params: lspt.DocumentFormattingParams
-) -> list[lspt.TextEdit]: ...
-def did_create_files(ls: JacLangServer, params: lspt.CreateFilesParams) -> None: ...
-def did_rename_files(ls: JacLangServer, params: lspt.RenameFilesParams) -> None: ...
-def did_delete_files(ls: JacLangServer, params: lspt.DeleteFilesParams) -> None: ...
-def completion(
-    ls: JacLangServer, params: lspt.CompletionParams
-) -> lspt.CompletionList: ...
-def hover(
-    ls: JacLangServer, params: lspt.TextDocumentPositionParams
-) -> lspt.Hover | None: ...
-def document_symbol(
-    ls: JacLangServer, params: lspt.DocumentSymbolParams
-) -> list[lspt.DocumentSymbol]: ...
-def definition(
-    ls: JacLangServer, params: lspt.TextDocumentPositionParams
-) -> lspt.Location | None: ...
-def references(
-    ls: JacLangServer, params: lspt.ReferenceParams
-) -> list[lspt.Location]: ...
-def semantic_tokens_full(
-    ls: JacLangServer, params: lspt.SemanticTokensParams
-) -> lspt.SemanticTokens: ...
-def run_lang_server() -> None: ...
diff --git a/jac/stubs/jaclang/langserve/utils.pyi b/jac/stubs/jaclang/langserve/utils.pyi
deleted file mode 100644
index 34540086c9..0000000000
--- a/jac/stubs/jaclang/langserve/utils.pyi
+++ /dev/null
@@ -1,55 +0,0 @@
-import jaclang.compiler.absyntree as ast
-import lsprotocol.types as lspt
-from jaclang.compiler.codeloc import CodeLocInfo as CodeLocInfo
-from jaclang.compiler.constant import SymbolType as SymbolType
-from jaclang.compiler.passes.transform import Alert as Alert
-from jaclang.compiler.symtable import Symbol as Symbol, SymbolTable as SymbolTable
-from jaclang.vendor.pygls import uris as uris
-from typing import Any, Awaitable, Callable, Coroutine, ParamSpec, TypeVar
-
-T = TypeVar("T", bound=Callable[..., Coroutine[Any, Any, Any]])
-P = ParamSpec("P")
-
-def gen_diagnostics(
-    from_path: str, errors: list[Alert], warnings: list[Alert]
-) -> list[lspt.Diagnostic]: ...
-def debounce(wait: float) -> Callable[[T], Callable[..., Awaitable[None]]]: ...
-def sym_tab_list(sym_tab: SymbolTable, file_path: str) -> list[SymbolTable]: ...
-def find_node_by_position(
-    tokens: list[tuple[lspt.Position, int, int, ast.AstSymbolNode]],
-    line: int,
-    position: int,
-) -> ast.AstSymbolNode | None: ...
-def find_index(sem_tokens: list[int], line: int, char: int) -> int | None: ...
-def get_symbols_for_outline(node: SymbolTable) -> list[lspt.DocumentSymbol]: ...
-def owner_sym(table: SymbolTable) -> Symbol | None: ...
-def create_range(loc: CodeLocInfo) -> lspt.Range: ...
-def kind_map(sub_tab: ast.AstNode) -> lspt.SymbolKind: ...
-def label_map(sub_tab: SymbolType) -> lspt.CompletionItemKind: ...
-def get_mod_path(mod_path: ast.ModulePath, name_node: ast.Name) -> str | None: ...
-def get_item_path(mod_item: ast.ModuleItem) -> tuple[str, tuple[int, int]] | None: ...
-def get_definition_range(
-    filename: str, name: str
-) -> tuple[str, tuple[int, int]] | None: ...
-def collect_all_symbols_in_scope(
-    sym_tab: SymbolTable, up_tree: bool = True
-) -> list[lspt.CompletionItem]: ...
-def parse_symbol_path(text: str, dot_position: int) -> list[str]: ...
-def resolve_symbol_path(sym_name: str, node_tab: SymbolTable) -> str: ...
-def find_symbol_table(path: str, current_tab: SymbolTable | None) -> SymbolTable: ...
-def resolve_completion_symbol_table(
-    mod_tab: SymbolTable,
-    current_symbol_path: list[str],
-    current_tab: SymbolTable | None,
-) -> list[lspt.CompletionItem]: ...
-def get_token_start(
-    token_index: int | None, sem_tokens: list[int]
-) -> tuple[int, int, int]: ...
-def find_surrounding_tokens(
-    change_start_line: int,
-    change_start_char: int,
-    change_end_line: int,
-    change_end_char: int,
-    sem_tokens: list[int],
-) -> tuple[int | None, int | None, bool]: ...
-def get_line_of_code(line_number: int, lines: list[str]) -> tuple[str, int] | None: ...
diff --git a/jac/stubs/jaclang/plugin/__init__.pyi b/jac/stubs/jaclang/plugin/__init__.pyi
deleted file mode 100644
index 26af7fe86e..0000000000
--- a/jac/stubs/jaclang/plugin/__init__.pyi
+++ /dev/null
@@ -1,3 +0,0 @@
-from .default import Architype as Architype, DSFunc as DSFunc, hookimpl as hookimpl
-
-__all__ = ["Architype", "DSFunc", "hookimpl"]
diff --git a/jac/stubs/jaclang/plugin/builtin.pyi b/jac/stubs/jaclang/plugin/builtin.pyi
deleted file mode 100644
index 9c6ba89f1d..0000000000
--- a/jac/stubs/jaclang/plugin/builtin.pyi
+++ /dev/null
@@ -1,12 +0,0 @@
-from jaclang.runtimelib.constructs import NodeArchitype as NodeArchitype
-
-def dotgen(
-    node: NodeArchitype | None = None,
-    depth: int | None = None,
-    traverse: bool | None = None,
-    edge_type: list[str] | None = None,
-    bfs: bool | None = None,
-    edge_limit: int | None = None,
-    node_limit: int | None = None,
-    dot_file: str | None = None,
-) -> str: ...
diff --git a/jac/stubs/jaclang/plugin/default.pyi b/jac/stubs/jaclang/plugin/default.pyi
deleted file mode 100644
index a4626ac53c..0000000000
--- a/jac/stubs/jaclang/plugin/default.pyi
+++ /dev/null
@@ -1,202 +0,0 @@
-import types
-from _typeshed import Incomplete
-from jaclang.compiler.absyntree import Module
-from jaclang.compiler.constant import EdgeDir
-from jaclang.plugin.spec import P, T as T
-from jaclang.runtimelib.constructs import (
-    Anchor as Anchor,
-    Architype as Architype,
-    DSFunc as DSFunc,
-    EdgeAnchor as EdgeAnchor,
-    EdgeArchitype as EdgeArchitype,
-    ExecutionContext,
-    GenericEdge as GenericEdge,
-    JacTestCheck as JacTestCheck,
-    Memory,
-    NodeAnchor as NodeAnchor,
-    NodeArchitype as NodeArchitype,
-    Root as Root,
-    WalkerAnchor as WalkerAnchor,
-    WalkerArchitype as WalkerArchitype,
-)
-from typing import Any, Callable
-
-__all__ = [
-    "EdgeAnchor",
-    "GenericEdge",
-    "hookimpl",
-    "JacTestCheck",
-    "NodeAnchor",
-    "Anchor",
-    "WalkerAnchor",
-    "NodeArchitype",
-    "EdgeArchitype",
-    "Root",
-    "WalkerArchitype",
-    "Architype",
-    "DSFunc",
-    "T",
-]
-
-hookimpl: Incomplete
-
-class JacFeatureDefaults:
-    pm: Incomplete
-    @staticmethod
-    def context(session: str = "") -> ExecutionContext: ...
-    @staticmethod
-    def reset_context() -> None: ...
-    @staticmethod
-    def memory_hook() -> Memory | None: ...
-    @staticmethod
-    def make_architype(
-        cls, arch_base: type[Architype], on_entry: list[DSFunc], on_exit: list[DSFunc]
-    ) -> type[Architype]: ...
-    @staticmethod
-    def make_obj(
-        on_entry: list[DSFunc], on_exit: list[DSFunc]
-    ) -> Callable[[type], type]: ...
-    @staticmethod
-    def make_node(
-        on_entry: list[DSFunc], on_exit: list[DSFunc]
-    ) -> Callable[[type], type]: ...
-    @staticmethod
-    def make_edge(
-        on_entry: list[DSFunc], on_exit: list[DSFunc]
-    ) -> Callable[[type], type]: ...
-    @staticmethod
-    def make_walker(
-        on_entry: list[DSFunc], on_exit: list[DSFunc]
-    ) -> Callable[[type], type]: ...
-    @staticmethod
-    def impl_patch_filename(
-        file_loc: str,
-    ) -> Callable[[Callable[P, T]], Callable[P, T]]: ...
-    @staticmethod
-    def jac_import(
-        target: str,
-        base_path: str,
-        absorb: bool,
-        cachable: bool,
-        mdl_alias: str | None,
-        override_name: str | None,
-        mod_bundle: Module | str | None,
-        lng: str | None,
-        items: dict[str, str | str | None] | None,
-    ) -> tuple[types.ModuleType, ...]: ...
-    @staticmethod
-    def create_test(test_fun: Callable) -> Callable: ...
-    @staticmethod
-    def run_test(
-        filepath: str,
-        filter: str | None,
-        xit: bool,
-        maxfail: int | None,
-        directory: str | None,
-        verbose: bool,
-    ) -> int: ...
-    @staticmethod
-    def elvis(op1: T | None, op2: T) -> T: ...
-    @staticmethod
-    def has_instance_default(gen_func: Callable[[], T]) -> T: ...
-    @staticmethod
-    def spawn_call(op1: Architype, op2: Architype) -> WalkerArchitype: ...
-    @staticmethod
-    def report(expr: Any) -> Any: ...
-    @staticmethod
-    def ignore(
-        walker: WalkerArchitype,
-        expr: (
-            list[NodeArchitype | EdgeArchitype]
-            | list[NodeArchitype]
-            | list[EdgeArchitype]
-            | NodeArchitype
-            | EdgeArchitype
-        ),
-    ) -> bool: ...
-    @staticmethod
-    def visit_node(
-        walker: WalkerArchitype,
-        expr: (
-            list[NodeArchitype | EdgeArchitype]
-            | list[NodeArchitype]
-            | list[EdgeArchitype]
-            | NodeArchitype
-            | EdgeArchitype
-        ),
-    ) -> bool: ...
-    @staticmethod
-    def disengage(walker: WalkerArchitype) -> bool: ...
-    @staticmethod
-    def edge_ref(
-        node_obj: NodeArchitype | list[NodeArchitype],
-        target_obj: NodeArchitype | list[NodeArchitype] | None,
-        dir: EdgeDir,
-        filter_func: Callable[[list[EdgeArchitype]], list[EdgeArchitype]] | None,
-        edges_only: bool,
-    ) -> list[NodeArchitype] | list[EdgeArchitype]: ...
-    @staticmethod
-    def connect(
-        left: NodeArchitype | list[NodeArchitype],
-        right: NodeArchitype | list[NodeArchitype],
-        edge_spec: Callable[[], EdgeArchitype],
-        edges_only: bool,
-    ) -> list[NodeArchitype] | list[EdgeArchitype]: ...
-    @staticmethod
-    def disconnect(
-        left: NodeArchitype | list[NodeArchitype],
-        right: NodeArchitype | list[NodeArchitype],
-        dir: EdgeDir,
-        filter_func: Callable[[list[EdgeArchitype]], list[EdgeArchitype]] | None,
-    ) -> bool: ...
-    @staticmethod
-    def assign_compr(
-        target: list[T], attr_val: tuple[tuple[str], tuple[Any]]
-    ) -> list[T]: ...
-    @staticmethod
-    def get_root() -> Root: ...
-    @staticmethod
-    def get_root_type() -> type[Root]: ...
-    @staticmethod
-    def build_edge(
-        is_undirected: bool,
-        conn_type: type[EdgeArchitype] | EdgeArchitype | None,
-        conn_assign: tuple[tuple, tuple] | None,
-    ) -> Callable[[], EdgeArchitype]: ...
-    @staticmethod
-    def get_semstr_type(
-        file_loc: str, scope: str, attr: str, return_semstr: bool
-    ) -> str | None: ...
-    @staticmethod
-    def obj_scope(file_loc: str, attr: str) -> str: ...
-    @staticmethod
-    def get_sem_type(file_loc: str, attr: str) -> tuple[str | None, str | None]: ...
-    @staticmethod
-    def with_llm(
-        file_loc: str,
-        model: Any,
-        model_params: dict[str, Any],
-        scope: str,
-        incl_info: list[tuple[str, str]],
-        excl_info: list[tuple[str, str]],
-        inputs: list[tuple[str, str, str, Any]],
-        outputs: tuple,
-        action: str,
-    ) -> Any: ...
-
-class JacBuiltin:
-    @staticmethod
-    def dotgen(
-        node: NodeArchitype,
-        depth: int,
-        traverse: bool,
-        edge_type: list[str],
-        bfs: bool,
-        edge_limit: int,
-        node_limit: int,
-        dot_file: str | None,
-    ) -> str: ...
-
-class JacCmdDefaults:
-    @staticmethod
-    def create_cmd() -> None: ...
diff --git a/jac/stubs/jaclang/plugin/feature.pyi b/jac/stubs/jaclang/plugin/feature.pyi
deleted file mode 100644
index b35fdb2fd4..0000000000
--- a/jac/stubs/jaclang/plugin/feature.pyi
+++ /dev/null
@@ -1,176 +0,0 @@
-import types
-from _typeshed import Incomplete
-from jaclang.compiler.absyntree import Module as Module
-from jaclang.plugin.default import ExecutionContext as ExecutionContext
-from jaclang.plugin.spec import (
-    JacBuiltin as JacBuiltin,
-    JacCmdSpec as JacCmdSpec,
-    JacFeatureSpec as JacFeatureSpec,
-    P as P,
-    T as T,
-)
-from jaclang.runtimelib.constructs import (
-    Architype as Architype,
-    EdgeArchitype as EdgeArchitype,
-    Memory as Memory,
-    NodeArchitype as NodeArchitype,
-    Root as Root,
-    WalkerArchitype as WalkerArchitype,
-)
-from typing import Any, Callable, TypeAlias
-
-pm: Incomplete
-
-class JacFeature:
-    EdgeDir: TypeAlias
-    DSFunc: TypeAlias
-    RootType: TypeAlias
-    Obj: TypeAlias
-    Node: TypeAlias
-    Edge: TypeAlias
-    Walker: TypeAlias
-    @staticmethod
-    def context(session: str = "") -> ExecutionContext: ...
-    @staticmethod
-    def reset_context() -> None: ...
-    @staticmethod
-    def memory_hook() -> Memory | None: ...
-    @staticmethod
-    def make_architype(
-        cls, arch_base: type[Architype], on_entry: list[DSFunc], on_exit: list[DSFunc]
-    ) -> type[Architype]: ...
-    @staticmethod
-    def make_obj(
-        on_entry: list[DSFunc], on_exit: list[DSFunc]
-    ) -> Callable[[type], type]: ...
-    @staticmethod
-    def make_node(
-        on_entry: list[DSFunc], on_exit: list[DSFunc]
-    ) -> Callable[[type], type]: ...
-    @staticmethod
-    def make_edge(
-        on_entry: list[DSFunc], on_exit: list[DSFunc]
-    ) -> Callable[[type], type]: ...
-    @staticmethod
-    def make_walker(
-        on_entry: list[DSFunc], on_exit: list[DSFunc]
-    ) -> Callable[[type], type]: ...
-    @staticmethod
-    def impl_patch_filename(
-        file_loc: str,
-    ) -> Callable[[Callable[P, T]], Callable[P, T]]: ...
-    @staticmethod
-    def jac_import(
-        target: str,
-        base_path: str,
-        absorb: bool = False,
-        cachable: bool = True,
-        mdl_alias: str | None = None,
-        override_name: str | None = None,
-        mod_bundle: Module | str | None = None,
-        lng: str | None = "jac",
-        items: dict[str, str | str | None] | None = None,
-    ) -> tuple[types.ModuleType, ...]: ...
-    @staticmethod
-    def create_test(test_fun: Callable) -> Callable: ...
-    @staticmethod
-    def run_test(
-        filepath: str,
-        filter: str | None = None,
-        xit: bool = False,
-        maxfail: int | None = None,
-        directory: str | None = None,
-        verbose: bool = False,
-    ) -> int: ...
-    @staticmethod
-    def elvis(op1: T | None, op2: T) -> T: ...
-    @staticmethod
-    def has_instance_default(gen_func: Callable[[], T]) -> T: ...
-    @staticmethod
-    def spawn_call(op1: Architype, op2: Architype) -> WalkerArchitype: ...
-    @staticmethod
-    def report(expr: Any) -> Any: ...
-    @staticmethod
-    def ignore(
-        walker: WalkerArchitype,
-        expr: (
-            list[NodeArchitype | EdgeArchitype]
-            | list[NodeArchitype]
-            | list[EdgeArchitype]
-            | NodeArchitype
-            | EdgeArchitype
-        ),
-    ) -> bool: ...
-    @staticmethod
-    def visit_node(
-        walker: WalkerArchitype,
-        expr: (
-            list[NodeArchitype | EdgeArchitype]
-            | list[NodeArchitype]
-            | list[EdgeArchitype]
-            | NodeArchitype
-            | EdgeArchitype
-        ),
-    ) -> bool: ...
-    @staticmethod
-    def disengage(walker: WalkerArchitype) -> bool: ...
-    @staticmethod
-    def edge_ref(
-        node_obj: NodeArchitype | list[NodeArchitype],
-        target_obj: NodeArchitype | list[NodeArchitype] | None,
-        dir: EdgeDir,
-        filter_func: Callable[[list[EdgeArchitype]], list[EdgeArchitype]] | None,
-        edges_only: bool = False,
-    ) -> list[NodeArchitype] | list[EdgeArchitype]: ...
-    @staticmethod
-    def connect(
-        left: NodeArchitype | list[NodeArchitype],
-        right: NodeArchitype | list[NodeArchitype],
-        edge_spec: Callable[[], EdgeArchitype],
-        edges_only: bool = False,
-    ) -> list[NodeArchitype] | list[EdgeArchitype]: ...
-    @staticmethod
-    def disconnect(
-        left: NodeArchitype | list[NodeArchitype],
-        right: NodeArchitype | list[NodeArchitype],
-        dir: EdgeDir,
-        filter_func: Callable[[list[EdgeArchitype]], list[EdgeArchitype]] | None,
-    ) -> bool: ...
-    @staticmethod
-    def assign_compr(
-        target: list[T], attr_val: tuple[tuple[str], tuple[Any]]
-    ) -> list[T]: ...
-    @staticmethod
-    def get_root() -> Root: ...
-    @staticmethod
-    def get_root_type() -> type[Root]: ...
-    @staticmethod
-    def build_edge(
-        is_undirected: bool,
-        conn_type: type[EdgeArchitype] | EdgeArchitype | None,
-        conn_assign: tuple[tuple, tuple] | None,
-    ) -> Callable[[], EdgeArchitype]: ...
-    @staticmethod
-    def get_semstr_type(
-        file_loc: str, scope: str, attr: str, return_semstr: bool
-    ) -> str | None: ...
-    @staticmethod
-    def obj_scope(file_loc: str, attr: str) -> str: ...
-    @staticmethod
-    def get_sem_type(file_loc: str, attr: str) -> tuple[str | None, str | None]: ...
-    @staticmethod
-    def with_llm(
-        file_loc: str,
-        model: Any,
-        model_params: dict[str, Any],
-        scope: str,
-        incl_info: list[tuple[str, str]],
-        excl_info: list[tuple[str, str]],
-        inputs: list[tuple[str, str, str, Any]],
-        outputs: tuple,
-        action: str,
-    ) -> Any: ...
-
-class JacCmd:
-    @staticmethod
-    def create_cmd() -> None: ...
diff --git a/jac/stubs/jaclang/plugin/spec.pyi b/jac/stubs/jaclang/plugin/spec.pyi
deleted file mode 100644
index be8a94f2d3..0000000000
--- a/jac/stubs/jaclang/plugin/spec.pyi
+++ /dev/null
@@ -1,181 +0,0 @@
-import types
-from _typeshed import Incomplete
-from jaclang.compiler.absyntree import Module as Module
-from jaclang.plugin.default import (
-    Architype as Architype,
-    DSFunc as DSFunc,
-    EdgeDir as EdgeDir,
-    ExecutionContext as ExecutionContext,
-    Root as Root,
-    WalkerArchitype as WalkerArchitype,
-)
-from jaclang.runtimelib.constructs import (
-    EdgeArchitype as EdgeArchitype,
-    NodeArchitype as NodeArchitype,
-)
-from jaclang.runtimelib.memory import Memory as Memory
-from typing import Any, Callable, ParamSpec, TypeVar
-
-hookspec: Incomplete
-T = TypeVar("T")
-P = ParamSpec("P")
-
-class JacFeatureSpec:
-    @staticmethod
-    def context(session: str = "") -> ExecutionContext: ...
-    @staticmethod
-    def reset_context() -> None: ...
-    @staticmethod
-    def memory_hook() -> Memory | None: ...
-    @staticmethod
-    def make_architype(
-        cls, arch_base: type[Architype], on_entry: list[DSFunc], on_exit: list[DSFunc]
-    ) -> type[Architype]: ...
-    @staticmethod
-    def make_obj(
-        on_entry: list[DSFunc], on_exit: list[DSFunc]
-    ) -> Callable[[type], type]: ...
-    @staticmethod
-    def make_node(
-        on_entry: list[DSFunc], on_exit: list[DSFunc]
-    ) -> Callable[[type], type]: ...
-    @staticmethod
-    def make_edge(
-        on_entry: list[DSFunc], on_exit: list[DSFunc]
-    ) -> Callable[[type], type]: ...
-    @staticmethod
-    def make_walker(
-        on_entry: list[DSFunc], on_exit: list[DSFunc]
-    ) -> Callable[[type], type]: ...
-    @staticmethod
-    def impl_patch_filename(
-        file_loc: str,
-    ) -> Callable[[Callable[P, T]], Callable[P, T]]: ...
-    @staticmethod
-    def jac_import(
-        target: str,
-        base_path: str,
-        absorb: bool,
-        cachable: bool,
-        mdl_alias: str | None,
-        override_name: str | None,
-        mod_bundle: Module | str | None,
-        lng: str | None,
-        items: dict[str, str | str | None] | None,
-    ) -> tuple[types.ModuleType, ...]: ...
-    @staticmethod
-    def create_test(test_fun: Callable) -> Callable: ...
-    @staticmethod
-    def run_test(
-        filepath: str,
-        filter: str | None,
-        xit: bool,
-        maxfail: int | None,
-        directory: str | None,
-        verbose: bool,
-    ) -> int: ...
-    @staticmethod
-    def elvis(op1: T | None, op2: T) -> T: ...
-    @staticmethod
-    def has_instance_default(gen_func: Callable[[], T]) -> T: ...
-    @staticmethod
-    def spawn_call(op1: Architype, op2: Architype) -> WalkerArchitype: ...
-    @staticmethod
-    def report(expr: Any) -> Any: ...
-    @staticmethod
-    def ignore(
-        walker: WalkerArchitype,
-        expr: (
-            list[NodeArchitype | EdgeArchitype]
-            | list[NodeArchitype]
-            | list[EdgeArchitype]
-            | NodeArchitype
-            | EdgeArchitype
-        ),
-    ) -> bool: ...
-    @staticmethod
-    def visit_node(
-        walker: WalkerArchitype,
-        expr: (
-            list[NodeArchitype | EdgeArchitype]
-            | list[NodeArchitype]
-            | list[EdgeArchitype]
-            | NodeArchitype
-            | EdgeArchitype
-        ),
-    ) -> bool: ...
-    @staticmethod
-    def disengage(walker: WalkerArchitype) -> bool: ...
-    @staticmethod
-    def edge_ref(
-        node_obj: NodeArchitype | list[NodeArchitype],
-        target_obj: NodeArchitype | list[NodeArchitype] | None,
-        dir: EdgeDir,
-        filter_func: Callable[[list[EdgeArchitype]], list[EdgeArchitype]] | None,
-        edges_only: bool,
-    ) -> list[NodeArchitype] | list[EdgeArchitype]: ...
-    @staticmethod
-    def connect(
-        left: NodeArchitype | list[NodeArchitype],
-        right: NodeArchitype | list[NodeArchitype],
-        edge_spec: Callable[[], EdgeArchitype],
-        edges_only: bool,
-    ) -> list[NodeArchitype] | list[EdgeArchitype]: ...
-    @staticmethod
-    def disconnect(
-        left: NodeArchitype | list[NodeArchitype],
-        right: NodeArchitype | list[NodeArchitype],
-        dir: EdgeDir,
-        filter_func: Callable[[list[EdgeArchitype]], list[EdgeArchitype]] | None,
-    ) -> bool: ...
-    @staticmethod
-    def assign_compr(
-        target: list[T], attr_val: tuple[tuple[str], tuple[Any]]
-    ) -> list[T]: ...
-    @staticmethod
-    def get_root() -> Root: ...
-    @staticmethod
-    def get_root_type() -> type[Root]: ...
-    @staticmethod
-    def build_edge(
-        is_undirected: bool,
-        conn_type: type[EdgeArchitype] | EdgeArchitype | None,
-        conn_assign: tuple[tuple, tuple] | None,
-    ) -> Callable[[], EdgeArchitype]: ...
-    @staticmethod
-    def get_semstr_type(
-        file_loc: str, scope: str, attr: str, return_semstr: bool
-    ) -> str | None: ...
-    @staticmethod
-    def obj_scope(file_loc: str, attr: str) -> str: ...
-    @staticmethod
-    def get_sem_type(file_loc: str, attr: str) -> tuple[str | None, str | None]: ...
-    @staticmethod
-    def with_llm(
-        file_loc: str,
-        model: Any,
-        model_params: dict[str, Any],
-        scope: str,
-        incl_info: list[tuple[str, str]],
-        excl_info: list[tuple[str, str]],
-        inputs: list[tuple[str, str, str, Any]],
-        outputs: tuple,
-        action: str,
-    ) -> Any: ...
-
-class JacBuiltin:
-    @staticmethod
-    def dotgen(
-        node: NodeArchitype,
-        depth: int,
-        traverse: bool,
-        edge_type: list[str],
-        bfs: bool,
-        edge_limit: int,
-        node_limit: int,
-        dot_file: str | None,
-    ) -> str: ...
-
-class JacCmdSpec:
-    @staticmethod
-    def create_cmd() -> None: ...
diff --git a/jac/stubs/jaclang/runtimelib/__init__.pyi b/jac/stubs/jaclang/runtimelib/__init__.pyi
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/jac/stubs/jaclang/runtimelib/architype.pyi b/jac/stubs/jaclang/runtimelib/architype.pyi
deleted file mode 100644
index 15279b86ca..0000000000
--- a/jac/stubs/jaclang/runtimelib/architype.pyi
+++ /dev/null
@@ -1,133 +0,0 @@
-import types
-from dataclasses import dataclass
-from jaclang.compiler.constant import EdgeDir as EdgeDir
-from jaclang.runtimelib.utils import (
-    collect_node_connections as collect_node_connections,
-)
-from typing import Any, Callable
-from uuid import UUID
-
-@dataclass(eq=False)
-class Anchor:
-    def spawn_call(self, walk: WalkerArchitype) -> WalkerArchitype: ...
-    def __init__(self, obj, id=...) -> None: ...
-
-@dataclass(eq=False)
-class NodeAnchor(Anchor):
-    obj: NodeArchitype
-    edges: list[EdgeArchitype] = ...
-    edge_ids: list[UUID] = ...
-    persistent: bool = ...
-    def populate_edges(self) -> None: ...
-    def connect_node(self, nd: NodeArchitype, edg: EdgeArchitype) -> NodeArchitype: ...
-    def get_edges(
-        self,
-        dir: EdgeDir,
-        filter_func: Callable[[list[EdgeArchitype]], list[EdgeArchitype]] | None,
-        target_obj: list[NodeArchitype] | None,
-    ) -> list[EdgeArchitype]: ...
-    def edges_to_nodes(
-        self,
-        dir: EdgeDir,
-        filter_func: Callable[[list[EdgeArchitype]], list[EdgeArchitype]] | None,
-        target_obj: list[NodeArchitype] | None,
-    ) -> list[NodeArchitype]: ...
-    def gen_dot(self, dot_file: str | None = None) -> str: ...
-    def __init__(
-        self, obj, id=..., edges=..., edge_ids=..., persistent=...
-    ) -> None: ...
-
-@dataclass(eq=False)
-class EdgeAnchor(Anchor):
-    obj: EdgeArchitype
-    source: NodeArchitype | None = ...
-    target: NodeArchitype | None = ...
-    source_id: UUID | None = ...
-    target_id: UUID | None = ...
-    is_undirected: bool = ...
-    persistent: bool = ...
-    def attach(
-        self, src: NodeArchitype, trg: NodeArchitype, is_undirected: bool = False
-    ) -> EdgeAnchor: ...
-    def detach(
-        self, src: NodeArchitype, trg: NodeArchitype, is_undirected: bool = False
-    ) -> None: ...
-    def spawn_call(self, walk: WalkerArchitype) -> WalkerArchitype: ...
-    def __init__(
-        self,
-        obj,
-        id=...,
-        source=...,
-        target=...,
-        source_id=...,
-        target_id=...,
-        is_undirected=...,
-        persistent=...,
-    ) -> None: ...
-
-@dataclass(eq=False)
-class WalkerAnchor(Anchor):
-    obj: WalkerArchitype
-    path: list[Architype] = ...
-    next: list[Architype] = ...
-    ignores: list[Architype] = ...
-    disengaged: bool = ...
-    def visit_node(
-        self,
-        nds: (
-            list[NodeArchitype | EdgeArchitype]
-            | list[NodeArchitype]
-            | list[EdgeArchitype]
-            | NodeArchitype
-            | EdgeArchitype
-        ),
-    ) -> bool: ...
-    def ignore_node(
-        self,
-        nds: (
-            list[NodeArchitype | EdgeArchitype]
-            | list[NodeArchitype]
-            | list[EdgeArchitype]
-            | NodeArchitype
-            | EdgeArchitype
-        ),
-    ) -> bool: ...
-    def disengage_now(self) -> None: ...
-    def spawn_call(self, nd: Architype) -> WalkerArchitype: ...
-    def __init__(
-        self, obj, id=..., path=..., next=..., ignores=..., disengaged=...
-    ) -> None: ...
-
-class Architype:
-    def __init__(self) -> None: ...
-    def __hash__(self) -> int: ...
-    def __eq__(self, other: object) -> bool: ...
-
-class NodeArchitype(Architype):
-    def __init__(self) -> None: ...
-    def save(self) -> None: ...
-
-class EdgeArchitype(Architype):
-    persistent: bool
-    def __init__(self) -> None: ...
-    def save(self) -> None: ...
-    def populate_nodes(self) -> None: ...
-
-class WalkerArchitype(Architype):
-    def __init__(self) -> None: ...
-
-class GenericEdge(EdgeArchitype): ...
-
-class Root(NodeArchitype):
-    reachable_nodes: list[NodeArchitype]
-    connections: set[tuple[NodeArchitype, NodeArchitype, EdgeArchitype]]
-    def __init__(self) -> None: ...
-    def reset(self) -> None: ...
-
-@dataclass(eq=False)
-class DSFunc:
-    name: str
-    trigger: type | types.UnionType | tuple[type | types.UnionType, ...] | None
-    func: Callable[[Any, Any], Any] | None = ...
-    def resolve(self, cls: type) -> None: ...
-    def __init__(self, name, trigger, func=...) -> None: ...
diff --git a/jac/stubs/jaclang/runtimelib/constructs.pyi b/jac/stubs/jaclang/runtimelib/constructs.pyi
deleted file mode 100644
index 539b5a35f1..0000000000
--- a/jac/stubs/jaclang/runtimelib/constructs.pyi
+++ /dev/null
@@ -1,41 +0,0 @@
-from .architype import (
-    Anchor as Anchor,
-    Architype as Architype,
-    DSFunc as DSFunc,
-    EdgeAnchor as EdgeAnchor,
-    EdgeArchitype as EdgeArchitype,
-    GenericEdge as GenericEdge,
-    NodeAnchor as NodeAnchor,
-    NodeArchitype as NodeArchitype,
-    Root as Root,
-    WalkerAnchor as WalkerAnchor,
-    WalkerArchitype as WalkerArchitype,
-)
-from .context import ExecutionContext as ExecutionContext, exec_context as exec_context
-from .memory import Memory as Memory, ShelveStorage as ShelveStorage
-from .test import (
-    JacTestCheck as JacTestCheck,
-    JacTestResult as JacTestResult,
-    JacTextTestRunner as JacTextTestRunner,
-)
-
-__all__ = [
-    "Anchor",
-    "NodeAnchor",
-    "EdgeAnchor",
-    "WalkerAnchor",
-    "Architype",
-    "NodeArchitype",
-    "EdgeArchitype",
-    "WalkerArchitype",
-    "GenericEdge",
-    "Root",
-    "DSFunc",
-    "Memory",
-    "ShelveStorage",
-    "ExecutionContext",
-    "exec_context",
-    "JacTestResult",
-    "JacTextTestRunner",
-    "JacTestCheck",
-]
diff --git a/jac/stubs/jaclang/runtimelib/context.pyi b/jac/stubs/jaclang/runtimelib/context.pyi
deleted file mode 100644
index 1682519a75..0000000000
--- a/jac/stubs/jaclang/runtimelib/context.pyi
+++ /dev/null
@@ -1,48 +0,0 @@
-import unittest
-from .architype import Architype as Architype, Root as Root
-from .machine import JacMachine as JacMachine
-from .memory import Memory as Memory, ShelveStorage as ShelveStorage
-from _typeshed import Incomplete
-from contextvars import ContextVar
-from typing import Callable
-from uuid import UUID
-
-class ExecutionContext:
-    mem: Memory | None
-    root: Root | None
-    jac_machine: Incomplete
-    def __init__(self) -> None: ...
-    def init_memory(self, base_path: str = "", session: str = "") -> None: ...
-    def get_root(self) -> Root: ...
-    def get_obj(self, obj_id: UUID) -> Architype | None: ...
-    def save_obj(self, item: Architype, persistent: bool) -> None: ...
-    def reset(self) -> None: ...
-
-exec_context: ContextVar[ExecutionContext | None]
-
-class JacTestResult(unittest.TextTestResult):
-    failures_count: Incomplete
-    max_failures: Incomplete
-    def __init__(
-        self, stream, descriptions, verbosity: int, max_failures: int | None = None
-    ) -> None: ...
-    def addFailure(self, test, err) -> None: ...
-    shouldStop: bool
-    def stop(self) -> None: ...
-
-class JacTextTestRunner(unittest.TextTestRunner):
-    max_failures: Incomplete
-    def __init__(self, max_failures: int | None = None, **kwargs) -> None: ...
-
-class JacTestCheck:
-    test_case: Incomplete
-    test_suite: Incomplete
-    breaker: bool
-    failcount: int
-    @staticmethod
-    def reset() -> None: ...
-    @staticmethod
-    def run_test(xit: bool, maxfail: int | None, verbose: bool) -> None: ...
-    @staticmethod
-    def add_test(test_fun: Callable) -> None: ...
-    def __getattr__(self, name: str) -> object: ...
diff --git a/jac/stubs/jaclang/runtimelib/importer.pyi b/jac/stubs/jaclang/runtimelib/importer.pyi
deleted file mode 100644
index ebd7d731d3..0000000000
--- a/jac/stubs/jaclang/runtimelib/importer.pyi
+++ /dev/null
@@ -1,104 +0,0 @@
-import types
-from _typeshed import Incomplete
-from jaclang.compiler.absyntree import Module as Module
-from jaclang.compiler.compile import compile_jac as compile_jac
-from jaclang.runtimelib.machine import JacMachine as JacMachine
-from jaclang.runtimelib.utils import sys_path_context as sys_path_context
-from jaclang.utils.log import logging as logging
-
-logger: Incomplete
-
-class ImportPathSpec:
-    target: Incomplete
-    base_path: Incomplete
-    absorb: Incomplete
-    cachable: Incomplete
-    mdl_alias: Incomplete
-    override_name: Incomplete
-    mod_bundle: Incomplete
-    language: Incomplete
-    items: Incomplete
-    module_name: Incomplete
-    package_path: Incomplete
-    caller_dir: Incomplete
-    full_target: Incomplete
-    def __init__(
-        self,
-        target: str,
-        base_path: str,
-        absorb: bool,
-        cachable: bool,
-        mdl_alias: str | None,
-        override_name: str | None,
-        mod_bundle: Module | str | None,
-        lng: str | None,
-        items: dict[str, str | str | None] | None,
-    ) -> None: ...
-    def get_caller_dir(self) -> str: ...
-
-class ImportReturn:
-    ret_mod: Incomplete
-    ret_items: Incomplete
-    importer: Incomplete
-    def __init__(
-        self,
-        ret_mod: types.ModuleType,
-        ret_items: list[types.ModuleType],
-        importer: Importer,
-    ) -> None: ...
-    def process_items(
-        self,
-        module: types.ModuleType,
-        items: dict[str, str | str | None],
-        caller_dir: str,
-        lang: str | None,
-        mod_bundle: Module | None = None,
-        cachable: bool = True,
-    ) -> None: ...
-    def load_jac_mod_as_item(
-        self,
-        module: types.ModuleType,
-        name: str,
-        jac_file_path: str,
-        mod_bundle: Module | None,
-        cachable: bool,
-        caller_dir: str,
-    ) -> types.ModuleType | None: ...
-
-class Importer:
-    jac_machine: Incomplete
-    result: Incomplete
-    def __init__(self, jac_machine: JacMachine) -> None: ...
-    def run_import(self, spec: ImportPathSpec) -> ImportReturn: ...
-    def update_sys(self, module: types.ModuleType, spec: ImportPathSpec) -> None: ...
-    def get_codeobj(
-        self,
-        full_target: str,
-        module_name: str,
-        mod_bundle: Module | None,
-        cachable: bool,
-        caller_dir: str,
-    ) -> types.CodeType | None: ...
-
-class PythonImporter(Importer):
-    jac_machine: Incomplete
-    def __init__(self, jac_machine: JacMachine) -> None: ...
-    result: Incomplete
-    def run_import(self, spec: ImportPathSpec) -> ImportReturn: ...
-
-class JacImporter(Importer):
-    jac_machine: Incomplete
-    def __init__(self, jac_machine: JacMachine) -> None: ...
-    def get_sys_mod_name(self, full_target: str) -> str: ...
-    def handle_directory(
-        self, module_name: str, full_mod_path: str, mod_bundle: Module | str | None
-    ) -> types.ModuleType: ...
-    def create_jac_py_module(
-        self,
-        mod_bundle: Module | str | None,
-        module_name: str,
-        package_path: str,
-        full_target: str,
-    ) -> types.ModuleType: ...
-    result: Incomplete
-    def run_import(self, spec: ImportPathSpec) -> ImportReturn: ...
diff --git a/jac/stubs/jaclang/runtimelib/machine.pyi b/jac/stubs/jaclang/runtimelib/machine.pyi
deleted file mode 100644
index 7c26519f79..0000000000
--- a/jac/stubs/jaclang/runtimelib/machine.pyi
+++ /dev/null
@@ -1,6 +0,0 @@
-from _typeshed import Incomplete
-
-class JacMachine:
-    base_path: Incomplete
-    base_path_dir: Incomplete
-    def __init__(self, base_path: str = "") -> None: ...
diff --git a/jac/stubs/jaclang/runtimelib/memory.pyi b/jac/stubs/jaclang/runtimelib/memory.pyi
deleted file mode 100644
index b06ea803f0..0000000000
--- a/jac/stubs/jaclang/runtimelib/memory.pyi
+++ /dev/null
@@ -1,26 +0,0 @@
-import shelve
-from .architype import Architype as Architype
-from _typeshed import Incomplete
-from uuid import UUID
-
-class Memory:
-    mem: dict[UUID, Architype]
-    save_obj_list: dict[UUID, Architype]
-    def __init__(self) -> None: ...
-    def get_obj(self, obj_id: UUID) -> Architype | None: ...
-    def get_obj_from_store(self, obj_id: UUID) -> Architype | None: ...
-    def has_obj(self, obj_id: UUID) -> bool: ...
-    def has_obj_in_store(self, obj_id: UUID) -> bool: ...
-    def save_obj(self, item: Architype, persistent: bool) -> None: ...
-    def commit(self) -> None: ...
-    def close(self) -> None: ...
-
-class ShelveStorage(Memory):
-    storage: shelve.Shelf | None
-    def __init__(self, session: str = "") -> None: ...
-    def get_obj_from_store(self, obj_id: UUID) -> Architype | None: ...
-    def has_obj_in_store(self, obj_id: UUID | str) -> bool: ...
-    def commit(self) -> None: ...
-    session: Incomplete
-    def connect(self, session: str) -> None: ...
-    def close(self) -> None: ...
diff --git a/jac/stubs/jaclang/runtimelib/utils.pyi b/jac/stubs/jaclang/runtimelib/utils.pyi
deleted file mode 100644
index 18b6fb75c3..0000000000
--- a/jac/stubs/jaclang/runtimelib/utils.pyi
+++ /dev/null
@@ -1,35 +0,0 @@
-import ast as ast3
-import jaclang.compiler.absyntree as ast
-from jaclang.compiler.semtable import SemScope as SemScope
-from jaclang.runtimelib.constructs import (
-    NodeAnchor as NodeAnchor,
-    NodeArchitype as NodeArchitype,
-)
-from typing import Callable, Iterator
-
-def sys_path_context(path: str) -> Iterator[None]: ...
-def collect_node_connections(
-    current_node: NodeAnchor, visited_nodes: set, connections: set
-) -> None: ...
-def traverse_graph(
-    node: NodeArchitype,
-    cur_depth: int,
-    depth: int,
-    edge_type: list[str],
-    traverse: bool,
-    connections: list,
-    node_depths: dict[NodeArchitype, int],
-    visited_nodes: list,
-    queue: list,
-    bfs: bool,
-    dfs: Callable,
-    node_limit: int,
-    edge_limit: int,
-) -> None: ...
-def get_sem_scope(node: ast.AstNode) -> SemScope: ...
-def extract_type(node: ast.AstNode) -> list[str]: ...
-def extract_params(
-    body: ast.FuncCall,
-) -> tuple[
-    dict[str, ast.Expr], list[tuple[str, ast3.AST]], list[tuple[str, ast3.AST]]
-]: ...
diff --git a/jac/stubs/jaclang/settings.pyi b/jac/stubs/jaclang/settings.pyi
deleted file mode 100644
index 640f279404..0000000000
--- a/jac/stubs/jaclang/settings.pyi
+++ /dev/null
@@ -1,35 +0,0 @@
-from _typeshed import Incomplete
-from dataclasses import dataclass
-
-__all__ = ["settings"]
-
-@dataclass
-class Settings:
-    fuse_type_info_debug: bool = ...
-    filter_sym_builtins: bool = ...
-    ast_symbol_info_detailed: bool = ...
-    pass_timer: bool = ...
-    py_raise: bool = ...
-    py_raise_deep: bool = ...
-    max_line_length: int = ...
-    lsp_debug: bool = ...
-    config_file_path = ...
-    def __post_init__(self) -> None: ...
-    def load_all(self) -> None: ...
-    def load_config_file(self) -> None: ...
-    def load_env_vars(self) -> None: ...
-    def str_to_bool(self, value: str) -> bool: ...
-    def convert_type(self, value: str) -> bool | str | int: ...
-    def __init__(
-        self,
-        fuse_type_info_debug=...,
-        filter_sym_builtins=...,
-        ast_symbol_info_detailed=...,
-        pass_timer=...,
-        py_raise=...,
-        py_raise_deep=...,
-        max_line_length=...,
-        lsp_debug=...,
-    ) -> None: ...
-
-settings: Incomplete
diff --git a/jac/stubs/jaclang/utils/__init__.pyi b/jac/stubs/jaclang/utils/__init__.pyi
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/jac/stubs/jaclang/utils/helpers.pyi b/jac/stubs/jaclang/utils/helpers.pyi
deleted file mode 100644
index 2d65c83efb..0000000000
--- a/jac/stubs/jaclang/utils/helpers.pyi
+++ /dev/null
@@ -1,18 +0,0 @@
-import pdb
-from _typeshed import Incomplete
-
-def pascal_to_snake(pascal_string: str) -> str: ...
-def heading_to_snake(heading: str) -> str: ...
-def add_line_numbers(s: str) -> str: ...
-def clip_code_section(s: str, target_line: int, line_range: int) -> str: ...
-def get_ast_nodes_as_snake_case() -> list[str]: ...
-def extract_headings(file_path: str) -> dict[str, tuple[int, int]]: ...
-def auto_generate_refs() -> None: ...
-def is_standard_lib_module(module_path: str) -> bool: ...
-
-class Jdb(pdb.Pdb):
-    prompt: str
-    def __init__(self, *args, **kwargs) -> None: ...
-    def has_breakpoint(self, bytecode: bytes) -> bool: ...
-
-debugger: Incomplete
diff --git a/jac/stubs/jaclang/utils/lang_tools.pyi b/jac/stubs/jaclang/utils/lang_tools.pyi
deleted file mode 100644
index 0c178210f0..0000000000
--- a/jac/stubs/jaclang/utils/lang_tools.pyi
+++ /dev/null
@@ -1,43 +0,0 @@
-import jaclang.compiler.absyntree as ast
-from _typeshed import Incomplete
-from jaclang.compiler.compile import jac_file_to_pass as jac_file_to_pass
-from jaclang.compiler.passes.main.pyast_load_pass import (
-    PyastBuildPass as PyastBuildPass,
-)
-from jaclang.compiler.passes.main.schedules import (
-    py_code_gen as py_code_gen,
-    py_code_gen_typed as py_code_gen_typed,
-    type_checker_sched as type_checker_sched,
-)
-from jaclang.compiler.symtable import SymbolTable as SymbolTable
-from jaclang.utils.helpers import (
-    auto_generate_refs as auto_generate_refs,
-    pascal_to_snake as pascal_to_snake,
-)
-
-class AstKidInfo:
-    name: Incomplete
-    typ: Incomplete
-    default: Incomplete
-    def __init__(self, name: str, typ: str, default: str | None = None) -> None: ...
-
-class AstNodeInfo:
-    type_map: dict[str, type]
-    cls: Incomplete
-    def __init__(self, cls: type) -> None: ...
-    name: Incomplete
-    doc: Incomplete
-    class_name_snake: Incomplete
-    init_sig: Incomplete
-    kids: Incomplete
-    def process(self, cls: type[ast.AstNode]) -> None: ...
-
-class AstTool:
-    ast_classes: Incomplete
-    def __init__(self) -> None: ...
-    def pass_template(self) -> str: ...
-    def py_ast_nodes(self) -> str: ...
-    def md_doc(self) -> str: ...
-    def ir(self, args: list[str]) -> str: ...
-    def automate_ref(self) -> str: ...
-    def gen_parser(self) -> str: ...
diff --git a/jac/stubs/jaclang/utils/log.pyi b/jac/stubs/jaclang/utils/log.pyi
deleted file mode 100644
index 5ed71781c8..0000000000
--- a/jac/stubs/jaclang/utils/log.pyi
+++ /dev/null
@@ -1,3 +0,0 @@
-import logging as logging
-
-__all__ = ["logging"]
diff --git a/jac/stubs/jaclang/utils/treeprinter.pyi b/jac/stubs/jaclang/utils/treeprinter.pyi
deleted file mode 100644
index 5f88195597..0000000000
--- a/jac/stubs/jaclang/utils/treeprinter.pyi
+++ /dev/null
@@ -1,47 +0,0 @@
-import ast as ast3
-from _typeshed import Incomplete
-from jaclang.compiler.absyntree import AstNode as AstNode, SymbolTable as SymbolTable
-from jaclang.settings import settings as settings
-
-id_bag: dict
-id_used: int
-CLASS_COLOR_MAP: dict[str, str]
-
-def dotgen_ast_tree(root: AstNode, dot_lines: list[str] | None = None) -> str: ...
-def print_ast_tree(
-    root: AstNode | ast3.AST,
-    marker: str = "+-- ",
-    level_markers: list[bool] | None = None,
-    output_file: str | None = None,
-    max_depth: int | None = None,
-) -> str: ...
-
-class SymbolTree:
-    kid: Incomplete
-    name: Incomplete
-    def __init__(
-        self,
-        node_name: str,
-        parent: SymbolTree | None = None,
-        children: list[SymbolTree] | None = None,
-    ) -> None: ...
-    @property
-    def parent(self) -> SymbolTree | None: ...
-    @parent.setter
-    def parent(self, parent_node: SymbolTree | None) -> None: ...
-
-def print_symtab_tree(
-    root: SymbolTable,
-    marker: str = "+-- ",
-    level_markers: list[bool] | None = None,
-    output_file: str | None = None,
-    depth: int | None = None,
-) -> str: ...
-def get_symtab_tree_str(
-    root: SymbolTree,
-    marker: str = "+-- ",
-    level_markers: list[bool] | None = None,
-    output_file: str | None = None,
-    depth: int | None = None,
-) -> str: ...
-def dotgen_symtab_tree(node: SymbolTable) -> str: ...


Test patch:
diff --git a/jac-cloud/jac_cloud/tests/simple_graph.jac b/jac-cloud/jac_cloud/tests/simple_graph.jac
index 009c2f9b71..dd8884222b 100644
--- a/jac-cloud/jac_cloud/tests/simple_graph.jac
+++ b/jac-cloud/jac_cloud/tests/simple_graph.jac
@@ -281,7 +281,7 @@ walker manual_detach_nested_node {
     can enter_root with `root entry {
         nested = [-->(`?Nested)][0];
         detached = here del--> [-->(`?Nested)];
-        nested.__jac__.destroy();
+        Jac.destroy(nested);
         nested.__jac__.apply();
 
         # simulate no auto save
@@ -296,7 +296,7 @@ walker manual_detach_nested_node {
 walker delete_nested_node {
     can enter_root with `root entry {
         nested = [-->(`?Nested)][0];
-        nested.__jac__.destroy();
+        Jac.destroy(nested);
         # nested.__jac__.apply();
 
         report [-->(`?Nested)];
@@ -306,7 +306,7 @@ walker delete_nested_node {
 walker manual_delete_nested_node {
     can enter_root with `root entry {
         nested = [-->(`?Nested)][0];
-        nested.__jac__.destroy();
+        Jac.destroy(nested);
         nested.__jac__.apply();
 
         # simulate no auto save
@@ -321,7 +321,7 @@ walker manual_delete_nested_node {
 walker delete_nested_edge {
     can enter_root with `root entry {
         nested_edge = :e:[-->][0];
-        nested_edge.__jac__.destroy();
+        Jac.destroy(nested_edge);
 
         report [-->(`?Nested)];
     }
@@ -330,7 +330,7 @@ walker delete_nested_edge {
 walker manual_delete_nested_edge {
     can enter_root with `root entry {
         nested_edge = :e:[-->][0];
-        nested_edge.__jac__.destroy();
+        Jac.destroy(nested_edge);
         nested_edge.__jac__.apply();
 
         # simulate no auto save
@@ -347,17 +347,17 @@ walker allow_other_root_access {
 
     can enter_root with `root entry {
         if self.via_all {
-            here.__jac__.unrestrict(self.level);
+            Jac.unrestrict(here, self.level);
         } else {
-            here.__jac__.allow_root(BaseAnchor.ref(self.root_id), self.level);
+            Jac.allow_root(here, BaseAnchor.ref(self.root_id), self.level);
         }
     }
 
     can enter_nested with Nested entry {
         if self.via_all {
-            here.__jac__.unrestrict(self.level);
+            Jac.unrestrict(here, self.level);
         } else {
-            here.__jac__.allow_root(BaseAnchor.ref(self.root_id), self.level);
+            Jac.allow_root(here, BaseAnchor.ref(self.root_id), self.level);
         }
     }
 }
@@ -367,17 +367,17 @@ walker disallow_other_root_access {
 
     can enter_root with `root entry {
         if self.via_all {
-            here.__jac__.restrict();
+            Jac.restrict(here);
         } else {
-            here.__jac__.disallow_root(BaseAnchor.ref(self.root_id));
+            Jac.disallow_root(here, BaseAnchor.ref(self.root_id));
         }
     }
 
     can enter_nested with Nested entry {
         if self.via_all {
-            here.__jac__.restrict();
+            Jac.restrict(here);
         } else {
-            here.__jac__.disallow_root(BaseAnchor.ref(self.root_id));
+            Jac.disallow_root(here, BaseAnchor.ref(self.root_id));
         }
     }
 }
diff --git a/jac/jaclang/plugin/tests/fixtures/other_root_access.jac b/jac/jaclang/plugin/tests/fixtures/other_root_access.jac
index df5192d9ec..384587fe7f 100644
--- a/jac/jaclang/plugin/tests/fixtures/other_root_access.jac
+++ b/jac/jaclang/plugin/tests/fixtures/other_root_access.jac
@@ -36,7 +36,7 @@ walker create_node {
 walker create_other_root {
     can enter with `root entry {
         other_root = `root().__jac__;
-        other_root.save();
+        Jac.save(other_root);
         print(other_root.id);
     }
 }
@@ -46,17 +46,17 @@ walker allow_other_root_access {
 
     can enter_root with `root entry {
         if self.via_all {
-            here.__jac__.unrestrict(self.level);
+            Jac.unrestrict(here, self.level);
         } else {
-            here.__jac__.allow_root(UUID(self.root_id), self.level);
+            Jac.allow_root(here, UUID(self.root_id), self.level);
         }
     }
 
     can enter_nested with A entry {
         if self.via_all {
-            here.__jac__.unrestrict(self.level);
+            Jac.unrestrict(here, self.level);
         } else {
-            here.__jac__.allow_root(UUID(self.root_id), self.level);
+            Jac.allow_root(here, UUID(self.root_id), self.level);
         }
     }
 }
@@ -66,17 +66,17 @@ walker disallow_other_root_access {
 
     can enter_root with `root entry {
         if self.via_all {
-            here.__jac__.restrict();
+            Jac.restrict(here);
         } else {
-            here.__jac__.disallow_root(UUID(self.root_id));
+            Jac.disallow_root(here, UUID(self.root_id));
         }
     }
 
     can enter_nested with A entry {
         if self.via_all {
-            here.__jac__.restrict();
+            Jac.restrict(here);
         } else {
-            here.__jac__.disallow_root(UUID(self.root_id));
+            Jac.disallow_root(here, UUID(self.root_id));
         }
     }
 }
\ No newline at end of file
diff --git a/jac/jaclang/plugin/tests/test_features.py b/jac/jaclang/plugin/tests/test_features.py
index 22a3f99faa..6c3e8e0afa 100644
--- a/jac/jaclang/plugin/tests/test_features.py
+++ b/jac/jaclang/plugin/tests/test_features.py
@@ -3,7 +3,7 @@
 import inspect
 from typing import List, Type
 
-from jaclang.plugin.default import JacFeatureDefaults
+from jaclang.plugin.default import JacFeatureImpl
 from jaclang.plugin.feature import JacFeature
 from jaclang.plugin.spec import JacFeatureSpec
 from jaclang.utils.test import TestCase
@@ -46,7 +46,7 @@ def test_feature_funcs_synced(self) -> None:
         """Test if JacFeature, JacFeatureDefaults, and JacFeatureSpec have synced methods."""
         # Get methods of each class
         jac_feature_methods = self.get_methods(JacFeature)
-        jac_feature_defaults_methods = self.get_methods(JacFeatureDefaults)
+        jac_feature_defaults_methods = self.get_methods(JacFeatureImpl)
         jac_feature_spec_methods = self.get_methods(JacFeatureSpec)
 
         # Check if all methods are the same in all classes
diff --git a/jac/jaclang/tests/fixtures/arch_create_util.jac b/jac/jaclang/tests/fixtures/arch_create_util.jac
new file mode 100644
index 0000000000..6df4fdee9b
--- /dev/null
+++ b/jac/jaclang/tests/fixtures/arch_create_util.jac
@@ -0,0 +1,7 @@
+node UtilityNode {
+    has data: int;
+
+    can display_data with entry {
+        print("UtilityNode Data:", f'{self.data}');
+    }
+}
diff --git a/jac/jaclang/tests/fixtures/arch_rel_import_creation.jac b/jac/jaclang/tests/fixtures/arch_rel_import_creation.jac
new file mode 100644
index 0000000000..b4968aaf7a
--- /dev/null
+++ b/jac/jaclang/tests/fixtures/arch_rel_import_creation.jac
@@ -0,0 +1,30 @@
+import:py from jaclang.runtimelib.machine { JacMachine }
+
+glob dynamic_module_source = """
+import from .arch_create_util {UtilityNode}
+
+walker DynamicWalker {
+can start with entry {
+print("DynamicWalker Started");
+here ++> UtilityNode(data=42);
+visit [-->](`?UtilityNode);
+}
+
+can UtilityNode {
+here.display_data();
+}
+}
+""";
+
+with entry {
+    node_arch = JacMachine.get().create_architype_from_source(
+        dynamic_module_source,
+        module_name="dynamic_module"
+    );
+    walker_obj = JacMachine.get().spawn_walker(
+        'DynamicWalker',
+        module_name="dynamic_module",
+
+    );
+    root spawn walker_obj;
+}
diff --git a/jac/jaclang/tests/fixtures/create_dynamic_architype.jac b/jac/jaclang/tests/fixtures/create_dynamic_architype.jac
new file mode 100644
index 0000000000..c0d4dea740
--- /dev/null
+++ b/jac/jaclang/tests/fixtures/create_dynamic_architype.jac
@@ -0,0 +1,35 @@
+import:py from jaclang.runtimelib.machine { JacMachine }
+# Dynamically create a node architype
+glob source_code = """
+node dynamic_node {
+has value:int;
+can print_value with entry {
+print("Dynamic Node Value:", f'{self.value}');
+}
+}
+""";
+
+# Create a new walker architype dynamically
+glob walker_code = """
+walker dynamic_walker {
+can visit_nodes with entry {
+visit [-->](`?dynamic_node);
+}
+}
+""";
+
+with entry {
+    node_arch = JacMachine.get().create_architype_from_source(source_code);
+    walker_arch = JacMachine.get().create_architype_from_source(walker_code);
+
+    node_obj = JacMachine.get().spawn_node(
+        'dynamic_node',
+        {'value': 99},
+        node_arch.__name__
+    );
+    walker_obj = JacMachine.get().spawn_walker(
+        'dynamic_walker',
+        module_name=walker_arch.__name__
+    );
+    node_obj spawn walker_obj;
+}
diff --git a/jac/jaclang/tests/fixtures/edge_node_walk.jac b/jac/jaclang/tests/fixtures/edge_node_walk.jac
index c4ba4b0b61..7901930743 100644
--- a/jac/jaclang/tests/fixtures/edge_node_walk.jac
+++ b/jac/jaclang/tests/fixtures/edge_node_walk.jac
@@ -37,7 +37,7 @@ edge Edge_c {
 
 with entry {
     print(root spawn creator());
-    print(root.__jac__.gen_dot());
+    print(Jac.node_dot(root));
     print([root-:Edge_a:->]);
     print([root-:Edge_c:->]);
     print([root-:Edge_a:->-:Edge_b:->]);
diff --git a/jac/jaclang/tests/fixtures/edges_walk.jac b/jac/jaclang/tests/fixtures/edges_walk.jac
index b5b242f0ca..aaef4dd15a 100644
--- a/jac/jaclang/tests/fixtures/edges_walk.jac
+++ b/jac/jaclang/tests/fixtures/edges_walk.jac
@@ -30,7 +30,7 @@ edge Edge_c{
 
 with entry{
     print(root spawn creator());
-    print(root.__jac__.gen_dot());
+    print(Jac.node_dot(root));
     print([root -:Edge_a:->]);
     print([root -:Edge_c:->]);
     print([root -:Edge_a:-> -:Edge_b:->]);
diff --git a/jac/jaclang/tests/fixtures/gendot_bubble_sort.jac b/jac/jaclang/tests/fixtures/gendot_bubble_sort.jac
index 30c8003bbb..8348fc1fee 100644
--- a/jac/jaclang/tests/fixtures/gendot_bubble_sort.jac
+++ b/jac/jaclang/tests/fixtures/gendot_bubble_sort.jac
@@ -73,5 +73,5 @@ with entry {
     root spawn walker1();
     root spawn walker2();
     root spawn walker3();
-    print(root.__jac__.gen_dot());
+    print(Jac.node_dot(root));
 }
diff --git a/jac/jaclang/tests/fixtures/visit_order.jac b/jac/jaclang/tests/fixtures/visit_order.jac
new file mode 100644
index 0000000000..d7d0af7a56
--- /dev/null
+++ b/jac/jaclang/tests/fixtures/visit_order.jac
@@ -0,0 +1,20 @@
+node MyNode{
+    has Name:str;
+}
+
+edge a{}
+
+edge b{}
+
+with entry{
+    Start = MyNode("Start");
+    End = MyNode("End");
+    mid = MyNode("Middle");
+    root <+:a:+ Start;
+    root +:a:+> End;
+    root +:b:+> mid;
+    root +:a:+> mid;
+
+    print([root-->]);
+
+}
diff --git a/jac/jaclang/tests/test_language.py b/jac/jaclang/tests/test_language.py
index 3c71339e5c..e24da0b131 100644
--- a/jac/jaclang/tests/test_language.py
+++ b/jac/jaclang/tests/test_language.py
@@ -80,6 +80,18 @@ def test_simple_jac_red(self) -> None:
             "\nValue: 5\nValue: 6\nValue: 7\nFinal Value: 8\nDone walking.\n",
         )
 
+    def test_simple_walk_by_edge(self) -> None:
+        """Parse micro jac file."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        jac_import("micro.simple_walk_by_edge", base_path=self.examples_abs_path(""))
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue()
+        self.assertEqual(
+            stdout_value,
+            "Visited 1\nVisited 2\n",
+        )
+
     def test_guess_game(self) -> None:
         """Parse micro jac file."""
         captured_output = io.StringIO()
@@ -1070,6 +1082,38 @@ def test_dynamic_spawn_architype(self) -> None:
                 f"Expected '{val}' to appear 2 times, but found {len(occurrences)}.",
             )
 
+    def test_dynamic_architype_creation(self) -> None:
+        """Test that the walker and node can be created dynamically."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        cli.run(self.fixture_abs_path("create_dynamic_architype.jac"))
+
+        output = captured_output.getvalue().strip()
+        # Expected outputs for spawned entities
+        expected_spawned_walker = "Dynamic Node Value: 99"
+
+        # Check for the spawned messages
+        self.assertTrue(
+            expected_spawned_walker in output,
+            f"Expected '{expected_spawned_walker}' in output.",
+        )
+
+    def test_dynamic_architype_creation_rel_import(self) -> None:
+        """Test that the walker and node can be created dynamically, with relative import."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        cli.run(self.fixture_abs_path("arch_rel_import_creation.jac"))
+
+        output = captured_output.getvalue().strip().splitlines()
+        # Expected outputs for spawned entities
+        expected_values = ["DynamicWalker Started", "UtilityNode Data: 42"]
+        for val in expected_values:
+            # Check for the spawned messages
+            self.assertTrue(
+                val in output,
+                f"Expected '{val}' in output.",
+            )
+
     def test_object_ref_interface(self) -> None:
         """Test class method output."""
         captured_output = io.StringIO()
@@ -1103,3 +1147,12 @@ def test_entry_exit(self) -> None:
         self.assertIn(
             "Exiting at the end of walker:  test_node(value=", stdout_value[11]
         )
+
+    def test_visit_order(self) -> None:
+        """Test entry and exit behavior of walker."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        jac_import("visit_order", base_path=self.fixture_abs_path("./"))
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue()
+        self.assertEqual("[MyNode(Name='End'), MyNode(Name='Middle')]\n", stdout_value)