@skillcap/gdh 3.0.2 → 3.1.0

package/node_modules/@gdh/runtime/dist/bridge-surface.js

@@ -1,7 +1,7 @@
 import fs from "node:fs/promises";
 import path from "node:path";
-import {} from "@gdh/core";
-const RUNTIME_BRIDGE_SURFACE_VERSION = 11;
+import { renderEditorOperationCatalogGdscript } from "@gdh/editor";
+const RUNTIME_BRIDGE_SURFACE_VERSION = 14;
 const AUTOLOAD_ENABLE_SENTINEL = "GDH_RUNTIME_BRIDGE_AUTOLOAD_ENABLED";
 const DEFAULT_RUNTIME_BRIDGE_CONFIG = {
     enabled: true,
@@ -50,6 +50,7 @@ export async function inspectRuntimeBridgeSurface(input) {
             projectGodotPath: null,
             addonRootPath: null,
             autoloadRegistered: false,
+            editorPluginRegistered: false,
             customEntryPaths: [],
             managedArtifacts: [],
         };
@@ -67,6 +68,7 @@ export async function inspectRuntimeBridgeSurface(input) {
             projectGodotPath: null,
             addonRootPath: null,
             autoloadRegistered: false,
+            editorPluginRegistered: false,
             customEntryPaths: [],
             managedArtifacts: [],
         };
@@ -89,12 +91,14 @@ export async function inspectRuntimeBridgeSurface(input) {
             projectGodotPath,
             addonRootPath,
             autoloadRegistered: false,
+            editorPluginRegistered: false,
             customEntryPaths: [],
             managedArtifacts: [],
         };
     }
     const projectGodotContent = await fs.readFile(projectGodotPath, "utf8");
     const autoloadRegistered = hasAutoloadRegistration(projectGodotContent, runtimeBridge);
