@forbocai/core 0.6.3 → 0.6.4

package/dist/index.mjs

@@ -18,341 +18,443 @@ import { createSlice, createAsyncThunk } from "@reduxjs/toolkit";
 
 // src/apiSlice.ts
 import { createApi, fetchBaseQuery } from "@reduxjs/toolkit/query";
-var sdkApi = createApi({
-  reducerPath: "forbocApi",
-  baseQuery: fetchBaseQuery({
-    baseUrl: "/",
-    prepareHeaders: (headers, { getState }) => {
-      return headers;
-    }
+
+// src/api/endpoints/arweave.ts
+var buildArweaveEndpoints = (builder) => ({
+  postArweaveUpload: builder.mutation({
+    queryFn: async (instruction) => {
+      const maxRetries = instruction.maxRetries ?? 3;
+      const headers = {
+        "Content-Type": instruction.auiContentType || "application/json"
+      };
+      const walletToken = typeof globalThis !== "undefined" ? globalThis.process?.env?.ARWEAVE_WALLET_JWK ?? null : null;
+      const authToken = instruction.auiAuthHeader ?? (walletToken ? `Bearer ${walletToken}` : null);
+      if (authToken) headers.Authorization = authToken;
+      const attempt = async (n) => {
+        try {
+          const controller = new AbortController();
+          const timeout = setTimeout(() => controller.abort(), 6e4);
+          const response = await fetch(instruction.auiEndpoint, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(instruction.auiPayload),
+            signal: controller.signal
+          });
+          clearTimeout(timeout);
+          const responseBody = await response.json().catch(() => null);
+          const txId = responseBody?.id ?? `ar_tx_sdk_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+          const success = response.status >= 200 && response.status < 300;
+          return !success && n + 1 < maxRetries ? new Promise((resolve) => setTimeout(() => resolve(attempt(n + 1)), 250 * 2 ** n)) : {
+            data: {
+              aurTxId: txId,
+              aurStatus: response.status,
+              aurSuccess: success,
+              aurError: success ? null : `upload_failed_status_${response.status}`
+            }
+          };
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          return n + 1 < maxRetries ? new Promise((resolve) => setTimeout(() => resolve(attempt(n + 1)), 250 * 2 ** n)) : {
+            data: {
+              aurTxId: `ar_tx_failed_${Date.now()}`,
+              aurStatus: 0,
+              aurSuccess: false,
+              aurError: `upload_request_failed:${message}`
+            }
+          };
+        }
+      };
+      return attempt(0);
+    },
+    invalidatesTags: ["Soul"]
   }),
-  tagTypes: ["NPC", "Memory", "Cortex", "Ghost", "Soul", "Bridge", "Rule"],
-  endpoints: (builder) => ({
-    // Cortex Endpoints
-    getCortexModels: builder.query({
-      query: ({ apiUrl, apiKey }) => ({
-        url: `${apiUrl}/cortex/models`,
-        method: "GET",
-        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {}
-      }),
-      providesTags: ["Cortex"],
-      transformResponse: (response) => response || []
+  postArweaveDownload: builder.mutation({
+    queryFn: async (instruction) => {
+      try {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 6e4);
+        const response = await fetch(instruction.adiGatewayUrl, { method: "GET", signal: controller.signal });
+        clearTimeout(timeout);
+        return response.status < 200 || response.status >= 300 ? { data: { adrBody: null, adrStatus: response.status, adrSuccess: false, adrError: `download_failed_status_${response.status}` } } : response.json().then((body) => ({ data: { adrBody: body, adrStatus: response.status, adrSuccess: true, adrError: null } })).catch(() => ({ data: { adrBody: null, adrStatus: response.status, adrSuccess: false, adrError: "download_invalid_json" } }));
+      } catch (error) {
+        return {
+          data: {
+            adrBody: null,
+            adrStatus: 0,
+            adrSuccess: false,
+            adrError: error instanceof Error ? error.message : String(error)
+          }
+        };
+      }
+    },
+    invalidatesTags: ["Soul"]
+  })
+});
+
+// src/api/endpoints/builder.ts
+var authHeaders = (apiKey) => apiKey ? { Authorization: `Bearer ${apiKey}` } : {};
+
+// src/api/endpoints/cortex.ts
+var buildCortexEndpoints = (builder) => ({
+  getCortexModels: builder.query({
+    query: ({ apiUrl, apiKey }) => ({
+      url: `${apiUrl}/cortex/models`,
+      method: "GET",
+      headers: authHeaders(apiKey)
     }),
-    postCortexInit: builder.mutation({
-      query: ({ request, apiUrl, apiKey }) => ({
-        url: `${apiUrl}/cortex/init`,
-        method: "POST",
-        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {},
-        body: request
-      }),
-      invalidatesTags: ["Cortex"],
-      transformResponse: (response) => response
+    providesTags: ["Cortex"],
+    transformResponse: (response) => response || []
+  }),
+  postCortexInit: builder.mutation({
+    query: ({ request, apiUrl, apiKey }) => ({
+      url: `${apiUrl}/cortex/init`,
+      method: "POST",
+      headers: authHeaders(apiKey),
+      body: request
     }),
-    // NPC Endpoints
-    /**
-     * User Story: As the SDK protocol loop, I need a single process endpoint
-     * that returns one atomic instruction per turn while echoing full tape state.
-     * ᚹ one hop in, one hop out, like passing a lit shard through vacuum.
-     */
-    postNpcProcess: builder.mutation({
-      query: ({ npcId, request, apiUrl, apiKey }) => ({
-        url: `${apiUrl}/npcs/${npcId}/process`,
-        method: "POST",
-        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {},
-        body: request
-      }),
-      invalidatesTags: (result, error, { npcId }) => [{ type: "NPC", id: npcId }],
-      transformResponse: (response) => response
+    invalidatesTags: ["Cortex"],
+    transformResponse: (response) => response
+  }),
+  postCortexComplete: builder.mutation({
+    query: ({ cortexId, prompt, options, apiUrl, apiKey }) => ({
+      url: `${apiUrl}/cortex/${cortexId}/complete`,
+      method: "POST",
+      headers: authHeaders(apiKey),
+      body: { prompt, ...options }
     }),
-    postDirective: builder.mutation({
-      query: ({ npcId, request, apiUrl, apiKey }) => ({
-        url: `${apiUrl}/npcs/${npcId}/directive`,
-        method: "POST",
-        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {},
-        body: request
-      }),
-      invalidatesTags: ["NPC"],
-      transformResponse: (response) => response
+    invalidatesTags: ["Cortex"],
+    transformResponse: (response) => response
+  })
+});
+
+// src/api/endpoints/ghost.ts
+var ghostTag = (sessionId) => [{ type: "Ghost", id: sessionId }];
+var buildGhostEndpoints = (builder) => ({
+  postGhostRun: builder.mutation({
+    query: ({ request, apiUrl, apiKey }) => ({
+      url: `${apiUrl}/ghost/run`,
+      method: "POST",
+      headers: authHeaders(apiKey),
+      body: request
     }),
-    postContext: builder.mutation({
-      query: ({ npcId, request, apiUrl, apiKey }) => ({
-        url: `${apiUrl}/npcs/${npcId}/context`,
-        method: "POST",
-        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {},
-        body: request
-      }),
-      invalidatesTags: (result, error, { npcId }) => [{ type: "NPC", id: npcId }],
-      transformResponse: (response) => response
+    invalidatesTags: ["Ghost"],
+    transformResponse: (response) => response
+  }),
+  getGhostStatus: builder.query({
+    query: ({ sessionId, apiUrl, apiKey }) => ({
+      url: `${apiUrl}/ghost/${sessionId}/status`,
+      method: "GET",
+      headers: authHeaders(apiKey)
     }),
-    postVerdict: builder.mutation({
-      query: ({ npcId, request, apiUrl, apiKey }) => ({
-        url: `${apiUrl}/npcs/${npcId}/verdict`,
-        method: "POST",
-        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {},
-        body: request
-      }),
-      invalidatesTags: (result, error, { npcId }) => [{ type: "NPC", id: npcId }],
-      transformResponse: (response) => {
-        const action = response.action ? {
-          type: response.action.gaType || response.action.type,
-          reason: response.action.actionReason || response.action.reason,
-          target: response.action.actionTarget || response.action.target,
-          signature: response.action.signature
-        } : void 0;
-        return {
-          ...response,
-          action
-        };
-      }
+    providesTags: (_result, _error, { sessionId }) => ghostTag(sessionId),
+    transformResponse: (response) => response
+  }),
+  getGhostResults: builder.query({
+    query: ({ sessionId, apiUrl, apiKey }) => ({
+      url: `${apiUrl}/ghost/${sessionId}/results`,
+      method: "GET",
+      headers: authHeaders(apiKey)
     }),
-    postMemoryStore: builder.mutation({
-      query: ({ npcId, request, apiUrl, apiKey }) => ({
-        url: `${apiUrl}/npcs/${npcId}/memory`,
-        method: "POST",
-        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {},
-        body: request
-      }),
-      invalidatesTags: (result, error, { npcId }) => [{ type: "Memory", id: npcId }],
-      transformResponse: (response) => response
+    providesTags: (_result, _error, { sessionId }) => ghostTag(sessionId),
+    transformResponse: (response) => response
+  }),
+  postGhostStop: builder.mutation({
+    query: ({ sessionId, apiUrl, apiKey }) => ({
+      url: `${apiUrl}/ghost/${sessionId}/stop`,
+      method: "POST",
+      headers: authHeaders(apiKey)
     }),
-    getMemoryList: builder.query({
-      query: ({ npcId, apiUrl, apiKey }) => ({
-        url: `${apiUrl}/npcs/${npcId}/memory`,
-        method: "GET",
-        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {}
-      }),
-      providesTags: (result, error, { npcId }) => [{ type: "Memory", id: npcId }],
-      transformResponse: (response) => response || []
+    invalidatesTags: (_result, _error, { sessionId }) => ghostTag(sessionId),
+    transformResponse: (response) => ({
+      stopped: response?.stopStatus === "stopped",
+      stopStatus: response?.stopStatus,
+      stopSessionId: response?.stopSessionId
+    })
+  }),
+  getGhostHistory: builder.query({
+    query: ({ limit, apiUrl, apiKey }) => ({
+      url: `${apiUrl}/ghost/history?limit=${limit}`,
+      method: "GET",
+      headers: authHeaders(apiKey)
     }),
-    postMemoryRecall: builder.mutation({
-      query: ({ npcId, request, apiUrl, apiKey }) => ({
-        url: `${apiUrl}/npcs/${npcId}/memory/recall`,
-        method: "POST",
-        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {},
-        body: request
-      }),
-      invalidatesTags: (result, error, { npcId }) => [{ type: "Memory", id: npcId }],
-      transformResponse: (response) => response || []
+    providesTags: ["Ghost"],
+    transformResponse: (response) => response
+  })
+});
+
+// src/api/endpoints/npc.ts
+var memoryTag = (npcId) => [{ type: "Memory", id: npcId }];
+var npcTag = (npcId) => [{ type: "NPC", id: npcId }];
+var buildNpcEndpoints = (builder) => ({
+  postNpcProcess: builder.mutation({
+    query: ({ npcId, request, apiUrl, apiKey }) => ({
+      url: `${apiUrl}/npcs/${npcId}/process`,
+      method: "POST",
+      headers: authHeaders(apiKey),
+      body: request
     }),
-    deleteMemoryClear: builder.mutation({
-      query: ({ npcId, apiUrl, apiKey }) => ({
-        url: `${apiUrl}/npcs/${npcId}/memory/clear`,
-        method: "DELETE",
-        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {}
-      }),
-      invalidatesTags: (result, error, { npcId }) => [{ type: "Memory", id: npcId }],
-      transformResponse: (response) => response
+    invalidatesTags: (_result, _error, { npcId }) => npcTag(npcId),
+    transformResponse: (response) => response
+  }),
+  postDirective: builder.mutation({
+    query: ({ npcId, request, apiUrl, apiKey }) => ({
+      url: `${apiUrl}/npcs/${npcId}/directive`,
+      method: "POST",
+      headers: authHeaders(apiKey),
+      body: request
     }),
-    // Ghost Endpoints
-    postGhostRun: builder.mutation({
-      query: ({ request, apiUrl, apiKey }) => ({
-        url: `${apiUrl}/ghost/run`,
-        method: "POST",
-        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {},
-        body: request
-      }),
-      invalidatesTags: ["Ghost"],
-      transformResponse: (response) => response
+    invalidatesTags: ["NPC"],
+    transformResponse: (response) => response
+  }),
+  postContext: builder.mutation({
+    query: ({ npcId, request, apiUrl, apiKey }) => ({
+      url: `${apiUrl}/npcs/${npcId}/context`,
+      method: "POST",
+      headers: authHeaders(apiKey),
+      body: request
     }),
-    getGhostStatus: builder.query({
-      query: ({ sessionId, apiUrl, apiKey }) => ({
-        url: `${apiUrl}/ghost/${sessionId}/status`,
-        method: "GET",
-        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {}
-      }),
-      providesTags: (result, error, { sessionId }) => [{ type: "Ghost", id: sessionId }],
-      transformResponse: (response) => response
+    invalidatesTags: (_result, _error, { npcId }) => npcTag(npcId),
+    transformResponse: (response) => response
+  }),
+  postVerdict: builder.mutation({
+    query: ({ npcId, request, apiUrl, apiKey }) => ({
+      url: `${apiUrl}/npcs/${npcId}/verdict`,
+      method: "POST",
+      headers: authHeaders(apiKey),
+      body: request
     }),
-    getGhostResults: builder.query({
-      query: ({ sessionId, apiUrl, apiKey }) => ({
-        url: `${apiUrl}/ghost/${sessionId}/results`,
-        method: "GET",
-        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {}
-      }),
-      providesTags: (result, error, { sessionId }) => [{ type: "Ghost", id: sessionId }],
-      transformResponse: (response) => response
+    invalidatesTags: (_result, _error, { npcId }) => npcTag(npcId),
+    transformResponse: (response) => {
+      const action = response.action ? {
+        type: response.action.gaType || response.action.type,
+        reason: response.action.actionReason || response.action.reason,
+        target: response.action.actionTarget || response.action.target,
+        signature: response.action.signature
+      } : void 0;
+      return {
+        ...response,
+        action
+      };
+    }
+  }),
+  postMemoryStore: builder.mutation({
+    query: ({ npcId, request, apiUrl, apiKey }) => ({
+      url: `${apiUrl}/npcs/${npcId}/memory`,
+      method: "POST",
+      headers: authHeaders(apiKey),
+      body: request
     }),
-    postGhostStop: builder.mutation({
-      query: ({ sessionId, apiUrl, apiKey }) => ({
-        url: `${apiUrl}/ghost/${sessionId}/stop`,
-        method: "POST",
-        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {}
-      }),
-      invalidatesTags: (result, error, { sessionId }) => [{ type: "Ghost", id: sessionId }],
-      transformResponse: (response) => ({
-        stopped: response?.stopStatus === "stopped",
-        stopStatus: response?.stopStatus,
-        stopSessionId: response?.stopSessionId
-      })
+    invalidatesTags: (_result, _error, { npcId }) => memoryTag(npcId),
+    transformResponse: (response) => response
+  }),
+  getMemoryList: builder.query({
+    query: ({ npcId, apiUrl, apiKey }) => ({
+      url: `${apiUrl}/npcs/${npcId}/memory`,
+      method: "GET",
+      headers: authHeaders(apiKey)
     }),
-    getGhostHistory: builder.query({
-      query: ({ limit, apiUrl, apiKey }) => ({
-        url: `${apiUrl}/ghost/history?limit=${limit}`,
-        method: "GET",
-        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {}
-      }),
-      providesTags: ["Ghost"],
-      transformResponse: (response) => response
+    providesTags: (_result, _error, { npcId }) => memoryTag(npcId),
+    transformResponse: (response) => response || []
+  }),
+  postMemoryRecall: builder.mutation({
+    query: ({ npcId, request, apiUrl, apiKey }) => ({
+      url: `${apiUrl}/npcs/${npcId}/memory/recall`,
+      method: "POST",
+      headers: authHeaders(apiKey),
+      body: request
     }),
-    // Soul Endpoints
-    postSoulExport: builder.mutation({
-      query: ({ npcId, request, apiUrl, apiKey }) => ({
-        url: `${apiUrl}/npcs/${npcId}/soul/export`,
-        method: "POST",
-        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {},
-        body: request
-      }),
-      invalidatesTags: ["Soul"],
-      transformResponse: (response) => response
+    invalidatesTags: (_result, _error, { npcId }) => memoryTag(npcId),
+    transformResponse: (response) => response || []
+  }),
+  deleteMemoryClear: builder.mutation({
+    query: ({ npcId, apiUrl, apiKey }) => ({
+      url: `${apiUrl}/npcs/${npcId}/memory/clear`,
+      method: "DELETE",
+      headers: authHeaders(apiKey)
     }),
-    postSoulExportConfirm: builder.mutation({
-      query: ({ npcId, request, apiUrl, apiKey }) => ({
-        url: `${apiUrl}/npcs/${npcId}/soul/confirm`,
-        method: "POST",
-        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {},
-        body: request
-      }),
-      invalidatesTags: ["Soul"],
-      transformResponse: (response) => response
+    invalidatesTags: (_result, _error, { npcId }) => memoryTag(npcId),
+    transformResponse: (response) => response
+  })
+});
+
+// src/api/endpoints/rules.ts
+var buildBridgeAndRuleEndpoints = (builder) => ({
+  postBridgeValidate: builder.mutation({
+    query: ({ request, npcId, apiUrl, apiKey }) => ({
+      url: npcId ? `${apiUrl}/bridge/validate/${npcId}` : `${apiUrl}/bridge/validate`,
+      method: "POST",
+      headers: authHeaders(apiKey),
+      body: request
     }),
-    getSoulImport: builder.query({
-      query: ({ txId, apiUrl, apiKey }) => ({
-        url: `${apiUrl}/souls/${txId}`,
-        method: "GET",
-        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {}
-      }),
-      providesTags: (result, error, { txId }) => [{ type: "Soul", id: txId }],
-      transformResponse: (response) => response
+    invalidatesTags: ["Bridge"],
+    transformResponse: (response) => response.brResult || response
+  }),
+  getBridgeRules: builder.query({
+    query: ({ apiUrl, apiKey }) => ({
+      url: `${apiUrl}/bridge/rules`,
+      method: "GET",
+      headers: authHeaders(apiKey)
     }),
-    getSouls: builder.query({
-      query: ({ limit, apiUrl, apiKey }) => ({
-        url: `${apiUrl}/souls?limit=${limit}`,
-        method: "GET",
-        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {}
-      }),
-      providesTags: ["Soul"],
-      transformResponse: (response) => response
+    providesTags: ["Bridge"],
+    transformResponse: (response) => response
+  }),
+  postBridgePreset: builder.mutation({
+    query: ({ presetName, apiUrl, apiKey }) => ({
+      url: `${apiUrl}/rules/presets/${presetName}`,
+      method: "POST",
+      headers: authHeaders(apiKey)
     }),
-    // Bridge Endpoints
-    postBridgeValidate: builder.mutation({
-      query: ({ request, npcId, apiUrl, apiKey }) => ({
-        url: npcId ? `${apiUrl}/bridge/validate/${npcId}` : `${apiUrl}/bridge/validate`,
-        method: "POST",
-        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {},
-        body: request
-      }),
-      invalidatesTags: ["Bridge"],
-      transformResponse: (response) => response.brResult || response
+    invalidatesTags: ["Bridge"],
+    transformResponse: (response) => response
+  }),
+  getRulesets: builder.query({
+    query: ({ apiUrl, apiKey }) => ({
+      url: `${apiUrl}/rules`,
+      method: "GET",
+      headers: authHeaders(apiKey)
     }),
-    getBridgeRules: builder.query({
-      query: ({ apiUrl, apiKey }) => ({
-        url: `${apiUrl}/bridge/rules`,
-        method: "GET",
-        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {}
-      }),
-      providesTags: ["Bridge"],
-      transformResponse: (response) => response
+    providesTags: ["Rule"],
+    transformResponse: (response) => response || []
+  }),
+  getRulePresets: builder.query({
+    query: ({ apiUrl, apiKey }) => ({
+      url: `${apiUrl}/rules/presets`,
+      method: "GET",
+      headers: authHeaders(apiKey)
     }),
-    postBridgePreset: builder.mutation({
-      query: ({ presetName, apiUrl, apiKey }) => ({
-        url: `${apiUrl}/rules/presets/${presetName}`,
-        method: "POST",
-        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {}
-      }),
-      invalidatesTags: ["Bridge"],
-      transformResponse: (response) => response
+    providesTags: ["Rule"],
+    transformResponse: (response) => response || []
+  }),
+  postRuleRegister: builder.mutation({
+    query: ({ request, apiUrl, apiKey }) => ({
+      url: `${apiUrl}/rules`,
+      method: "POST",
+      headers: authHeaders(apiKey),
+      body: request
     }),
-    // Rules Endpoints
-    getRulesets: builder.query({
-      query: ({ apiUrl, apiKey }) => ({
-        url: `${apiUrl}/rules`,
-        method: "GET",
-        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {}
-      }),
-      providesTags: ["Rule"],
-      transformResponse: (response) => response || []
+    invalidatesTags: ["Rule"],
+    transformResponse: (response) => response
+  }),
+  deleteRule: builder.mutation({
+    query: ({ rulesetId, apiUrl, apiKey }) => ({
+      url: `${apiUrl}/rules/${rulesetId}`,
+      method: "DELETE",
+      headers: authHeaders(apiKey)
     }),
-    getRulePresets: builder.query({
-      query: ({ apiUrl, apiKey }) => ({
-        url: `${apiUrl}/rules/presets`,
-        method: "GET",
-        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {}
-      }),
-      providesTags: ["Rule"],
-      transformResponse: (response) => response || []
+    invalidatesTags: ["Rule"],
+    transformResponse: (_response) => ({ deleted: true })
+  })
+});
+
+// src/api/endpoints/soul.ts
+var soulTag = (id) => [{ type: "Soul", id }];
+var buildSoulEndpoints = (builder) => ({
+  postSoulExport: builder.mutation({
+    query: ({ npcId, request, apiUrl, apiKey }) => ({
+      url: `${apiUrl}/npcs/${npcId}/soul/export`,
+      method: "POST",
+      headers: authHeaders(apiKey),
+      body: request
     }),
-    postRuleRegister: builder.mutation({
-      query: ({ request, apiUrl, apiKey }) => ({
-        url: `${apiUrl}/rules`,
-        method: "POST",
-        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {},
-        body: request
-      }),
-      invalidatesTags: ["Rule"],
-      transformResponse: (response) => response
+    invalidatesTags: ["Soul"],
+    transformResponse: (response) => response
+  }),
+  postSoulExportConfirm: builder.mutation({
+    query: ({ npcId, request, apiUrl, apiKey }) => ({
+      url: `${apiUrl}/npcs/${npcId}/soul/confirm`,
+      method: "POST",
+      headers: authHeaders(apiKey),
+      body: request
     }),
-    deleteRule: builder.mutation({
-      query: ({ rulesetId, apiUrl, apiKey }) => ({
-        url: `${apiUrl}/rules/${rulesetId}`,
-        method: "DELETE",
-        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {}
-      }),
-      invalidatesTags: ["Rule"],
-      transformResponse: (_response) => ({ deleted: true })
+    invalidatesTags: ["Soul"],
+    transformResponse: (response) => response
+  }),
+  getSoulImport: builder.query({
+    query: ({ txId, apiUrl, apiKey }) => ({
+      url: `${apiUrl}/souls/${txId}`,
+      method: "GET",
+      headers: authHeaders(apiKey)
     }),
-    // Additional Soul/NPC Endpoints
-    postSoulVerify: builder.mutation({
-      query: ({ txId, apiUrl, apiKey }) => ({
-        url: `${apiUrl}/souls/${txId}/verify`,
-        method: "POST",
-        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {}
-      }),
-      invalidatesTags: ["Soul"],
-      transformResponse: (response) => ({
-        valid: response.verifyValid ?? response.valid ?? false,
-        reason: response.verifyReason ?? response.reason
-      })
+    providesTags: (_result, _error, { txId }) => soulTag(txId),
+    transformResponse: (response) => response
+  }),
+  getSouls: builder.query({
+    query: ({ limit, apiUrl, apiKey }) => ({
+      url: `${apiUrl}/souls?limit=${limit}`,
+      method: "GET",
+      headers: authHeaders(apiKey)
     }),
-    postNpcImport: builder.mutation({
-      query: ({ request, apiUrl, apiKey }) => ({
-        url: `${apiUrl}/npcs/import`,
-        method: "POST",
-        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {},
-        body: request
-      }),
-      invalidatesTags: ["NPC"],
-      transformResponse: (response) => response
+    providesTags: ["Soul"],
+    transformResponse: (response) => response
+  }),
+  postSoulVerify: builder.mutation({
+    query: ({ txId, apiUrl, apiKey }) => ({
+      url: `${apiUrl}/souls/${txId}/verify`,
+      method: "POST",
+      headers: authHeaders(apiKey)
     }),
-    postNpcImportConfirm: builder.mutation({
-      query: ({ request, apiUrl, apiKey }) => ({
-        url: `${apiUrl}/npcs/import/confirm`,
-        method: "POST",
-        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {},
-        body: request
-      }),
-      invalidatesTags: ["NPC"],
-      transformResponse: (response) => response
+    invalidatesTags: ["Soul"],
+    transformResponse: (response) => ({
+      valid: response.verifyValid ?? response.valid ?? false,
+      reason: response.verifyReason ?? response.reason
+    })
+  }),
+  postNpcImport: builder.mutation({
+    query: ({ request, apiUrl, apiKey }) => ({
+      url: `${apiUrl}/npcs/import`,
+      method: "POST",
+      headers: authHeaders(apiKey),
+      body: request
     }),
-    // Cortex Remote Endpoint
-    postCortexComplete: builder.mutation({
-      query: ({ cortexId, prompt, options, apiUrl, apiKey }) => ({
-        url: `${apiUrl}/cortex/${cortexId}/complete`,
-        method: "POST",
-        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {},
-        body: { prompt, ...options }
-      }),
-      invalidatesTags: ["Cortex"],
-      transformResponse: (response) => response
+    invalidatesTags: ["NPC"],
+    transformResponse: (response) => response
+  }),
+  postNpcImportConfirm: builder.mutation({
+    query: ({ request, apiUrl, apiKey }) => ({
+      url: `${apiUrl}/npcs/import/confirm`,
+      method: "POST",
+      headers: authHeaders(apiKey),
+      body: request
     }),
-    // System Endpoints
-    getApiStatus: builder.query({
-      query: ({ apiUrl }) => ({ url: `${apiUrl}/status`, method: "GET" }),
-      transformResponse: (response) => response
-    })
+    invalidatesTags: ["NPC"],
+    transformResponse: (response) => response
+  })
+});
+
+// src/api/endpoints/system.ts
+var buildSystemEndpoints = (builder) => ({
+  getApiStatus: builder.query({
+    query: ({ apiUrl }) => ({ url: `${apiUrl}/status`, method: "GET" }),
+    providesTags: ["NPC"],
+    transformResponse: (response) => response
+  })
+});
+
+// src/apiSlice.ts
+var api = createApi({
+  reducerPath: "api",
+  baseQuery: fetchBaseQuery({
+    baseUrl: "/",
+    prepareHeaders: (headers, { getState }) => {
+      return headers;
+    }
+  }),
+  tagTypes: ["NPC", "Memory", "Cortex", "Ghost", "Soul", "Bridge", "Rule"],
+  endpoints: (builder) => ({
+    ...buildCortexEndpoints(builder),
+    ...buildNpcEndpoints(builder),
+    ...buildGhostEndpoints(builder),
+    ...buildSoulEndpoints(builder),
+    ...buildBridgeAndRuleEndpoints(builder),
+    ...buildArweaveEndpoints(builder),
+    ...buildSystemEndpoints(builder)
   })
 });
 
 // src/errors.ts
+var DEFAULT_API_URL = "http://localhost:8080";
+var PRODUCTION_API_URL = "https://api.forboc.ai";
+var resolveApiUrl = (apiUrl) => apiUrl || DEFAULT_API_URL;
 var extractThunkErrorMessage = (error, fallback) => {
   if (typeof error === "string") return error;
   if (error && typeof error === "object") {
@@ -384,9 +486,9 @@ var validateBridgeThunk = createAsyncThunk(
   "bridge/validate",
   async ({ action, context, npcId, apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
     try {
-      const url = apiUrl || "https://api.forboc.ai";
+      const url = resolveApiUrl(apiUrl);
       requireApiKeyGuidance(url, apiKey);
-      const data = await dispatch2(sdkApi.endpoints.postBridgeValidate.initiate({
+      const data = await dispatch2(api.endpoints.postBridgeValidate.initiate({
         request: { action, context },
         npcId,
         apiUrl: url,
@@ -402,9 +504,9 @@ var loadBridgePresetThunk = createAsyncThunk(
   "bridge/loadPreset",
   async ({ presetName, apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
     try {
-      const url = apiUrl || "https://api.forboc.ai";
+      const url = resolveApiUrl(apiUrl);
       requireApiKeyGuidance(url, apiKey);
-      return await dispatch2(sdkApi.endpoints.postBridgePreset.initiate({ presetName, apiUrl: url, apiKey })).unwrap();
+      return await dispatch2(api.endpoints.postBridgePreset.initiate({ presetName, apiUrl: url, apiKey })).unwrap();
     } catch (error) {
       return rejectWithValue(extractThunkErrorMessage(error, "Failed to load preset"));
     }
@@ -414,9 +516,9 @@ var getBridgeRulesThunk = createAsyncThunk(
   "bridge/rules",
   async ({ apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
     try {
-      const url = apiUrl || "https://api.forboc.ai";
+      const url = resolveApiUrl(apiUrl);
       requireApiKeyGuidance(url, apiKey);
-      return await dispatch2(sdkApi.endpoints.getBridgeRules.initiate({ apiUrl: url, apiKey })).unwrap();
+      return await dispatch2(api.endpoints.getBridgeRules.initiate({ apiUrl: url, apiKey })).unwrap();
     } catch (error) {
       return rejectWithValue(extractThunkErrorMessage(error, "Failed to list bridge rules"));
     }
@@ -426,9 +528,9 @@ var listRulesetsThunk = createAsyncThunk(
   "bridge/listRulesets",
   async ({ apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
     try {
-      const url = apiUrl || "https://api.forboc.ai";
+      const url = resolveApiUrl(apiUrl);
       requireApiKeyGuidance(url, apiKey);
-      return await dispatch2(sdkApi.endpoints.getRulesets.initiate({ apiUrl: url, apiKey })).unwrap();
+      return await dispatch2(api.endpoints.getRulesets.initiate({ apiUrl: url, apiKey })).unwrap();
     } catch (error) {
       return rejectWithValue(extractThunkErrorMessage(error, "Failed to list rulesets"));
     }
@@ -438,9 +540,9 @@ var listRulePresetsThunk = createAsyncThunk(
   "bridge/listRulePresets",
   async ({ apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
     try {
-      const url = apiUrl || "https://api.forboc.ai";
+      const url = resolveApiUrl(apiUrl);
       requireApiKeyGuidance(url, apiKey);
-      return await dispatch2(sdkApi.endpoints.getRulePresets.initiate({ apiUrl: url, apiKey })).unwrap();
+      return await dispatch2(api.endpoints.getRulePresets.initiate({ apiUrl: url, apiKey })).unwrap();
     } catch (error) {
       return rejectWithValue(extractThunkErrorMessage(error, "Failed to list rule presets"));
     }
@@ -450,9 +552,9 @@ var registerRulesetThunk = createAsyncThunk(
   "bridge/registerRuleset",
   async ({ ruleset, apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
     try {
-      const url = apiUrl || "https://api.forboc.ai";
+      const url = resolveApiUrl(apiUrl);
       requireApiKeyGuidance(url, apiKey);
-      return await dispatch2(sdkApi.endpoints.postRuleRegister.initiate({ request: ruleset, apiUrl: url, apiKey })).unwrap();
+      return await dispatch2(api.endpoints.postRuleRegister.initiate({ request: ruleset, apiUrl: url, apiKey })).unwrap();
     } catch (error) {
       return rejectWithValue(extractThunkErrorMessage(error, "Failed to register ruleset"));
     }
@@ -462,9 +564,9 @@ var deleteRulesetThunk = createAsyncThunk(
   "bridge/deleteRuleset",
   async ({ rulesetId, apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
     try {
-      const url = apiUrl || "https://api.forboc.ai";
+      const url = resolveApiUrl(apiUrl);
       requireApiKeyGuidance(url, apiKey);
-      return await dispatch2(sdkApi.endpoints.deleteRule.initiate({ rulesetId, apiUrl: url, apiKey })).unwrap();
+      return await dispatch2(api.endpoints.deleteRule.initiate({ rulesetId, apiUrl: url, apiKey })).unwrap();
     } catch (error) {
       return rejectWithValue(extractThunkErrorMessage(error, "Failed to delete ruleset"));
     }
@@ -516,121 +618,82 @@ var bridgeSlice_default = bridgeSlice.reducer;
 // src/soulSlice.ts
 import { createSlice as createSlice2, createAsyncThunk as createAsyncThunk2 } from "@reduxjs/toolkit";
 
-// src/handlers/arweave.ts
-var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-var getLocalWalletToken = () => {
-  const maybeEnv = globalThis.process?.env;
-  return maybeEnv?.ARWEAVE_WALLET_JWK ?? null;
-};
-var withTimeout = async (promiseFactory, timeoutMs = 6e4) => {
-  const controller = new AbortController();
-  const timeout = setTimeout(() => controller.abort(), timeoutMs);
-  try {
-    return await promiseFactory(controller.signal);
-  } finally {
-    clearTimeout(timeout);
-  }
-};
-async function handler_ArweaveUpload(instruction, maxRetries = 3) {
-  const headers = {
-    "Content-Type": instruction.auiContentType || "application/json"
-  };
-  const authToken = instruction.auiAuthHeader ?? (getLocalWalletToken() ? `Bearer ${getLocalWalletToken()}` : null);
-  if (authToken) {
-    headers.Authorization = authToken;
-  }
-  let attempt = 0;
-  while (attempt < maxRetries) {
-    attempt += 1;
-    try {
-      const response = await withTimeout(
-        (signal) => fetch(instruction.auiEndpoint, {
-          method: "POST",
-          headers,
-          body: JSON.stringify(instruction.auiPayload),
-          signal
-        })
-      );
-      let responseBody = null;
-      try {
-        responseBody = await response.json();
-      } catch {
-        responseBody = null;
-      }
-      const txId = responseBody?.id ?? `ar_tx_sdk_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-      const success = response.status >= 200 && response.status < 300;
-      if (!success && attempt < maxRetries) {
-        await sleep(250 * 2 ** (attempt - 1));
-        continue;
-      }
-      return {
-        aurTxId: txId,
-        aurStatus: response.status,
-        aurSuccess: success,
-        aurError: success ? null : `upload_failed_status_${response.status}`
-      };
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      if (attempt < maxRetries) {
-        await sleep(250 * 2 ** (attempt - 1));
-        continue;
-      }
-      return {
-        aurTxId: `ar_tx_failed_${Date.now()}`,
-        aurStatus: 0,
-        aurSuccess: false,
-        aurError: `upload_request_failed:${message}`
-      };
-    }
+// src/functional_core.ts
+var just = (value) => ({
+  _tag: "Just",
+  map: (f) => just(f(value)),
+  chain: (f) => f(value),
+  getOrElse: (_defaultValue) => value,
+  match: (cases) => cases.just(value)
+});
+var nothing = () => ({
+  _tag: "Nothing",
+  map: (_f) => nothing(),
+  chain: (_f) => nothing(),
+  getOrElse: (defaultValue) => defaultValue,
+  match: (cases) => cases.nothing()
+});
+var fmap = (m, f) => m.map(f);
+var mbind = (m, f) => m.chain(f);
+var orElse = (m, defaultValue) => m.getOrElse(defaultValue);
+var match = (m, onJust, onNothing) => m.match({ just: onJust, nothing: onNothing });
+var isJust = (m) => m._tag === "Just";
+var isNothing = (m) => m._tag === "Nothing";
+var fromNullable = (value) => value != null ? just(value) : nothing();
+var requireJust = (m, errorMsg) => m.match({
+  just: (v) => v,
+  nothing: () => {
+    throw new Error(errorMsg);
   }
-  return {
-    aurTxId: `ar_tx_failed_${Date.now()}`,
-    aurStatus: 0,
-    aurSuccess: false,
-    aurError: "upload_retry_exhausted"
+});
+var left = (error) => ({
+  _tag: "Left",
+  map: (_f) => left(error),
+  chain: (_f) => left(error),
+  getOrElse: (defaultValue) => defaultValue,
+  match: (cases) => cases.left(error)
+});
+var right = (value) => ({
+  _tag: "Right",
+  map: (f) => right(f(value)),
+  chain: (f) => f(value),
+  getOrElse: (_defaultValue) => value,
+  match: (cases) => cases.right(value)
+});
+var efmap = (e, f) => e.map(f);
+var ebind = (e, f) => e.chain(f);
+var ematch = (e, onLeft, onRight) => e.match({ left: onLeft, right: onRight });
+var isLeft = (e) => e._tag === "Left";
+var isRight = (e) => e._tag === "Right";
+function compose(...fns) {
+  return (...args) => {
+    const last = fns[fns.length - 1];
+    const rest = fns.slice(0, -1);
+    return rest.reduceRight((acc, fn) => fn(acc), last(...args));
   };
 }
-async function handler_ArweaveDownload(instruction) {
-  try {
-    const response = await withTimeout(
-      (signal) => fetch(instruction.adiGatewayUrl, {
-        method: "GET",
-        signal
-      })
-    );
-    if (response.status < 200 || response.status >= 300) {
-      return {
-        adrBody: null,
-        adrStatus: response.status,
-        adrSuccess: false,
-        adrError: `download_failed_status_${response.status}`
-      };
-    }
-    try {
-      const body = await response.json();
-      return {
-        adrBody: body,
-        adrStatus: response.status,
-        adrSuccess: true,
-        adrError: null
-      };
-    } catch {
-      return {
-        adrBody: null,
-        adrStatus: response.status,
-        adrSuccess: false,
-        adrError: "download_invalid_json"
-      };
-    }
-  } catch (error) {
-    return {
-      adrBody: null,
-      adrStatus: 0,
-      adrSuccess: false,
-      adrError: error instanceof Error ? error.message : String(error)
-    };
-  }
+function curry(fn) {
+  const arity = fn.length;
+  const curried = (...args) => args.length >= arity ? fn(...args) : (...moreArgs) => curried(...args, ...moreArgs);
+  return curried;
 }
+var createDispatcher = (entries) => {
+  const table = new Map(entries);
+  return {
+    dispatch: (key, ...args) => {
+      const handler = table.get(key);
+      return handler ? just(handler(...args)) : nothing();
+    },
+    has: (key) => table.has(key),
+    keys: () => [...table.keys()]
+  };
+};
+var _ = /* @__PURE__ */ Symbol.for("forbocai_wildcard");
+var testCase = (value, predicate, handler) => predicate === _ ? just(handler(value)) : typeof predicate === "function" ? predicate(value) ? just(handler(value)) : nothing() : predicate === value ? just(handler(value)) : nothing();
+var multiMatch = (value, cases) => cases.length === 0 ? nothing() : testCase(value, cases[0][0], cases[0][1]).match({
+  just: (v) => just(v),
+  nothing: () => multiMatch(value, cases.slice(1))
+});
 
 // src/soulSlice.ts
 var initialState2 = {
@@ -647,24 +710,25 @@ var remoteExportSoulThunk = createAsyncThunk2(
     try {
       const state = getState().npc;
       const npcId = argNpcId || state.activeNpcId;
-      const npc = state.entities[npcId];
-      if (!npc) throw new Error(`NPC ${npcId} not found`);
-      const url = apiUrl || "https://api.forboc.ai";
+      const npc = requireJust(fromNullable(state.entities[npcId]), `NPC ${npcId} not found`);
+      const url = resolveApiUrl(apiUrl);
       requireApiKeyGuidance(url, apiKey);
       const phase1 = await dispatch2(
-        sdkApi.endpoints.postSoulExport.initiate({
+        api.endpoints.postSoulExport.initiate({
           npcId,
           request: { npcIdRef: npcId, persona: npc.persona || "NPC", npcState: npc.state },
           apiUrl: url,
           apiKey
         })
       ).unwrap();
-      const uploadResult = await handler_ArweaveUpload({
-        ...phase1.se1Instruction,
-        auiAuthHeader: phase1.se1Instruction.auiAuthHeader ?? null
-      });
+      const uploadResult = await dispatch2(
+        api.endpoints.postArweaveUpload.initiate({
+          ...phase1.se1Instruction,
+          auiAuthHeader: phase1.se1Instruction.auiAuthHeader ?? null
+        })
+      ).unwrap();
       const final = await dispatch2(
-        sdkApi.endpoints.postSoulExportConfirm.initiate({
+        api.endpoints.postSoulExportConfirm.initiate({
           npcId,
           request: {
             secUploadResult: uploadResult,
@@ -689,14 +753,16 @@ var importSoulFromArweaveThunk = createAsyncThunk2(
   "soul/import",
   async ({ txId, apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
     try {
-      const url = apiUrl || "https://api.forboc.ai";
+      const url = resolveApiUrl(apiUrl);
       requireApiKeyGuidance(url, apiKey);
       const phase1 = await dispatch2(
-        sdkApi.endpoints.postNpcImport.initiate({ request: { txIdRef: txId }, apiUrl: url, apiKey })
+        api.endpoints.postNpcImport.initiate({ request: { txIdRef: txId }, apiUrl: url, apiKey })
+      ).unwrap();
+      const downloadResult = await dispatch2(
+        api.endpoints.postArweaveDownload.initiate(phase1.si1Instruction)
       ).unwrap();
-      const downloadResult = await handler_ArweaveDownload(phase1.si1Instruction);
       const npc = await dispatch2(
-        sdkApi.endpoints.postNpcImportConfirm.initiate({
+        api.endpoints.postNpcImportConfirm.initiate({
           request: {
             sicTxId: txId,
             sicDownloadResult: downloadResult
@@ -722,9 +788,9 @@ var getSoulListThunk = createAsyncThunk2(
   "soul/list",
   async ({ limit = 50, apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
     try {
-      const url = apiUrl || "https://api.forboc.ai";
+      const url = resolveApiUrl(apiUrl);
       requireApiKeyGuidance(url, apiKey);
-      const data = await dispatch2(sdkApi.endpoints.getSouls.initiate({ limit, apiUrl: url, apiKey })).unwrap();
+      const data = await dispatch2(api.endpoints.getSouls.initiate({ limit, apiUrl: url, apiKey })).unwrap();
       return data.souls || [];
     } catch (error) {
       return rejectWithValue(extractThunkErrorMessage(error, "Failed to list souls"));
@@ -735,9 +801,9 @@ var verifySoulThunk = createAsyncThunk2(
   "soul/verify",
   async ({ txId, apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
     try {
-      const url = apiUrl || "https://api.forboc.ai";
+      const url = resolveApiUrl(apiUrl);
       requireApiKeyGuidance(url, apiKey);
-      return await dispatch2(sdkApi.endpoints.postSoulVerify.initiate({ txId, apiUrl: url, apiKey })).unwrap();
+      return await dispatch2(api.endpoints.postSoulVerify.initiate({ txId, apiUrl: url, apiKey })).unwrap();
     } catch (error) {
       return rejectWithValue(extractThunkErrorMessage(error, "Soul verify failed"));
     }
@@ -747,18 +813,20 @@ var importNpcFromSoulThunk = createAsyncThunk2(
   "soul/importNpc",
   async ({ txId, apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
     try {
-      const url = apiUrl || "https://api.forboc.ai";
+      const url = resolveApiUrl(apiUrl);
       requireApiKeyGuidance(url, apiKey);
       const phase1 = await dispatch2(
-        sdkApi.endpoints.postNpcImport.initiate({
+        api.endpoints.postNpcImport.initiate({
           request: { txIdRef: txId },
           apiUrl: url,
           apiKey
         })
       ).unwrap();
-      const downloadResult = await handler_ArweaveDownload(phase1.si1Instruction);
+      const downloadResult = await dispatch2(
+        api.endpoints.postArweaveDownload.initiate(phase1.si1Instruction)
+      ).unwrap();
       return await dispatch2(
-        sdkApi.endpoints.postNpcImportConfirm.initiate({
+        api.endpoints.postNpcImportConfirm.initiate({
           request: { sicTxId: txId, sicDownloadResult: downloadResult },
           apiUrl: url,
           apiKey
@@ -823,9 +891,9 @@ var startGhostThunk = createAsyncThunk3(
   "ghost/start",
   async (config, { dispatch: dispatch2, rejectWithValue }) => {
     try {
-      const apiUrl = config.apiUrl || "https://api.forboc.ai";
+      const apiUrl = resolveApiUrl(config.apiUrl);
       requireApiKeyGuidance(apiUrl, config.apiKey);
-      const data = await dispatch2(sdkApi.endpoints.postGhostRun.initiate({
+      const data = await dispatch2(api.endpoints.postGhostRun.initiate({
         request: { testSuite: config.testSuite, duration: config.duration ?? 300 },
         apiUrl,
         apiKey: config.apiKey
@@ -844,11 +912,10 @@ var getGhostStatusThunk = createAsyncThunk3(
   async ({ sessionId, apiUrl, apiKey }, { dispatch: dispatch2, getState, rejectWithValue }) => {
     try {
       const state = getState().ghost;
-      const targetSession = sessionId || state.activeSessionId;
-      if (!targetSession) throw new Error("No active Ghost session");
-      const url = apiUrl || "https://api.forboc.ai";
+      const targetSession = requireJust(fromNullable(sessionId || state.activeSessionId), "No active Ghost session");
+      const url = resolveApiUrl(apiUrl);
       requireApiKeyGuidance(url, apiKey);
-      const data = await dispatch2(sdkApi.endpoints.getGhostStatus.initiate({ sessionId: targetSession, apiUrl: url, apiKey })).unwrap();
+      const data = await dispatch2(api.endpoints.getGhostStatus.initiate({ sessionId: targetSession, apiUrl: url, apiKey })).unwrap();
       return {
         sessionId: data.ghostSessionId,
         status: data.ghostStatus,
@@ -867,11 +934,10 @@ var getGhostResultsThunk = createAsyncThunk3(
   async ({ sessionId, apiUrl, apiKey }, { dispatch: dispatch2, getState, rejectWithValue }) => {
     try {
       const state = getState().ghost;
-      const targetSession = sessionId || state.activeSessionId;
-      if (!targetSession) throw new Error("No active Ghost session");
-      const url = apiUrl || "https://api.forboc.ai";
+      const targetSession = requireJust(fromNullable(sessionId || state.activeSessionId), "No active Ghost session");
+      const url = resolveApiUrl(apiUrl);
       requireApiKeyGuidance(url, apiKey);
-      const data = await dispatch2(sdkApi.endpoints.getGhostResults.initiate({ sessionId: targetSession, apiUrl: url, apiKey })).unwrap();
+      const data = await dispatch2(api.endpoints.getGhostResults.initiate({ sessionId: targetSession, apiUrl: url, apiKey })).unwrap();
       return {
         sessionId: data.resultsSessionId,
         totalTests: data.resultsTotalTests,
@@ -899,11 +965,10 @@ var stopGhostThunk = createAsyncThunk3(
   async ({ sessionId, apiUrl, apiKey }, { dispatch: dispatch2, getState, rejectWithValue }) => {
     try {
       const state = getState().ghost;
-      const targetSession = sessionId || state.activeSessionId;
-      if (!targetSession) throw new Error("No active Ghost session");
-      const url = apiUrl || "https://api.forboc.ai";
+      const targetSession = requireJust(fromNullable(sessionId || state.activeSessionId), "No active Ghost session");
+      const url = resolveApiUrl(apiUrl);
       requireApiKeyGuidance(url, apiKey);
-      const data = await dispatch2(sdkApi.endpoints.postGhostStop.initiate({ sessionId: targetSession, apiUrl: url, apiKey })).unwrap();
+      const data = await dispatch2(api.endpoints.postGhostStop.initiate({ sessionId: targetSession, apiUrl: url, apiKey })).unwrap();
       return {
         stopped: data.stopped,
         status: data.stopStatus,
@@ -918,9 +983,9 @@ var getGhostHistoryThunk = createAsyncThunk3(
   "ghost/history",
   async ({ limit = 10, apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
     try {
-      const url = apiUrl || "https://api.forboc.ai";
+      const url = resolveApiUrl(apiUrl);
       requireApiKeyGuidance(url, apiKey);
-      const data = await dispatch2(sdkApi.endpoints.getGhostHistory.initiate({ limit, apiUrl: url, apiKey })).unwrap();
+      const data = await dispatch2(api.endpoints.getGhostHistory.initiate({ limit, apiUrl: url, apiKey })).unwrap();
       return (data.sessions || []).map((s) => ({
         sessionId: s.sessionId,
         testSuite: s.testSuite,
@@ -979,8 +1044,8 @@ var ghostSlice = createSlice3({
 var { clearGhostSession } = ghostSlice.actions;
 var ghostSlice_default = ghostSlice.reducer;
 
-// src/utils/sdkVersion.ts
-var SDK_VERSION = "0.6.1";
+// src/utils/version.ts
+var VERSION = "0.6.4";
 
 // src/utils/generateNPCId.ts
 var generateNPCId = () => `ag_${Date.now().toString(36)}`;
@@ -1148,9 +1213,9 @@ var initRemoteCortexThunk = createAsyncThunk4(
   "cortex/initRemote",
   async ({ model = "api-integrated", authKey, apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
     try {
-      const url = apiUrl || "https://api.forboc.ai";
+      const url = resolveApiUrl(apiUrl);
       requireApiKeyGuidance(url, apiKey);
-      const data = await dispatch2(sdkApi.endpoints.postCortexInit.initiate({
+      const data = await dispatch2(api.endpoints.postCortexInit.initiate({
         request: { requestedModel: model, authKey },
         apiUrl: url,
         apiKey
@@ -1170,9 +1235,9 @@ var listCortexModelsThunk = createAsyncThunk4(
   "cortex/listModels",
   async ({ apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
     try {
-      const url = apiUrl || "https://api.forboc.ai";
+      const url = resolveApiUrl(apiUrl);
       requireApiKeyGuidance(url, apiKey);
-      return await dispatch2(sdkApi.endpoints.getCortexModels.initiate({ apiUrl: url, apiKey })).unwrap();
+      return await dispatch2(api.endpoints.getCortexModels.initiate({ apiUrl: url, apiKey })).unwrap();
     } catch (error) {
       return rejectWithValue(extractThunkErrorMessage(error, "Failed to list cortex models"));
     }
@@ -1183,7 +1248,7 @@ var completeRemoteThunk = createAsyncThunk4(
   async ({ cortexId, prompt, options, apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
     try {
       requireApiKeyGuidance(apiUrl, apiKey);
-      const data = await dispatch2(sdkApi.endpoints.postCortexComplete.initiate({
+      const data = await dispatch2(api.endpoints.postCortexComplete.initiate({
         cortexId,
         prompt,
         options,
@@ -1384,8 +1449,8 @@ var directiveSlice_default = directiveSlice.reducer;
 
 // src/listeners.ts
 import { createListenerMiddleware } from "@reduxjs/toolkit";
-var sdkListenerMiddleware = createListenerMiddleware();
-var startAppListening = sdkListenerMiddleware.startListening.withTypes();
+var listenerMiddleware = createListenerMiddleware();
+var startAppListening = listenerMiddleware.startListening.withTypes();
 startAppListening({
   actionCreator: removeNPC,
   effect: async (action, listenerApi) => {
@@ -1402,11 +1467,38 @@ startAppListening({
   }
 });
 
+// src/runtimeRegistry.ts
+var createRuntimeRegistry = () => {
+  const _store = {};
+  return {
+    get: (ns, key) => _store[ns]?.[key],
+    set: (ns, key, value) => {
+      if (!_store[ns]) _store[ns] = {};
+      _store[ns][key] = value;
+    },
+    delete: (ns, key) => {
+      if (_store[ns]) {
+        delete _store[ns][key];
+        return true;
+      }
+      return false;
+    },
+    has: (ns, key) => !!(_store[ns]?.[key] !== void 0),
+    clear: (ns) => {
+      if (ns) {
+        delete _store[ns];
+      } else {
+        Object.keys(_store).forEach((k) => delete _store[k]);
+      }
+    }
+  };
+};
+
 // src/store.ts
-var createSDKStore = (extraReducers = {}) => {
+var createRuntimeStore = (extraReducers = {}, registry = createRuntimeRegistry()) => {
   return configureStore({
     reducer: {
-      [sdkApi.reducerPath]: sdkApi.reducer,
+      [api.reducerPath]: api.reducer,
       npc: npcSlice_default,
       cortex: cortexSlice_default,
       memory: memorySlice_default,
@@ -1417,46 +1509,120 @@ var createSDKStore = (extraReducers = {}) => {
       ...extraReducers
     },
     middleware: (getDefaultMiddleware) => getDefaultMiddleware({
-      serializableCheck: false
-      // Allow non-serializable for engine refs in specific slices if needed, though we try to keep them external
-    }).prepend(sdkListenerMiddleware.middleware).concat(sdkApi.middleware)
+      thunk: { extraArgument: registry },
+      serializableCheck: {
+        ignoredActionPaths: [
+          "meta.arg.cortex",
+          "meta.arg.memory",
+          "meta.arg.onProgress",
+          "meta.baseQueryMeta.request",
+          "meta.baseQueryMeta.response"
+        ]
+      }
+    }).prepend(listenerMiddleware.middleware).concat(api.middleware)
   });
 };
-var store = createSDKStore();
+var store = createRuntimeStore();
 var dispatch = store.dispatch;
 
 // src/thunks.ts
 import { createAsyncThunk as createAsyncThunk5 } from "@reduxjs/toolkit";
-var extractThunkErrorMessage2 = (e) => {
-  if (typeof e === "string") return e;
-  if (e?.data?.message) return String(e.data.message);
-  if (e?.error) return String(e.error);
-  if (e?.message) return String(e.message);
-  return "Protocol processing failed";
+
+// src/protocolHandlers.ts
+var persistMemoryRecursively = async (memory, instructions, index = 0) => !memory || index >= instructions.length ? void 0 : memory.store(instructions[index].text, instructions[index].type, instructions[index].importance).then(() => persistMemoryRecursively(memory, instructions, index + 1));
+var handleIdentifyActor = (ctx, nextTape, turn) => ctx.recurse(nextTape, {
+  type: "IdentifyActorResult",
+  actor: { npcId: ctx.npcId, persona: ctx.persona, data: nextTape.npcState }
+}, turn + 1);
+var handleQueryVector = async (ctx, instruction, nextTape, turn) => {
+  ctx.dispatch(directiveReceived({
+    id: ctx.directiveId,
+    response: { memoryRecall: { query: instruction.query, limit: instruction.limit, threshold: instruction.threshold } }
+  }));
+  return ctx.memory ? ctx.memory.recall(instruction.query, instruction.limit, instruction.threshold).then((recalled) => ctx.recurse(nextTape, {
+    type: "QueryVectorResult",
+    memories: recalled.map((m) => ({ text: m.text, type: m.type, importance: m.importance, similarity: m.similarity }))
+  }, turn + 1)) : ctx.rejectWithValue("API requested memory recall, but no memory engine is configured");
+};
+var handleExecuteInference = async (ctx, instruction, nextTape, turn) => {
+  ctx.dispatch(contextComposed({ id: ctx.directiveId, prompt: instruction.prompt, constraints: instruction.constraints }));
+  const generatedText = await ctx.cortex.complete(instruction.prompt, {
+    maxTokens: instruction.constraints.maxTokens,
+    temperature: instruction.constraints.temperature,
+    stop: instruction.constraints.stop
+  });
+  return ctx.recurse(nextTape, {
+    type: "ExecuteInferenceResult",
+    generatedOutput: generatedText
+  }, turn + 1);
 };
+var handleFinalize = async (ctx, finalize) => {
+  ctx.dispatch(verdictValidated({
+    id: ctx.directiveId,
+    verdict: {
+      valid: finalize.valid,
+      signature: finalize.signature,
+      memoryStore: finalize.memoryStore,
+      stateDelta: finalize.stateTransform,
+      action: finalize.action,
+      dialogue: finalize.dialogue
+    }
+  }));
+  return finalize.valid ? applyFinalizeSuccess(ctx, finalize) : applyFinalizeBlocked(ctx, finalize);
+};
+var applyFinalizeBlocked = (ctx, finalize) => {
+  ctx.dispatch(blockAction({ id: ctx.npcId, reason: finalize.dialogue || "Validation Failed" }));
+  return { dialogue: finalize.dialogue, action: finalize.action, thought: finalize.dialogue };
+};
+var applyFinalizeSuccess = async (ctx, finalize) => {
+  if (finalize.memoryStore?.length && !ctx.memory) {
+    return ctx.rejectWithValue("API returned memoryStore instructions, but no memory engine is configured");
+  }
+  await persistMemoryRecursively(ctx.memory, finalize.memoryStore || []);
+  if (finalize.stateTransform) {
+    ctx.dispatch(updateNPCState({ id: ctx.npcId, delta: finalize.stateTransform }));
+  }
+  ctx.dispatch(setLastAction({ id: ctx.npcId, action: finalize.action }));
+  ctx.dispatch(addToHistory({ id: ctx.npcId, role: "user", content: ctx.text }));
+  ctx.dispatch(addToHistory({ id: ctx.npcId, role: "assistant", content: finalize.dialogue }));
+  return { dialogue: finalize.dialogue, action: finalize.action, thought: finalize.dialogue };
+};
+var dispatchInstruction = (ctx, instruction, nextTape, turn) => {
+  const handlers = {
+    "IdentifyActor": () => handleIdentifyActor(ctx, nextTape, turn),
+    "QueryVector": () => handleQueryVector(ctx, instruction, nextTape, turn),
+    "ExecuteInference": () => handleExecuteInference(ctx, instruction, nextTape, turn),
+    "Finalize": () => handleFinalize(ctx, instruction)
+  };
+  const handler = handlers[instruction.type];
+  return handler ? handler() : Promise.resolve(ctx.rejectWithValue("API returned unknown instruction type"));
+};
+
+// src/thunks.ts
+var extractThunkErrorMessage2 = (e) => multiMatch(e, [
+  [(e2) => typeof e2 === "string", (e2) => e2],
+  [(e2) => !!e2?.data?.message, (e2) => String(e2.data.message)],
+  [(e2) => !!e2?.error, (e2) => String(e2.error)],
+  [(e2) => !!e2?.message, (e2) => String(e2.message)],
+  [_, () => "Protocol processing failed"]
+]).getOrElse("Protocol processing failed");
+var safeDispatch = async (promise) => promise.then((v) => right(v)).catch((e) => left(extractThunkErrorMessage2(e)));
 var processNPC = createAsyncThunk5(
   "npc/process",
   async ({ npcId: argNpcId, text, context = {}, apiUrl, apiKey, memory, cortex, persona: argPersona }, { getState, dispatch: dispatch2, rejectWithValue }) => {
     const stateNpcId = selectActiveNpcId(getState());
     const activeNpc = selectActiveNPC(getState());
-    const npcId = argNpcId || stateNpcId;
-    const persona = argPersona || activeNpc?.persona;
     const currentState = activeNpc?.state || {};
-    if (!npcId) {
-      return rejectWithValue("No npcId provided and no active NPC selected");
-    }
-    if (!persona) {
-      return rejectWithValue("No persona provided and no active NPC persona available");
-    }
-    if (!cortex) {
-      return rejectWithValue("No local cortex provided. SDK remote cortex fallback is disabled.");
-    }
-    if (argNpcId && argNpcId !== stateNpcId) {
-      dispatch2(setNPCInfo({ id: argNpcId, persona }));
-    }
-    const directiveId = `${npcId}:${Date.now()}`;
-    dispatch2(directiveRunStarted({ id: directiveId, npcId, observation: text }));
+    let directiveId;
     try {
+      const npcId = requireJust(fromNullable(argNpcId || stateNpcId), "No npcId provided and no active NPC selected");
+      const persona = requireJust(fromNullable(argPersona || activeNpc?.persona), "No persona provided and no active NPC persona available");
+      requireJust(fromNullable(cortex), "No local cortex provided. SDK remote cortex fallback is disabled.");
+      if (argNpcId && argNpcId !== stateNpcId) {
+        dispatch2(setNPCInfo({ id: argNpcId, persona }));
+      }
+      directiveId = `${npcId}:${Date.now()}`;
+      dispatch2(directiveRunStarted({ id: directiveId, npcId, observation: text }));
       const initialTape = {
         observation: text,
         context,
@@ -1465,104 +1631,33 @@ var processNPC = createAsyncThunk5(
         memories: [],
         vectorQueried: false
       };
-      const maxTurns = 12;
-      const persistMemoryInstructionsRecursively = async (instructions, index = 0) => {
-        if (!memory || index >= instructions.length) {
-          return;
-        }
-        const inst = instructions[index];
-        await memory.store(inst.text, inst.type, inst.importance);
-        await persistMemoryInstructionsRecursively(instructions, index + 1);
-      };
-      const runProtocolRecursively = async (tape, lastResult, turn) => {
-        if (turn >= maxTurns) {
-          return rejectWithValue(`Protocol loop exceeded max turns (${maxTurns})`);
+      const runProtocol = async (tape, lastResult, turn) => {
+        if (turn >= 12) {
+          return rejectWithValue("Protocol loop exceeded max turns (12)");
         }
         const request = { tape, lastResult };
         const processResult = await dispatch2(
-          sdkApi.endpoints.postNpcProcess.initiate({ npcId, request, apiUrl, apiKey })
+          api.endpoints.postNpcProcess.initiate({ npcId, request, apiUrl, apiKey })
         ).unwrap();
-        const nextTape = processResult.tape;
-        const instruction = processResult.instruction;
-        if (instruction.type === "IdentifyActor") {
-          return runProtocolRecursively(nextTape, {
-            type: "IdentifyActorResult",
-            actor: {
-              npcId,
-              persona,
-              data: nextTape.npcState
-            }
-          }, turn + 1);
-        }
-        if (instruction.type === "QueryVector") {
-          dispatch2(directiveReceived({
-            id: directiveId,
-            response: { memoryRecall: { query: instruction.query, limit: instruction.limit, threshold: instruction.threshold } }
-          }));
-          if (!memory) {
-            return rejectWithValue("API requested memory recall, but no memory engine is configured");
-          }
-          const recalled = await memory.recall(instruction.query, instruction.limit, instruction.threshold);
-          return runProtocolRecursively(nextTape, {
-            type: "QueryVectorResult",
-            memories: recalled.map((m) => ({ text: m.text, type: m.type, importance: m.importance, similarity: m.similarity }))
-          }, turn + 1);
-        }
-        if (instruction.type === "ExecuteInference") {
-          dispatch2(contextComposed({ id: directiveId, prompt: instruction.prompt, constraints: instruction.constraints }));
-          const generatedText = await cortex.complete(instruction.prompt, {
-            maxTokens: instruction.constraints.maxTokens,
-            temperature: instruction.constraints.temperature,
-            stop: instruction.constraints.stop
-          });
-          return runProtocolRecursively(nextTape, {
-            type: "ExecuteInferenceResult",
-            generatedOutput: generatedText
-          }, turn + 1);
-        }
-        if (instruction.type === "Finalize") {
-          const finalize = instruction;
-          dispatch2(verdictValidated({
-            id: directiveId,
-            verdict: {
-              valid: finalize.valid,
-              signature: finalize.signature,
-              memoryStore: finalize.memoryStore,
-              stateDelta: finalize.stateTransform,
-              action: finalize.action,
-              dialogue: finalize.dialogue
-            }
-          }));
-          if (!finalize.valid) {
-            dispatch2(blockAction({ id: npcId, reason: finalize.dialogue || "Validation Failed" }));
-            return {
-              dialogue: finalize.dialogue,
-              action: finalize.action,
-              thought: finalize.dialogue
-            };
-          }
-          if (finalize.memoryStore?.length && !memory) {
-            return rejectWithValue("API returned memoryStore instructions, but no memory engine is configured");
-          }
-          await persistMemoryInstructionsRecursively(finalize.memoryStore || []);
-          if (finalize.stateTransform) {
-            dispatch2(updateNPCState({ id: npcId, delta: finalize.stateTransform }));
-          }
-          dispatch2(setLastAction({ id: npcId, action: finalize.action }));
-          dispatch2(addToHistory({ id: npcId, role: "user", content: text }));
-          dispatch2(addToHistory({ id: npcId, role: "assistant", content: finalize.dialogue }));
-          return {
-            dialogue: finalize.dialogue,
-            action: finalize.action,
-            thought: finalize.dialogue
-          };
-        }
-        return rejectWithValue("API returned unknown instruction type");
+        const ctx = {
+          npcId,
+          persona,
+          text,
+          directiveId,
+          memory,
+          cortex,
+          dispatch: dispatch2,
+          rejectWithValue,
+          recurse: runProtocol
+        };
+        return dispatchInstruction(ctx, processResult.instruction, processResult.tape, turn);
       };
-      return runProtocolRecursively(initialTape, void 0, 0);
+      return runProtocol(initialTape, void 0, 0);
     } catch (e) {
       const message = extractThunkErrorMessage2(e);
-      dispatch2(directiveRunFailed({ id: directiveId, error: String(message) }));
+      if (directiveId) {
+        dispatch2(directiveRunFailed({ id: directiveId, error: String(message) }));
+      }
       return rejectWithValue(String(message));
     }
   }
@@ -1572,8 +1667,7 @@ var localExportSoulThunk = createAsyncThunk5(
   async ({ id, memory }, { getState }) => {
     const state = getState().npc;
     const npcId = id || state.activeNpcId;
-    const npc = state.entities[npcId];
-    if (!npc) throw new Error(`NPC ${npcId} not found`);
+    const npc = requireJust(fromNullable(state.entities[npcId]), `NPC ${npcId} not found`);
     const memories = memory ? await memory.export() : [];
     return exportToSoul(npcId, "NPC", npc.persona, npc.state, memories);
   }
@@ -1581,76 +1675,98 @@ var localExportSoulThunk = createAsyncThunk5(
 var checkApiStatusThunk = createAsyncThunk5(
   "system/checkApiStatus",
   async ({ apiUrl }, { dispatch: dispatch2, rejectWithValue }) => {
-    try {
-      return await dispatch2(sdkApi.endpoints.getApiStatus.initiate({ apiUrl })).unwrap();
-    } catch (e) {
-      return rejectWithValue(e?.message || "Connection failed");
-    }
+    const result = await safeDispatch(dispatch2(api.endpoints.getApiStatus.initiate({ apiUrl })).unwrap());
+    return result.match({
+      left: (e) => rejectWithValue(e),
+      right: (v) => v
+    });
   }
 );
 var listMemoryRemoteThunk = createAsyncThunk5(
   "memory/listRemote",
   async ({ npcId, apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
-    try {
-      const data = await dispatch2(sdkApi.endpoints.getMemoryList.initiate({ npcId, apiUrl, apiKey })).unwrap();
-      return data || [];
-    } catch (e) {
-      return rejectWithValue(e?.message || "Failed to list memories");
-    }
+    const result = await safeDispatch(dispatch2(api.endpoints.getMemoryList.initiate({ npcId, apiUrl, apiKey })).unwrap());
+    return result.match({
+      left: (e) => rejectWithValue(e),
+      right: (v) => v || []
+    });
   }
 );
 var recallMemoryRemoteThunk = createAsyncThunk5(
   "memory/recallRemote",
   async ({ npcId, query, apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
-    try {
-      const data = await dispatch2(
-        sdkApi.endpoints.postMemoryRecall.initiate({
-          npcId,
-          request: { query },
-          apiUrl,
-          apiKey
-        })
-      ).unwrap();
-      return data || [];
-    } catch (e) {
-      return rejectWithValue(e?.message || "Failed to recall memories");
-    }
+    const result = await safeDispatch(dispatch2(
+      api.endpoints.postMemoryRecall.initiate({ npcId, request: { query }, apiUrl, apiKey })
+    ).unwrap());
+    return result.match({
+      left: (e) => rejectWithValue(e),
+      right: (v) => v || []
+    });
   }
 );
 var storeMemoryRemoteThunk = createAsyncThunk5(
   "memory/storeRemote",
   async ({ npcId, observation, importance = 0.8, apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
-    try {
-      return await dispatch2(
-        sdkApi.endpoints.postMemoryStore.initiate({
-          npcId,
-          request: { observation, importance },
-          apiUrl,
-          apiKey
-        })
-      ).unwrap();
-    } catch (e) {
-      return rejectWithValue(e?.message || "Failed to store memory");
-    }
+    const result = await safeDispatch(dispatch2(
+      api.endpoints.postMemoryStore.initiate({ npcId, request: { observation, importance }, apiUrl, apiKey })
+    ).unwrap());
+    return result.match({
+      left: (e) => rejectWithValue(e),
+      right: (v) => v
+    });
   }
 );
 var clearMemoryRemoteThunk = createAsyncThunk5(
   "memory/clearRemote",
   async ({ npcId, apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
-    try {
-      return await dispatch2(
-        sdkApi.endpoints.deleteMemoryClear.initiate({ npcId, apiUrl, apiKey })
-      ).unwrap();
-    } catch (e) {
-      return rejectWithValue(e?.message || "Failed to clear memories");
-    }
+    const result = await safeDispatch(dispatch2(
+      api.endpoints.deleteMemoryClear.initiate({ npcId, apiUrl, apiKey })
+    ).unwrap());
+    return result.match({
+      left: (e) => rejectWithValue(e),
+      right: (v) => v
+    });
   }
 );
+
+// src/handlers/arweave.ts
+var handler_ArweaveUpload = async (instruction, maxRetries = 3) => store.dispatch(
+  api.endpoints.postArweaveUpload.initiate({ ...instruction, maxRetries })
+).unwrap();
+var handler_ArweaveDownload = async (instruction) => store.dispatch(
+  api.endpoints.postArweaveDownload.initiate(instruction)
+).unwrap();
+
+// src/configOps.ts
+var normalizeStatusUrl = (apiUrl) => apiUrl.endsWith("/status") ? apiUrl : `${apiUrl.replace(/\/+$/, "")}/status`;
+var checkApiConnectivity = async (apiUrl = DEFAULT_API_URL) => {
+  try {
+    const res = await fetch(normalizeStatusUrl(apiUrl), { signal: AbortSignal.timeout(1500) });
+    return res.ok;
+  } catch {
+    return false;
+  }
+};
+var resolveReachableApiUrl = async (apiUrl) => {
+  if (apiUrl) return await checkApiConnectivity(apiUrl) ? apiUrl : null;
+  if (await checkApiConnectivity(DEFAULT_API_URL)) return DEFAULT_API_URL;
+  if (await checkApiConnectivity(PRODUCTION_API_URL)) return PRODUCTION_API_URL;
+  return null;
+};
+var resolveApiUrlWithFallback = async (apiUrl) => {
+  if (apiUrl) return apiUrl;
+  return await resolveReachableApiUrl() || PRODUCTION_API_URL;
+};
 export {
-  SDK_VERSION,
+  DEFAULT_API_URL,
+  PRODUCTION_API_URL,
+  VERSION,
+  _,
   addToHistory,
+  api,
   blockAction,
   bridgeSlice,
+  checkApiConnectivity,
   checkApiStatusThunk,
   clearBlock,
   clearBridgeValidation,
@@ -1659,13 +1775,17 @@ export {
   clearMemoryRemoteThunk,
   clearSoulState,
   completeRemoteThunk,
+  compose,
   contextComposed,
   cortexInitFailed,
   cortexInitStart,
   cortexInitSuccess,
   cortexSlice,
+  createDispatcher,
   createInitialState,
-  createSDKStore,
+  createRuntimeRegistry,
+  createRuntimeStore,
+  curry,
   delay,
   deleteRulesetThunk,
   directiveReceived,
@@ -1673,7 +1793,12 @@ export {
   directiveRunStarted,
   directiveSlice,
   dispatch,
+  ebind,
+  efmap,
+  ematch,
   exportToSoul,
+  fmap,
+  fromNullable,
   generateNPCId,
   getBridgeRulesThunk,
   getGhostHistoryThunk,
@@ -1686,12 +1811,20 @@ export {
   importNpcFromSoulThunk,
   importSoulFromArweaveThunk,
   initRemoteCortexThunk,
+  isJust,
+  isLeft,
+  isNothing,
+  isRight,
+  just,
+  left,
   listCortexModelsThunk,
   listMemoryRemoteThunk,
   listRulePresetsThunk,
   listRulesetsThunk,
   loadBridgePresetThunk,
   localExportSoulThunk,
+  match,
+  mbind,
   memoise,
   memoiseAsync,
   memoryClear,
@@ -1702,14 +1835,21 @@ export {
   memoryStoreFailed,
   memoryStoreStart,
   memoryStoreSuccess,
+  multiMatch,
+  nothing,
   npcSlice,
+  orElse,
   pipe,
   processNPC,
   recallMemoryRemoteThunk,
   registerRulesetThunk,
   remoteExportSoulThunk,
   removeNPC,
-  sdkApi,
+  requireJust,
+  resolveApiUrl,
+  resolveApiUrlWithFallback,
+  resolveReachableApiUrl,
+  right,
   selectActiveDirective,
   selectActiveDirectiveId,
   selectActiveNPC,