+    const editorPluginRegistered = hasEditorPluginRegistration(projectGodotContent, runtimeBridge);
     const managedArtifacts = await Promise.all(managedFiles.map((file) => inspectManagedBridgeFile({
         targetPath: resolvedTargetPath,
         targetProjectPath,
@@ -110,6 +114,7 @@ export async function inspectRuntimeBridgeSurface(input) {
     const hasPresentManagedFiles = managedArtifacts.some((artifact) => artifact.state === "present" || artifact.state === "drifted");
     const state = resolveRuntimeBridgeState({
         autoloadRegistered,
+        editorPluginRegistered,
         hasDrift,
         hasMissing,
         hasPresentManagedFiles,
@@ -122,6 +127,7 @@ export async function inspectRuntimeBridgeSurface(input) {
             ? ["runtime_bridge_plugin_enable_required"]
             : []),
         ...(!autoloadRegistered ? ["runtime_bridge_autoload_missing_or_drifted"] : []),
+        ...(!editorPluginRegistered ? ["editor_bridge_plugin_missing_or_drifted"] : []),
         ...managedArtifacts
             .filter((artifact) => artifact.state === "missing")
             .map((artifact) => `runtime_bridge_missing:${artifact.id}`),
@@ -136,6 +142,7 @@ export async function inspectRuntimeBridgeSurface(input) {
             state,
             compatibility: resolvedConfig.compatibility,
             autoloadRegistered,
+            editorPluginRegistered,
             runtimeBridge,
             customEntryCount: customEntryPaths.length,
         }),
@@ -147,6 +154,7 @@ export async function inspectRuntimeBridgeSurface(input) {
         projectGodotPath,
         addonRootPath,
         autoloadRegistered,
+        editorPluginRegistered,
         customEntryPaths,
         managedArtifacts,
     };
@@ -197,30 +205,31 @@ async function applyRuntimeBridgeOperation(input) {
             actions.push({
                 id: `remove-${artifact.id}`,
                 kind: "remove_file",
-                state: artifact.state === "missing"
-                    ? "unchanged"
-                    : input.dryRun
-                        ? "planned"
-                        : "applied",
+                state: artifact.state === "missing" ? "unchanged" : input.dryRun ? "planned" : "applied",
                 relativePath: artifact.relativePath,
                 summary: artifact.state === "missing"
-                    ? "Managed runtime bridge file is already absent."
-                    : "Remove the GDH-managed runtime bridge file.",
+                    ? "Managed bridge addon file is already absent."
+                    : "Remove the GDH-managed bridge addon file.",
             });
         }
         actions.push({
             id: "remove-runtime-bridge-autoload",
             kind: "remove_project_godot_entry",
-            state: !status.autoloadRegistered
-                ? "unchanged"
-                : input.dryRun
-                    ? "planned"
-                    : "applied",
+            state: !status.autoloadRegistered ? "unchanged" : input.dryRun ? "planned" : "applied",
             relativePath: path.relative(status.targetPath, projectGodotPath),
             summary: !status.autoloadRegistered
                 ? "Runtime bridge autoload entry is already absent."
                 : "Remove the GDH runtime bridge autoload entry left by older bridge installs.",
         });
+        actions.push({
+            id: "remove-editor-bridge-plugin-registration",
+            kind: "remove_project_godot_entry",
+            state: !status.editorPluginRegistered ? "unchanged" : input.dryRun ? "planned" : "applied",
+            relativePath: path.relative(status.targetPath, projectGodotPath),
+            summary: !status.editorPluginRegistered
+                ? "GDH editor plugin registration is already absent."
+                : "Remove the GDH editor plugin registration from project.godot.",
+        });
         if (!input.dryRun) {
             for (const artifact of status.managedArtifacts) {
                 if (artifact.state === "missing") {
@@ -232,17 +241,17 @@ async function applyRuntimeBridgeOperation(input) {
                 const content = await fs.readFile(projectGodotPath, "utf8");
                 await fs.writeFile(projectGodotPath, removeAutoloadRegistration(content, status.runtimeBridge), "utf8");
             }
+            if (status.editorPluginRegistered) {
+                const content = await fs.readFile(projectGodotPath, "utf8");
+                await fs.writeFile(projectGodotPath, removeEditorPluginRegistration(content, status.runtimeBridge), "utf8");
+            }
         }
     }
     else {
         actions.push({
             id: "write-project-bridge-entries-gitkeep",
             kind: "write_file",
-            state: projectEntryGitkeepExists
-                ? "unchanged"
-                : input.dryRun
-                    ? "planned"
-                    : "applied",
+            state: projectEntryGitkeepExists ? "unchanged" : input.dryRun ? "planned" : "applied",
             relativePath: normalizePath(path.relative(status.targetPath, projectEntryGitkeepPath)),
             summary: projectEntryGitkeepExists
                 ? "Project-owned runtime bridge entry folder scaffold already exists."
@@ -253,30 +262,31 @@ async function applyRuntimeBridgeOperation(input) {
             actions.push({
                 id: `write-${file.id}`,
                 kind: "write_file",
-                state: artifact.state === "present"
-                    ? "unchanged"
-                    : input.dryRun
-                        ? "planned"
-                        : "applied",
+                state: artifact.state === "present" ? "unchanged" : input.dryRun ? "planned" : "applied",
                 relativePath: artifact.relativePath,
                 summary: artifact.state === "present"
-                    ? "Managed runtime bridge file already matches the current GDH baseline."
-                    : "Write the GDH-managed runtime bridge file.",
+                    ? "Managed bridge addon file already matches the current GDH baseline."
+                    : "Write the GDH-managed bridge addon file.",
             });
         }
         actions.push({
             id: "write-runtime-bridge-autoload",
             kind: "update_project_godot",
-            state: status.autoloadRegistered
-                ? "unchanged"
-                : input.dryRun
-                    ? "planned"
-                    : "applied",
+            state: status.autoloadRegistered ? "unchanged" : input.dryRun ? "planned" : "applied",
             relativePath: path.relative(status.targetPath, projectGodotPath),
             summary: status.autoloadRegistered
                 ? "Runtime bridge autoload entry is already present."
                 : "Register the GDH runtime bridge autoload in project.godot (class-3 register_autoload op, GDH_MANAGED_SURFACE_CLASSES allowlist).",
         });
+        actions.push({
+            id: "write-editor-bridge-plugin-registration",
+            kind: "update_project_godot",
+            state: status.editorPluginRegistered ? "unchanged" : input.dryRun ? "planned" : "applied",
+            relativePath: path.relative(status.targetPath, projectGodotPath),
+            summary: status.editorPluginRegistered
+                ? "GDH editor plugin registration is already present."
+                : "Register the GDH editor plugin in project.godot (class-3 edit_editor_plugins_array op, GDH_MANAGED_SURFACE_CLASSES allowlist).",
+        });
         if (!input.dryRun) {
             if (!projectEntryGitkeepExists) {
                 await fs.mkdir(path.dirname(projectEntryGitkeepPath), { recursive: true });
@@ -295,6 +305,10 @@ async function applyRuntimeBridgeOperation(input) {
                 const content = await fs.readFile(projectGodotPath, "utf8");
                 await fs.writeFile(projectGodotPath, addAutoloadRegistration(content, status.runtimeBridge), "utf8");
             }
+            if (!status.editorPluginRegistered) {
+                const content = await fs.readFile(projectGodotPath, "utf8");
+                await fs.writeFile(projectGodotPath, addEditorPluginRegistration(content, status.runtimeBridge), "utf8");
+            }
         }
     }
     const nextStatus = input.dryRun
@@ -328,7 +342,7 @@ async function inspectManagedBridgeFile(input) {
             absolutePath,
             managed: true,
             state: "missing",
-            summary: "Managed runtime bridge file has not been installed yet.",
+            summary: "Managed bridge addon file has not been installed yet.",
             expectedVersion: input.file.expectedVersion,
             detectedVersion: null,
         };
@@ -340,8 +354,8 @@ async function inspectManagedBridgeFile(input) {
         managed: true,
         state: currentContent === input.file.content ? "present" : "drifted",
         summary: currentContent === input.file.content
-            ? "Managed runtime bridge file matches the current GDH baseline."
-            : "Managed runtime bridge file exists but has drifted from the current GDH baseline.",
+            ? "Managed bridge addon file matches the current GDH baseline."
+            : "Managed bridge addon file exists but has drifted from the current GDH baseline.",
         expectedVersion: input.file.expectedVersion,
         detectedVersion: input.file.relativePath.endsWith(".json")
             ? parseBridgeManifestVersion(currentContent)
@@ -378,6 +392,7 @@ function renderManagedBridgeFiles(runtimeBridge) {
         managedFiles: [
             "plugin.cfg",
             "plugin.gd",
+            "editor/gdh_editor_bridge_plugin.gd",
             "registry/bridge_registry.gd",
             "entries/core_entries.gd",
             "runtime/gdh_runtime_bridge.gd",
@@ -390,11 +405,11 @@ function renderManagedBridgeFiles(runtimeBridge) {
             relativePath: normalizePath(path.join(runtimeBridge.addonPath, "plugin.cfg")),
             expectedVersion: RUNTIME_BRIDGE_SURFACE_VERSION,
             content: [
-                `; GDH managed runtime bridge v${RUNTIME_BRIDGE_SURFACE_VERSION}`,
+                `; GDH managed bridge addon v${RUNTIME_BRIDGE_SURFACE_VERSION}`,
                 "",
                 "[plugin]",
-                'name="GDH Runtime Bridge"',
-                'description="GDH-managed bounded runtime bridge surface."',
+                'name="GDH Bridge"',
+                'description="GDH-managed editor and runtime bridge surfaces."',
                 'author="GDH"',
                 `version="${RUNTIME_BRIDGE_SURFACE_VERSION}"`,
                 'script="plugin.gd"',
@@ -409,12 +424,31 @@ function renderManagedBridgeFiles(runtimeBridge) {
                 "@tool",
                 "extends EditorPlugin",
                 "",
-                `const GDH_RUNTIME_BRIDGE_VERSION := ${RUNTIME_BRIDGE_SURFACE_VERSION}`,
+                `const GDH_BRIDGE_ADDON_VERSION := ${RUNTIME_BRIDGE_SURFACE_VERSION}`,
+                `const EditorBridgePlugin = preload("res://${normalizePath(path.join(runtimeBridge.addonPath, "editor", "gdh_editor_bridge_plugin.gd"))}")`,
                 `const AUTOLOAD_NAME := "${runtimeBridge.autoloadName}"`,
                 `const AUTOLOAD_PATH := "res://${normalizePath(path.join(runtimeBridge.addonPath, "runtime", "gdh_runtime_bridge.gd"))}"`,
                 "",
+                "var _editor_bridge: RefCounted",
+                "",
+                "func _enter_tree() -> void:",
+                "\tset_process(true)",
+                "\t_editor_bridge = EditorBridgePlugin.new()",
+                '\tif _editor_bridge != null and _editor_bridge.has_method("enter_tree"):',
+                "\t\t_editor_bridge.enter_tree(self)",
+                "",
+                "func _process(delta: float) -> void:",
+                '\tif _editor_bridge != null and _editor_bridge.has_method("process"):',
+                "\t\t_editor_bridge.process(delta)",
+                "",
+                "func _exit_tree() -> void:",
+                "\tset_process(false)",
+                '\tif _editor_bridge != null and _editor_bridge.has_method("exit_tree"):',
+                "\t\t_editor_bridge.exit_tree(self)",
+                "\t_editor_bridge = null",
+                "",
                 "func _enable_plugin() -> void:",
-                "\tif not ProjectSettings.has_setting(\"autoload/%s\" % AUTOLOAD_NAME):",
+                '\tif not ProjectSettings.has_setting("autoload/%s" % AUTOLOAD_NAME):',
                 "\t\tadd_autoload_singleton(AUTOLOAD_NAME, AUTOLOAD_PATH)",
                 `\t\tProjectSettings.set_setting("${AUTOLOAD_ENABLE_SENTINEL}", true)`,
                 "",
@@ -425,6 +459,231 @@ function renderManagedBridgeFiles(runtimeBridge) {
                 "",
             ].join("\n"),
         },
+        {
+            id: "editor-bridge-plugin-gd",
+            relativePath: normalizePath(path.join(runtimeBridge.addonPath, "editor", "gdh_editor_bridge_plugin.gd")),
+            expectedVersion: RUNTIME_BRIDGE_SURFACE_VERSION,
+            content: [
+                "@tool",
+                "extends RefCounted",
+                "",
+                `const GDH_EDITOR_BRIDGE_VERSION := ${RUNTIME_BRIDGE_SURFACE_VERSION}`,
+                "const GDH_EDITOR_ADOPTION_PROTOCOL_VERSION := 1",
+                'const GDH_EDITOR_ADOPTION_HOST := "127.0.0.1"',
+                "const GDH_EDITOR_ADOPTION_PORT_START := 42240",
+                "const GDH_EDITOR_ADOPTION_PORT_END := 42320",
+                "const GDH_EDITOR_HEARTBEAT_INTERVAL_SECONDS := 2.0",
+                "",
+                "var _plugin: EditorPlugin",
+                "var _server := TCPServer.new()",
+                "var _peers: Array = []",
+                "var _heartbeat_elapsed := 0.0",
+                'var _target_root_path := ""',
+                'var _godot_project_root_path := ""',
+                'var _state_root_path := ""',
+                'var _editor_bridge_dir := ""',
+                'var _metadata_path := ""',
+                'var _token_file_path := ""',
+                'var _heartbeat_path := ""',
+                'var _token := ""',
+                "var _port := 0",
+                'var _started_at := ""',
+                "",
+                "func enter_tree(plugin: EditorPlugin) -> void:",
+                "\t_plugin = plugin",
+                "\t_started_at = _now_iso()",
+                '\t_godot_project_root_path = _normalize_absolute_path(ProjectSettings.globalize_path("res://"))',
+                "\t_target_root_path = _find_target_root(_godot_project_root_path)",
+                '\t_state_root_path = _normalize_absolute_path(_target_root_path.path_join(".gdh-state"))',
+                '\t_editor_bridge_dir = _state_root_path.path_join("editor-bridge")',
+                '\t_metadata_path = _editor_bridge_dir.path_join("adopted-editor.json")',
+                '\t_token_file_path = _editor_bridge_dir.path_join("adopted-editor.token")',
+                '\t_heartbeat_path = _editor_bridge_dir.path_join("adopted-editor.heartbeat")',
+                "\tDirAccess.make_dir_recursive_absolute(_editor_bridge_dir)",
+                "\t_token = _read_or_create_token(_token_file_path)",
+                "\t_start_server()",
+                "\t_write_heartbeat()",
+                "",
+                "func process(delta: float) -> void:",
+                "\t_poll_server()",
+                "\t_heartbeat_elapsed += delta",
+                "\tif _heartbeat_elapsed >= GDH_EDITOR_HEARTBEAT_INTERVAL_SECONDS:",
+                "\t\t_heartbeat_elapsed = 0.0",
+                "\t\t_write_heartbeat()",
+                "",
+                "func exit_tree(_plugin_instance: EditorPlugin) -> void:",
+                "\t_server.stop()",
+                "\t_peers.clear()",
+                "\tDirAccess.remove_absolute(_metadata_path)",
+                "\tDirAccess.remove_absolute(_heartbeat_path)",
+                "\t_plugin = null",
+                "",
+                "func get_status() -> Dictionary:",
+                "\treturn {",
+                '\t\t"version": GDH_EDITOR_BRIDGE_VERSION,',
+                '\t\t"state": "ready",',
+                '\t\t"capabilities": [',
+                '\t\t\t"editor_operation_catalog",',
+                '\t\t\t"editor_session_adoption_anchor",',
+                "\t\t],",
+                "\t}",
+                "",
+                "func _start_server() -> void:",
+                "\tfor candidate_port in range(GDH_EDITOR_ADOPTION_PORT_START, GDH_EDITOR_ADOPTION_PORT_END + 1):",
+                "\t\tif _server.listen(candidate_port, GDH_EDITOR_ADOPTION_HOST) == OK:",
+                "\t\t\t_port = candidate_port",
+                "\t\t\treturn",
+                "\t_server.stop()",
+                "\t_port = 0",
+                "",
+                "func _poll_server() -> void:",
+                "\tif _port <= 0:",
+                "\t\treturn",
+                "\twhile _server.is_connection_available():",
+                "\t\tvar peer := _server.take_connection()",
+                '\t\t_peers.append({"peer": peer, "buffer": PackedByteArray()})',
+                "\tvar remaining: Array = []",
+                "\tfor entry in _peers:",
+                '\t\tvar peer: StreamPeerTCP = entry["peer"]',
+                '\t\tvar buffer: PackedByteArray = entry["buffer"]',
+                "\t\tif peer.get_status() == StreamPeerTCP.STATUS_CONNECTED:",
+                "\t\t\tvar available := peer.get_available_bytes()",
+                "\t\t\tif available > 0:",
+                "\t\t\t\tvar chunk := peer.get_data(available)",
+                "\t\t\t\tif int(chunk[0]) == OK:",
+                "\t\t\t\t\tbuffer.append_array(chunk[1])",
+                "\t\t\tif _try_handle_peer(peer, buffer):",
+                "\t\t\t\tpeer.disconnect_from_host()",
+                "\t\t\telse:",
+                "\t\t\t\tremaining.append(entry)",
+                "\t_peers = remaining",
+                "",
+                "func _try_handle_peer(peer: StreamPeerTCP, buffer: PackedByteArray) -> bool:",
+                "\tvar text := buffer.get_string_from_utf8()",
+                '\tvar header_end := text.find("\\r\\n\\r\\n")',
+                "\tif header_end < 0:",
+                "\t\treturn false",
+                "\tvar header_text := text.substr(0, header_end)",
+                "\tvar body_start := header_end + 4",
+                "\tvar content_length := 0",
+                "\tvar authorized := false",
+                '\tfor raw_header in header_text.split("\\r\\n"):',
+                "\t\tvar header := str(raw_header)",
+                "\t\tvar lower := header.to_lower()",
+                '\t\tif lower.begins_with("content-length:"):',
+                '\t\t\tcontent_length = int(header.substr(header.find(":") + 1).strip_edges())',
+                '\t\telif lower.begins_with("authorization:"):',
+                '\t\t\tauthorized = header.substr(header.find(":") + 1).strip_edges() == "Bearer " + _token',
+                "\tif text.length() < body_start + content_length:",
+                "\t\treturn false",
+                "\tif not authorized:",
+                '\t\t_write_http_response(peer, 401, _failure("Adopted editor token is invalid.", ["adopted_editor_token_invalid"]))',
+                "\t\treturn true",
+                "\tvar request_text := text.substr(body_start, content_length)",
+                "\tvar request = JSON.parse_string(request_text)",
+                "\tif typeof(request) != TYPE_DICTIONARY:",
+                '\t\t_write_http_response(peer, 400, _failure("Invalid adopted editor request JSON.", ["request_json_invalid"]))',
+                "\t\treturn true",
+                "\t_write_http_response(peer, 200, _handle_adopted_request(request))",
+                "\treturn true",
+                "",
+                "func _handle_adopted_request(request: Dictionary) -> Dictionary:",
+                '\tif int(request.get("protocolVersion", 0)) != GDH_EDITOR_ADOPTION_PROTOCOL_VERSION:',
+                '\t\treturn _failure("Adopted editor protocol version mismatch.", ["adopted_editor_protocol_mismatch"])',
+                '\tvar target_identity = request.get("targetIdentity", {})',
+                '\tif typeof(target_identity) != TYPE_DICTIONARY or str(target_identity.get("identityKey", "")) != str(_target_identity().get("identityKey", "")):',
+                '\t\treturn _failure("Adopted editor target identity mismatch.", ["adopted_editor_identity_mismatch"])',
+                '\tvar operation = request.get("operation", {})',
+                "\tif typeof(operation) != TYPE_DICTIONARY:",
+                '\t\treturn _failure("Missing adopted editor operation payload.", ["operation_missing"])',
+                "\treturn run_editor_operation(operation)",
+                "",
+                "func _write_http_response(peer: StreamPeerTCP, status_code: int, body: Dictionary) -> void:",
+                "\tvar body_text := JSON.stringify(body)",
+                '\tvar status_text := "OK" if status_code == 200 else "Error"',
+                '\tvar response := "HTTP/1.1 %d %s\\r\\nContent-Type: application/json\\r\\nContent-Length: %d\\r\\nConnection: close\\r\\n\\r\\n%s" % [status_code, status_text, body_text.to_utf8_buffer().size(), body_text]',
+                "\tpeer.put_data(response.to_utf8_buffer())",
+                "",
+                "func _write_heartbeat() -> void:",
+                "\tif _port <= 0:",
+                "\t\treturn",
+                "\tvar now := _now_iso()",
+                '\t_write_text_file(_heartbeat_path, now + "\\n")',
+                "\t_write_text_file(_metadata_path, JSON.stringify({",
+                '\t\t"protocolVersion": GDH_EDITOR_ADOPTION_PROTOCOL_VERSION,',
+                '\t\t"bridgeSurfaceVersion": GDH_EDITOR_BRIDGE_VERSION,',
+                '\t\t"targetIdentity": _target_identity(),',
+                '\t\t"pid": OS.get_process_id(),',
+                '\t\t"host": GDH_EDITOR_ADOPTION_HOST,',
+                '\t\t"port": _port,',
+                '\t\t"metadataPath": _metadata_path,',
+                '\t\t"tokenFilePath": _token_file_path,',
+                '\t\t"heartbeatPath": _heartbeat_path,',
+                '\t\t"startedAt": _started_at,',
+                '\t\t"lastHeartbeatAt": now,',
+                '\t}, "\\t") + "\\n")',
+                "",
+                "func _target_identity() -> Dictionary:",
+                '\tvar path_style := "win32" if OS.get_name() == "Windows" else "posix"',
+                "\tvar normalized_target := _normalize_identity_path(_target_root_path, path_style)",
+                "\tvar normalized_project := _normalize_identity_path(_godot_project_root_path, path_style)",
+                "\tvar normalized_state := _normalize_identity_path(_state_root_path, path_style)",
+                "\treturn {",
+                '\t\t"targetRootPath": _target_root_path,',
+                '\t\t"godotProjectRootPath": _godot_project_root_path,',
+                '\t\t"stateRootPath": _state_root_path,',
+                '\t\t"normalizedTargetRootPath": normalized_target,',
+                '\t\t"normalizedGodotProjectRootPath": normalized_project,',
+                '\t\t"normalizedStateRootPath": normalized_state,',
+                '\t\t"pathStyle": path_style,',
+                '\t\t"identityKey": "target=%s|godot=%s|state=%s|style=%s" % [normalized_target, normalized_project, normalized_state, path_style],',
+                "\t}",
+                "",
+                "func _read_or_create_token(token_path: String) -> String:",
+                "\tif FileAccess.file_exists(token_path):",
+                "\t\treturn FileAccess.get_file_as_string(token_path).strip_edges()",
+                "\tvar token := _generate_token()",
+                '\t_write_text_file(token_path, token + "\\n")',
+                "\treturn token",
+                "",
+                "func _generate_token() -> String:",
+                "\tvar crypto := Crypto.new()",
+                "\treturn crypto.generate_random_bytes(32).hex_encode()",
+                "",
+                "func _write_text_file(file_path: String, content: String) -> void:",
+                "\tDirAccess.make_dir_recursive_absolute(file_path.get_base_dir())",
+                "\tvar file := FileAccess.open(file_path, FileAccess.WRITE)",
+                "\tif file:",
+                "\t\tfile.store_string(content)",
+                "\t\tfile.close()",
+                "",
+                "func _find_target_root(project_root: String) -> String:",
+                "\tvar current := _normalize_absolute_path(project_root)",
+                "\tfor _index in range(0, 64):",
+                '\t\tif FileAccess.file_exists(current.path_join(".gdh/project.yaml")):',
+                "\t\t\treturn current",
+                "\t\tvar parent := current.get_base_dir()",
+                '\t\tif parent == current or parent == "":',
+                "\t\t\treturn _normalize_absolute_path(project_root)",
+                "\t\tcurrent = parent",
+                "\treturn _normalize_absolute_path(project_root)",
+                "",
+                "func _normalize_absolute_path(value: String) -> String:",
+                '\tvar normalized := value.simplify_path().trim_suffix("/").trim_suffix("\\\\")',
+                "\treturn normalized",
+                "",
+                "func _normalize_identity_path(value: String, path_style: String) -> String:",
+                "\tvar normalized := _normalize_absolute_path(value)",
+                '\tif path_style == "win32":',
+                '\t\treturn normalized.replace("/", "\\\\").to_lower()',
+                "\treturn normalized",
+                "",
+                "func _now_iso() -> String:",
+                '\treturn Time.get_datetime_string_from_system(true) + "Z"',
+                "",
+                renderEditorOperationCatalogGdscript().trimEnd(),
+            ].join("\n"),
+        },
         {
             id: "bridge-registry-gd",
             relativePath: normalizePath(path.join(runtimeBridge.addonPath, "registry", "bridge_registry.gd")),
@@ -439,18 +698,18 @@ function renderManagedBridgeFiles(runtimeBridge) {
                 "static func list_entries() -> Array[Dictionary]:",
                 "\tvar entries: Array[Dictionary] = CoreEntries.list_entries()",
                 "\tfor project_entries in _load_project_entries():",
-                "\t\tif project_entries != null and project_entries.has_method(\"list_entries\"):",
+                '\t\tif project_entries != null and project_entries.has_method("list_entries"):',
                 "\t\t\tentries.append_array(project_entries.list_entries())",
                 "\treturn entries",
                 "",
                 "static func invoke(runtime: Node, entry_id: String, input: Dictionary) -> Dictionary:",
                 "\tvar core_result := CoreEntries.invoke(runtime, entry_id, input)",
-                "\tif str(core_result.get(\"state\", \"\")) != \"unavailable\":",
+                '\tif str(core_result.get("state", "")) != "unavailable":',
                 "\t\treturn core_result",
                 "\tfor project_entries in _load_project_entries():",
-                "\t\tif project_entries != null and project_entries.has_method(\"invoke\"):",
+                '\t\tif project_entries != null and project_entries.has_method("invoke"):',
                 "\t\t\tvar project_result: Dictionary = project_entries.invoke(runtime, entry_id, input)",
-                "\t\t\tif str(project_result.get(\"state\", \"\")) != \"unavailable\":",
+                '\t\t\tif str(project_result.get("state", "")) != "unavailable":',
                 "\t\t\t\treturn project_result",
                 "\treturn core_result",
                 "",
@@ -477,10 +736,10 @@ function renderManagedBridgeFiles(runtimeBridge) {
                 "\tdirectory.list_dir_begin()",
                 "\tvar file_name := directory.get_next()",
                 "\twhile not file_name.is_empty():",
-                "\t\tvar child_path := \"%s/%s\" % [directory_path, file_name]",
+                '\t\tvar child_path := "%s/%s" % [directory_path, file_name]',
                 "\t\tif directory.current_is_dir():",
                 "\t\t\t_collect_project_entry_paths(child_path, paths)",
-                "\t\telif file_name.ends_with(\".gd\"):",
+                '\t\telif file_name.ends_with(".gd"):',
                 "\t\t\tpaths.append(child_path)",
                 "\t\tfile_name = directory.get_next()",
                 "\tdirectory.list_dir_end()",
@@ -713,7 +972,7 @@ function renderManagedBridgeFiles(runtimeBridge) {
                 '\t\t"input.action.release":',
                 "\t\t\treturn _set_input_action(input, false)",
                 '\t\t"input.action.hold":',
-                "\t\t\treturn _result(\"unavailable\", null, \"input.action.hold is handled by the GDH runtime dispatch path.\")",
+                '\t\t\treturn _result("unavailable", null, "input.action.hold is handled by the GDH runtime dispatch path.")',
                 '\t\t"input.event.send":',
                 "\t\t\treturn _send_input_event(input)",
                 '\t\t"ui.button.press":',
@@ -774,7 +1033,7 @@ function renderManagedBridgeFiles(runtimeBridge) {
                 '\tvar node_path: String = str(input.get("nodePath", ""))',
                 '\tvar signal_name: String = str(input.get("signalName", ""))',
                 "",
-                '\tif node_path.is_empty() or signal_name.is_empty():',
+                "\tif node_path.is_empty() or signal_name.is_empty():",
                 '\t\treturn _result("failed", null, "state.signal_observation.start requires nodePath and signalName.")',
                 "",
                 "\treturn runtime.start_signal_observation(node_path, signal_name)",
@@ -783,7 +1042,7 @@ function renderManagedBridgeFiles(runtimeBridge) {
                 '\tvar node_path: String = str(input.get("nodePath", ""))',
                 '\tvar signal_name: String = str(input.get("signalName", ""))',
                 "",
-                '\tif node_path.is_empty() or signal_name.is_empty():',
+                "\tif node_path.is_empty() or signal_name.is_empty():",
                 '\t\treturn _result("failed", null, "state.signal_observation.get requires nodePath and signalName.")',
                 "",
                 "\treturn runtime.get_signal_observation_snapshot(node_path, signal_name)",
@@ -792,7 +1051,7 @@ function renderManagedBridgeFiles(runtimeBridge) {
                 '\tvar node_path: String = str(input.get("nodePath", ""))',
                 '\tvar property_name: String = str(input.get("property", ""))',
                 "",
-                '\tif node_path.is_empty() or property_name.is_empty():',
+                "\tif node_path.is_empty() or property_name.is_empty():",
                 '\t\treturn _result("failed", null, "state.node_property.get requires nodePath and property.")',
                 "",
                 "\tvar node: Node = runtime.resolve_node_by_path(node_path)",
@@ -1103,7 +1362,7 @@ function renderManagedBridgeFiles(runtimeBridge) {
                 '\tvar requested_class_name: String = str(filters.get("className", ""))',
                 "",
                 "\t_append_node_if_matches(search_root, name_contains, requested_class_name, limit, results)",
-                "\tfor node in search_root.find_children(\"*\", requested_class_name, true, false):",
+                '\tfor node in search_root.find_children("*", requested_class_name, true, false):',
                 "\t\tif results.size() >= limit:",
                 "\t\t\tbreak",
                 "\t\t_append_node_if_matches(node, name_contains, requested_class_name, limit, results)",
@@ -1118,7 +1377,7 @@ function renderManagedBridgeFiles(runtimeBridge) {
                 "",
                 "func start_signal_observation(node_path: String, signal_name: String) -> Dictionary:",
                 '\tvar entry_id := "state.signal_observation.start"',
-                '\tvar observation_key := _build_signal_observation_key(node_path, signal_name)',
+                "\tvar observation_key := _build_signal_observation_key(node_path, signal_name)",
                 "",
                 "\tif _signal_observations.has(observation_key):",
                 "\t\treturn _bridge_ok(_duplicate_signal_observation(_signal_observations[observation_key]))",
@@ -1150,7 +1409,7 @@ function renderManagedBridgeFiles(runtimeBridge) {
                 "",
                 "func get_signal_observation_snapshot(node_path: String, signal_name: String) -> Dictionary:",
                 '\tvar entry_id := "state.signal_observation.get"',
-                '\tvar observation_key := _build_signal_observation_key(node_path, signal_name)',
+                "\tvar observation_key := _build_signal_observation_key(node_path, signal_name)",
                 "",
                 "\tif not _signal_observations.has(observation_key):",
                 '\t\treturn _bridge_result("unavailable", null, "%s has not started observing %s on node %s." % [entry_id, signal_name, node_path])',
@@ -1195,11 +1454,11 @@ function renderManagedBridgeFiles(runtimeBridge) {
                 "\targ2: Variant = null,",
                 "\targ3: Variant = null,",
                 ") -> void:",
-                '\tvar observation_key := _build_signal_observation_key(node_path, signal_name)',
+                "\tvar observation_key := _build_signal_observation_key(node_path, signal_name)",
                 "\tif not _signal_observations.has(observation_key):",
                 "\t\treturn",
                 "",
-                '\tvar snapshot: Dictionary = _signal_observations[observation_key]',
+                "\tvar snapshot: Dictionary = _signal_observations[observation_key]",
                 '\tsnapshot["count"] = int(snapshot.get("count", 0)) + 1',
                 '\tsnapshot["lastObservedAt"] = Time.get_datetime_string_from_system(true, true)',
                 '\tsnapshot["lastPayload"] = _normalize_signal_payload(arg0, arg1, arg2, arg3)',
@@ -1247,9 +1506,9 @@ function renderManagedBridgeFiles(runtimeBridge) {
                 "\tif has_duration == has_physics_frames:",
                 '\t\treturn _bridge_result("failed", null, "input.action.hold requires exactly one of durationMs or physicsFrames.")',
                 "",
-                '\tvar started_at_ms := Time.get_ticks_msec()',
-                '\tvar duration_ms := 0',
-                '\tvar physics_frames := 0',
+                "\tvar started_at_ms := Time.get_ticks_msec()",
+                "\tvar duration_ms := 0",
+                "\tvar physics_frames := 0",
                 '\tvar mode := "durationMs" if has_duration else "physicsFrames"',
                 "",
                 "\tInput.action_press(action)",
@@ -1262,7 +1521,7 @@ function renderManagedBridgeFiles(runtimeBridge) {
                 "\t\t\tawait get_tree().physics_frame",
                 "\tInput.action_release(action)",
                 "",
-                '\tvar finished_at_ms := Time.get_ticks_msec()',
+                "\tvar finished_at_ms := Time.get_ticks_msec()",
                 "\treturn _bridge_ok(",
                 "\t\t{",
                 '\t\t\t"action": action,',
@@ -1377,9 +1636,9 @@ function renderManagedBridgeFiles(runtimeBridge) {
                 "\tfile.store_string(JSON.stringify(payload))",
                 "\tfile.close()",
                 "",
-                "\tif state == \"captured\":",
+                '\tif state == "captured":',
                 "\t\treturn _bridge_ok(payload)",
-                '\treturn _bridge_result(state, payload, summary)',
+                "\treturn _bridge_result(state, payload, summary)",
                 "",
                 "func _accept_pending_connection() -> void:",
                 "\twhile _server.is_connection_available():",
@@ -1505,7 +1764,7 @@ function resolveRuntimeBridgeState(input) {
     if (input.hasDrift) {
         return "drifted";
     }
-    if (!input.autoloadRegistered) {
+    if (!input.autoloadRegistered || !input.editorPluginRegistered) {
         return input.hasPresentManagedFiles ? "drifted" : "needs_install";
     }
     if (input.hasMissing) {
@@ -1517,18 +1776,21 @@ function summarizeRuntimeBridgeStatus(input) {
     if (input.state === "ready") {
         return input.compatibility === "migration_available"
             ? "Runtime bridge files are installed and healthy, but the project config still needs the current runtime_bridge contract migrated."
-            : "Runtime bridge files, autoload registration, and managed manifest all match the current GDH baseline.";
+            : "Runtime and editor bridge files, project.godot registrations, and managed manifest all match the current GDH baseline.";
     }
     if (input.state === "needs_install") {
-        return `Runtime bridge is configured for "${input.runtimeBridge.projectPath}" but the managed addon files or autoload entry have not been installed yet.`;
+        return `GDH bridge is configured for "${input.runtimeBridge.projectPath}" but the managed addon files or project.godot registrations have not been installed yet.`;
     }
     if (input.state === "drifted") {
         if (!input.autoloadRegistered) {
-            return "Runtime bridge addon files are installed, but GDHBridge is not registered yet. Enable the GDH Runtime Bridge plugin in the Godot editor so it can register the autoload itself.";
+            return "GDH bridge addon files are installed, but GDHBridge is not registered as an autoload yet.";
+        }
+        if (!input.editorPluginRegistered) {
+            return "GDH bridge addon files are installed, but the GDH editor plugin is not enabled in project.godot yet.";
         }
         return input.customEntryCount > 0
-            ? "Runtime bridge lifecycle detected drift in GDH-managed files or autoload registration while preserving project-owned bridge entries."
-            : "Runtime bridge lifecycle detected drift in GDH-managed files or autoload registration.";
+            ? "GDH bridge lifecycle detected drift in GDH-managed files or project.godot registrations while preserving project-owned bridge entries."
+            : "GDH bridge lifecycle detected drift in GDH-managed files or project.godot registrations.";
     }
     return "Runtime bridge lifecycle is blocked and cannot inspect the configured target project safely.";
 }
@@ -1548,13 +1810,79 @@ function hasAutoloadRegistration(content, runtimeBridge) {
     const normalizedValue = value.replace(/^"\*/, "").replace(/^"/, "").replace(/"$/, "");
     return normalizedValue === runtimeBridge.autoloadScriptPath;
 }
+function hasEditorPluginRegistration(content, runtimeBridge) {
+    return readEditorPluginRegistrations(content).includes(editorPluginResourcePath(runtimeBridge));
+}
+function addEditorPluginRegistration(content, runtimeBridge) {
+    const pluginPath = editorPluginResourcePath(runtimeBridge);
+    const lines = content.split(/\r?\n/);
+    const section = findSection(lines, "editor_plugins");
+    const registrations = readEditorPluginRegistrations(content);
+    const nextRegistrations = registrations.includes(pluginPath)
+        ? registrations
+        : [...registrations, pluginPath].sort();
+    const entryLine = renderEditorPluginsEnabledLine(nextRegistrations);
+    if (section === null) {
+        const trailingBlank = lines.length > 0 && lines[lines.length - 1] === "" ? 1 : 0;
+        const baseLines = trailingBlank ? lines.slice(0, -1) : lines;
+        const needsSeparator = baseLines.length > 0 && baseLines[baseLines.length - 1]?.trim() !== "";
+        return `${[
+            ...baseLines,
+            ...(needsSeparator ? [""] : []),
+            "[editor_plugins]",
+            "",
+            entryLine,
+        ].join("\n")}\n`;
+    }
+    const replacementIndex = lines.findIndex((line, index) => index > section.start && index < section.end && line.trim().startsWith("enabled="));
+    const nextLines = replacementIndex >= 0
+        ? lines.map((line, index) => (index === replacementIndex ? entryLine : line))
+        : [...lines.slice(0, section.end), entryLine, ...lines.slice(section.end)];
+    return `${nextLines.join("\n").replace(/\n+$/, "\n")}`;
+}
+function removeEditorPluginRegistration(content, runtimeBridge) {
+    const pluginPath = editorPluginResourcePath(runtimeBridge);
+    const lines = content.split(/\r?\n/);
+    const section = findSection(lines, "editor_plugins");
+    if (section === null)
+        return `${lines.join("\n").replace(/\n+$/, "\n")}`;
+    const registrations = readEditorPluginRegistrations(content).filter((entry) => entry !== pluginPath);
+    const entryLine = renderEditorPluginsEnabledLine(registrations);
+    const replacementIndex = lines.findIndex((line, index) => index > section.start && index < section.end && line.trim().startsWith("enabled="));
+    if (replacementIndex < 0)
+        return `${lines.join("\n").replace(/\n+$/, "\n")}`;
+    const nextLines = lines.map((line, index) => (index === replacementIndex ? entryLine : line));
+    return `${nextLines.join("\n").replace(/\n+$/, "\n")}`;
+}
+function readEditorPluginRegistrations(content) {
+    const lines = content.split(/\r?\n/);
+    const section = findSection(lines, "editor_plugins");
+    if (section === null)
+        return [];
+    for (let index = section.start + 1; index < section.end; index += 1) {
+        const line = lines[index]?.trim() ?? "";
+        if (line.startsWith("enabled=")) {
+            const entries = [...line.matchAll(/"([^"]+)"/gu)].map((match) => match[1] ?? "");
+            return entries.filter((entry) => entry.length > 0);
+        }
+    }
+    return [];
+}
+function renderEditorPluginsEnabledLine(entries) {
+    return `enabled=PackedStringArray(${entries.map((entry) => JSON.stringify(entry)).join(", ")})`;
+}
+function editorPluginResourcePath(runtimeBridge) {
+    return `res://${normalizePath(path.join(runtimeBridge.addonPath, "plugin.cfg"))}`;
+}
 function removeAutoloadRegistration(content, runtimeBridge) {
     const lines = content.split(/\r?\n/);
     const section = findSection(lines, "autoload");
     if (section === null) {
         return `${lines.join("\n").replace(/\n+$/, "\n")}`;
     }
-    const nextLines = lines.filter((_, index) => !(index > section.start && index < section.end && lines[index]?.startsWith(`${runtimeBridge.autoloadName}=`)));
+    const nextLines = lines.filter((_, index) => !(index > section.start &&
+        index < section.end &&
+        lines[index]?.startsWith(`${runtimeBridge.autoloadName}=`)));
     return `${nextLines.join("\n").replace(/\n+$/, "\n")}`;
 }
 /**
@@ -1585,12 +1913,7 @@ function addAutoloadRegistration(content, runtimeBridge) {
         // section if the previous content does not already end with one.
         const baseLines = trailingBlank ? lines.slice(0, -1) : lines;
         const needsSeparator = baseLines.length > 0 && baseLines[baseLines.length - 1]?.trim() !== "";
-        const sectionLines = [
-            ...(needsSeparator ? [""] : []),
-            "[autoload]",
-            "",
-            entryLine,
-        ];
+        const sectionLines = [...(needsSeparator ? [""] : []), "[autoload]", "", entryLine];
         return `${[...baseLines, ...sectionLines].join("\n")}\n`;
     }
     // Section exists. Replace any existing entry for this autoloadName, or