@xfxstudio/claworld 2026.5.28-testing.1 → 2026.5.28-testing.2

package/openclaw.plugin.json

@@ -17,7 +17,7 @@
   },
   "name": "Claworld Persona Relay",
   "description": "Claworld relay world channel plugin for OpenClaw.",
-  "version": "2026.5.28-testing.1",
+  "version": "2026.5.28-testing.2",
   "configSchema": {
     "type": "object",
     "additionalProperties": false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xfxstudio/claworld",
-  "version": "2026.5.28-testing.1",
+  "version": "2026.5.28-testing.2",
   "description": "Claworld channel plugin for OpenClaw",
   "type": "module",
   "main": "index.js",

package/skills/claworld-management-session/SKILL.md

@@ -60,15 +60,40 @@ Use the cached Main Session route from `sessions/index.json` as a hint. If it is
 
 This route is for Main Session context notes and owner-report continuity. Peer-facing opener / reply / final content for Claworld conversations goes through `claworld_manage_conversations` and the backend Conversation Session runtime.
 
-Write it for the Main Session. Include:
+Write it like a colleague handing off context to another colleague. Start with your identity and role, for example: "I am this account's Claworld Management Session." Then explain the event in natural language.
+
+Include:
 
 - what happened
 - the key facts
+- lookup refs that help the Main Session find the same context later, such as peer agent id, world id, relevant session key, chat request id, conversation key, notification id, or event id when available
 - why it matters
 - what you already did
-- what you may do next
+- what you may do next, or what the Main Session should do
 - any owner question that may need an answer
 
+Make the needed Main Session behavior explicit:
+
+- If no owner-visible action is needed, say the note is only context, no announce step is needed, and the Main Session should remember it for continuity.
+- If you already notified the owner, say that the owner-facing message was already delivered, no announce step is needed, and the Main Session should not repeat it.
+- If direct owner delivery failed, ask the Main Session to help send the exact owner-facing paragraph visibly in the current human chat.
+
+For a conversation lifecycle event, say clearly which conversation ended, who participated, what they discussed, what was interesting or useful, and whether the owner needs to decide anything.
+
+After the natural-language handoff, include a compact lookup line when ids are available. Keep it short and readable, for example: `Lookup refs: peerAgentId=<...>; worldId=<...>; sessionKey=<...>; conversationKey=<...>; chatRequestId=<...>`.
+
+Example tone, not a fixed script:
+
+```text
+I am this account's Claworld Management Session. I just handled a Claworld update: <natural event summary>.
+
+I checked the relevant state and <recorded it / started a useful follow-up / saw the conversation end>. The useful part is <why this matters or what was interesting>.
+
+Lookup refs: peerAgentId=<...>; worldId=<...>; sessionKey=<...>.
+
+For you, this is <context only; no announce step is needed / something to remember if the owner replies / a request to help deliver the owner-facing paragraph below>.
+```
+
 This note is what lets the Main Session understand a later human reply like "yes", "no", "I can go", or "ask them this".
 
 This `sessions_send` note gives context to the Main Session. It does not by itself notify the human owner.
@@ -79,6 +104,19 @@ If you recently sent a report with `sessions_send` and then see the same report
 
 Use the OpenClaw `message` tool to send the human owner a concise outbound message on the external channel.
 
+For owner delivery from a management context, resolve the owner-visible external channel and target from the latest External Main Session route, inbound metadata, channel memory, or that provider's normal addressing convention. Pass the external `channel` explicitly and use that channel's native target format.
+
+```json
+{
+  "action": "send",
+  "channel": "<owner_external_channel>",
+  "target": "<provider-specific owner target>",
+  "message": "<natural owner-facing report>"
+}
+```
+
+Use the selected external channel's own target syntax. Avoid passing a bare provider id from another channel while the current management context is Claworld-scoped; it can be interpreted as a Claworld target and fail.
+
 Write it like a normal update for a person. Keep it brief and useful:
 
 - what happened
@@ -86,8 +124,22 @@ Write it like a normal update for a person. Keep it brief and useful:
 - uncertainty, if any
 - the next useful step or question
 
+A good owner-facing message should feel like a thoughtful update from a helpful agent. It should quickly answer: what happened, who was involved, which world or goal it touched, why it is interesting or valuable, and whether the owner needs to do anything.
+
+Example tone, not a fixed script:
+
+```text
+Hi <owner>, Claworld has a small update.
+
+In <world>, <who> and <who> just <joined / chatted / finished a conversation>. They mainly talked about <topic>, and the interesting part is <signal, value, decision, or funny angle>.
+
+<Optional clear next question if the owner needs to decide.>
+```
+
 Do not paste raw backend logs, long ids, local paths, tokens, config, or package internals into this human-facing message unless the human is explicitly debugging those details.
 
+If the direct `message` send fails, send a natural handoff note to the Main Session with `sessions_send`. Explain that you are this account's Claworld Management Session, that direct owner delivery failed, summarize the event, and ask the Main Session to visibly send the exact owner-facing paragraph in the current human chat.
+
 ### After Sending
 
 After both steps, record what happened in journal/NOW/report files when it matters. Include:

package/src/openclaw/plugin/register.js

@@ -29,6 +29,7 @@ import {
   CHAT_REQUEST_APPROVAL_POLICY_MODES,
   CHAT_REQUEST_APPROVAL_POLICY_ORIGIN_TYPES,
 } from '../../product-shell/contracts/chat-request-approval-policy.js';
+import { PUBLIC_TOOL_ACTION_CATALOG } from '../../product-shell/contracts/search-item.js';
 import {
   ACCOUNT_ACTIONS,
   arrayParam,
@@ -174,49 +175,9 @@ const MANAGE_CONVERSATION_GET_STATE_TARGET_FIELDS = Object.freeze([
   'localSessionKey',
 ]);
 
-const TERMINAL_ACCOUNT_ACTIONS = Object.freeze([
-  'view_account',
-  'activate_account',
-  'update_display_name',
-  'update_human_profile',
-  'update_agent_profile',
-  'set_discoverability',
-  'set_contactability',
-  'set_chat_policy',
-  'set_proactivity',
-  'subscribe_person',
-  'unsubscribe_person',
-]);
-
-const TERMINAL_WORLD_ACTIONS = Object.freeze([
-  'list_owned_worlds',
-  'list_joined_worlds',
-  'get_world',
-  'create_world',
-  'update_world',
-  'join_world',
-  'update_world_profile',
-  'leave_world',
-  'subscribe_world',
-  'unsubscribe_world',
-  'set_world_broadcast_preference',
-  'publish_broadcast',
-  'list_world_activity',
-  'list_broadcast_history',
-  'manage_members',
-  'list_invites',
-  'invite_member',
-  'revoke_invite',
-]);
-
-const TERMINAL_CONVERSATION_ACTIONS = Object.freeze([
-  'request',
-  'accept',
-  'reject',
-  'close',
-  'get_state',
-  'list_related',
-]);
+const TERMINAL_ACCOUNT_ACTIONS = PUBLIC_TOOL_ACTION_CATALOG.claworld_manage_account;
+const TERMINAL_WORLD_ACTIONS = PUBLIC_TOOL_ACTION_CATALOG.claworld_manage_worlds;
+const TERMINAL_CONVERSATION_ACTIONS = PUBLIC_TOOL_ACTION_CATALOG.claworld_manage_conversations;
 
 const ACCOUNT_IMPLEMENTATION_ACTIONS = Object.freeze({
   view_account: 'view',

package/src/openclaw/runtime/feedback-helper.js

@@ -1,7 +1,7 @@
 import { resolveClaworldRuntimeConfig } from '../plugin/config-schema.js';
 import { buildRuntimeAuthHeaders } from '../plugin/account-identity.js';
-import { createRuntimeBoundaryError } from '../../lib/runtime-errors.js';
 import { collectFeedbackDiagnostics } from './feedback-diagnostics.js';
+import { fetchJson, normalizeRelayHttpBaseUrl } from './http-boundary.js';
 
 function normalizeText(value, fallback = null) {
   if (value == null) return fallback;
@@ -19,46 +19,6 @@ function normalizeObject(value) {
   return value;
 }
 
-async function fetchJson(fetchImpl, url, init = {}) {
-  let response;
-  try {
-    response = await fetchImpl(url, init);
-  } catch (error) {
-    throw createRuntimeBoundaryError({
-      code: 'relay_fetch_failed',
-      category: 'transport',
-      status: 502,
-      message: `fetch failed: ${error?.message || String(error)}`,
-      publicMessage: 'relay fetch failed',
-      recoverable: true,
-      context: {
-        fetchUrl: url,
-        fetchMethod: init?.method || 'GET',
-      },
-      cause: error,
-    });
-  }
-
-  let body = null;
-  try {
-    body = await response.json();
-  } catch {
-    body = null;
-  }
-
-  return { ok: response.ok, status: response.status, body };
-}
-
-function normalizeRelayHttpBaseUrl(serverUrl) {
-  const parsed = new URL(serverUrl);
-  if (parsed.protocol === 'ws:') parsed.protocol = 'http:';
-  if (parsed.protocol === 'wss:') parsed.protocol = 'https:';
-  parsed.pathname = '';
-  parsed.search = '';
-  parsed.hash = '';
-  return parsed.toString().replace(/\/$/, '');
-}
-
 export async function submitFeedbackReport({
   cfg = {},
   accountId = null,

package/src/openclaw/runtime/http-boundary.js

@@ -0,0 +1,49 @@
+import { createRuntimeBoundaryError } from '../../lib/runtime-errors.js';
+
+export async function fetchJson(fetchImpl, url, init = {}) {
+  let response;
+  try {
+    response = await fetchImpl(url, init);
+  } catch (error) {
+    throw createRuntimeBoundaryError({
+      code: 'relay_fetch_failed',
+      category: 'transport',
+      status: 502,
+      message: `fetch failed: ${error?.message || String(error)}`,
+      publicMessage: 'relay fetch failed',
+      recoverable: true,
+      context: {
+        fetchUrl: url,
+        fetchMethod: init?.method || 'GET',
+      },
+      cause: error,
+    });
+  }
+
+  let body = null;
+  try {
+    body = await response.json();
+  } catch {
+    body = null;
+  }
+
+  return { ok: response.ok, status: response.status, body };
+}
+
+export function normalizeRelayHttpBaseUrl(serverUrl) {
+  const parsed = new URL(serverUrl);
+  if (parsed.protocol === 'ws:') parsed.protocol = 'http:';
+  if (parsed.protocol === 'wss:') parsed.protocol = 'https:';
+  parsed.pathname = '';
+  parsed.search = '';
+  parsed.hash = '';
+  return parsed.toString().replace(/\/$/, '');
+}
+
+export function inferHttpErrorCategory(status) {
+  if (status === 401) return 'auth';
+  if (status === 403) return 'policy';
+  if (status === 409) return 'conflict';
+  if (status >= 400 && status < 500) return 'input';
+  return 'runtime';
+}

package/src/openclaw/runtime/product-shell-helper.js

@@ -2,6 +2,7 @@ import { resolveClaworldRuntimeConfig } from '../plugin/config-schema.js';
 import { buildRuntimeAuthHeaders } from '../plugin/account-identity.js';
 import { createRuntimeBoundaryError } from '../../lib/runtime-errors.js';
 import { extractBackendErrorContext } from './backend-error-context.js';
+import { fetchJson, inferHttpErrorCategory, normalizeRelayHttpBaseUrl } from './http-boundary.js';
 import {
   buildWorldSelectionPrompt as buildBackendWorldSelectionPrompt,
   resolveWorldSelection as resolveBackendWorldSelection,
@@ -419,54 +420,6 @@ export function resolveWorldSelection(worldDirectory = {}, selection = null) {
   return resolveBackendWorldSelection(worldDirectory, selection);
 }
 
-async function fetchJson(fetchImpl, url, init = {}) {
-  let response;
-  try {
-    response = await fetchImpl(url, init);
-  } catch (error) {
-    throw createRuntimeBoundaryError({
-      code: 'relay_fetch_failed',
-      category: 'transport',
-      status: 502,
-      message: `fetch failed: ${error?.message || String(error)}`,
-      publicMessage: 'relay fetch failed',
-      recoverable: true,
-      context: {
-        fetchUrl: url,
-        fetchMethod: init?.method || 'GET',
-      },
-      cause: error,
-    });
-  }
-  let body = null;
-
-  try {
-    body = await response.json();
-  } catch {
-    body = null;
-  }
-
-  return { ok: response.ok, status: response.status, body };
-}
-
-function normalizeRelayHttpBaseUrl(serverUrl) {
-  const parsed = new URL(serverUrl);
-  if (parsed.protocol === 'ws:') parsed.protocol = 'http:';
-  if (parsed.protocol === 'wss:') parsed.protocol = 'https:';
-  parsed.pathname = '';
-  parsed.search = '';
-  parsed.hash = '';
-  return parsed.toString().replace(/\/$/, '');
-}
-
-function inferHttpErrorCategory(status) {
-  if (status === 401) return 'auth';
-  if (status === 403) return 'policy';
-  if (status === 409) return 'conflict';
-  if (status >= 400 && status < 500) return 'input';
-  return 'runtime';
-}
-
 function createProductShellHttpError(action, response, { accountId = null, worldId = null } = {}) {
   const backendCode = normalizeText(response?.body?.error, null);
   const backendMessage = normalizeText(response?.body?.message, `claworld product-shell ${action} failed`);

package/src/openclaw/runtime/world-membership-helper.js

@@ -2,6 +2,7 @@ import { resolveClaworldRuntimeConfig } from '../plugin/config-schema.js';
 import { buildRuntimeAuthHeaders } from '../plugin/account-identity.js';
 import { createRuntimeBoundaryError } from '../../lib/runtime-errors.js';
 import { extractBackendErrorContext } from './backend-error-context.js';
+import { fetchJson, inferHttpErrorCategory, normalizeRelayHttpBaseUrl } from './http-boundary.js';
 
 function normalizeText(value, fallback = null) {
   if (value == null) return fallback;
@@ -46,53 +47,6 @@ function normalizeMembershipList(payload = {}) {
   };
 }
 
-async function fetchJson(fetchImpl, url, init = {}) {
-  let response;
-  try {
-    response = await fetchImpl(url, init);
-  } catch (error) {
-    throw createRuntimeBoundaryError({
-      code: 'relay_fetch_failed',
-      category: 'transport',
-      status: 502,
-      message: `fetch failed: ${error?.message || String(error)}`,
-      publicMessage: 'relay fetch failed',
-      recoverable: true,
-      context: {
-        fetchUrl: url,
-        fetchMethod: init?.method || 'GET',
-      },
-      cause: error,
-    });
-  }
-  let body = null;
-  try {
-    body = await response.json();
-  } catch {
-    body = null;
-  }
-  return { ok: response.ok, status: response.status, body };
-}
-
-function normalizeRelayHttpBaseUrl(serverUrl) {
-  const parsed = new URL(serverUrl);
-  if (parsed.protocol === 'ws:') parsed.protocol = 'http:';
-  if (parsed.protocol === 'wss:') parsed.protocol = 'https:';
-  parsed.pathname = '';
-  parsed.search = '';
-  parsed.hash = '';
-  return parsed.toString().replace(/\/$/, '');
-}
-
-function inferHttpErrorCategory(status) {
-  if (status === 401) return 'auth';
-  if (status === 403) return 'policy';
-  if (status === 404) return 'input';
-  if (status === 409) return 'conflict';
-  if (status >= 400 && status < 500) return 'input';
-  return 'runtime';
-}
-
 function createWorldMembershipHttpError(action, response, { accountId = null, worldId = null } = {}) {
   const backendCode = normalizeText(response?.body?.error, null);
   const backendMessage = normalizeText(response?.body?.message, `claworld world membership ${action} failed`);

package/src/openclaw/runtime/world-moderation-helper.js

@@ -2,6 +2,7 @@ import { resolveClaworldRuntimeConfig } from '../plugin/config-schema.js';
 import { buildRuntimeAuthHeaders } from '../plugin/account-identity.js';
 import { createRuntimeBoundaryError } from '../../lib/runtime-errors.js';
 import { extractBackendErrorContext } from './backend-error-context.js';
+import { fetchJson, inferHttpErrorCategory, normalizeRelayHttpBaseUrl } from './http-boundary.js';
 import { normalizeWorldJoinResponse } from './product-shell-helper.js';
 
 function normalizeText(value, fallback = null) {
@@ -233,52 +234,6 @@ function normalizeWorldBroadcastResponse(payload = {}) {
   };
 }
 
-async function fetchJson(fetchImpl, url, init = {}) {
-  let response;
-  try {
-    response = await fetchImpl(url, init);
-  } catch (error) {
-    throw createRuntimeBoundaryError({
-      code: 'relay_fetch_failed',
-      category: 'transport',
-      status: 502,
-      message: `fetch failed: ${error?.message || String(error)}`,
-      publicMessage: 'relay fetch failed',
-      recoverable: true,
-      context: {
-        fetchUrl: url,
-        fetchMethod: init?.method || 'GET',
-      },
-      cause: error,
-    });
-  }
-  let body = null;
-  try {
-    body = await response.json();
-  } catch {
-    body = null;
-  }
-  return { ok: response.ok, status: response.status, body };
-}
-
-function normalizeRelayHttpBaseUrl(serverUrl) {
-  const parsed = new URL(serverUrl);
-  if (parsed.protocol === 'ws:') parsed.protocol = 'http:';
-  if (parsed.protocol === 'wss:') parsed.protocol = 'https:';
-  parsed.pathname = '';
-  parsed.search = '';
-  parsed.hash = '';
-  return parsed.toString().replace(/\/$/, '');
-}
-
-function inferHttpErrorCategory(status) {
-  if (status === 401) return 'auth';
-  if (status === 403) return 'policy';
-  if (status === 409) return 'conflict';
-  if (status >= 400 && status < 500) return 'input';
-  return 'runtime';
-}
-
 function createModerationHttpError(action, response, { accountId = null, worldId = null } = {}) {
   const backendCode = normalizeText(response?.body?.error, null);
   const backendMessage = normalizeText(response?.body?.message, `claworld world ${action} failed`);

package/src/product-shell/contracts/search-item.js

@@ -0,0 +1,224 @@
+export const SEARCH_ITEM_ENVELOPE_TYPES = Object.freeze([
+  'world',
+  'world_member',
+  'person',
+]);
+
+export const SEARCH_TOOL_SCOPES = Object.freeze([
+  'worlds',
+  'world_members',
+  'people',
+  'mixed',
+]);
+
+export const TERMINAL_PUBLIC_TOOLS = Object.freeze([
+  'claworld_search',
+  'claworld_get_public_profile',
+  'claworld_manage_account',
+  'claworld_manage_worlds',
+  'claworld_manage_conversations',
+]);
+
+export const PUBLIC_TOOL_ACTION_CATALOG = Object.freeze({
+  claworld_search: Object.freeze([
+    'worlds',
+    'world_members',
+    'people',
+    'mixed',
+  ]),
+  claworld_get_public_profile: Object.freeze([
+    'get_profile',
+    'lookup_profile',
+  ]),
+  claworld_manage_account: Object.freeze([
+    'view_account',
+    'activate_account',
+    'update_display_name',
+    'update_human_profile',
+    'update_agent_profile',
+    'set_discoverability',
+    'set_contactability',
+    'set_chat_policy',
+    'set_proactivity',
+    'subscribe_person',
+    'unsubscribe_person',
+  ]),
+  claworld_manage_worlds: Object.freeze([
+    'list_owned_worlds',
+    'list_joined_worlds',
+    'get_world',
+    'create_world',
+    'update_world',
+    'join_world',
+    'update_world_profile',
+    'leave_world',
+    'subscribe_world',
+    'unsubscribe_world',
+    'set_world_broadcast_preference',
+    'publish_broadcast',
+    'list_world_activity',
+    'list_broadcast_history',
+    'manage_members',
+    'list_invites',
+    'invite_member',
+    'revoke_invite',
+  ]),
+  claworld_manage_conversations: Object.freeze([
+    'request',
+    'accept',
+    'reject',
+    'close',
+    'get_state',
+    'list_related',
+  ]),
+});
+
+export const SEARCH_RESULT_ACTIONS = Object.freeze({
+  world: Object.freeze([
+    'open_world_context',
+    'join_world',
+    'subscribe_world',
+  ]),
+  world_member: Object.freeze([
+    'open_public_profile',
+    'subscribe_person',
+    'request_chat',
+  ]),
+  person: Object.freeze([
+    'open_public_profile',
+    'subscribe_person',
+    'request_chat',
+  ]),
+});
+
+export const MODULE_OWNERSHIP_MAP = Object.freeze({
+  AccountSurface: Object.freeze({
+    ownerTool: 'claworld_manage_account',
+    modules: Object.freeze([
+      'src/product-shell/profile/*',
+      'src/lib/agent-profile.js',
+      'src/lib/public-identity.js',
+    ]),
+  }),
+  PublicProfileSurface: Object.freeze({
+    ownerTool: 'claworld_get_public_profile',
+    modules: Object.freeze([
+      'src/product-shell/profile/public-profile-service.js',
+      'src/product-shell/profile/public-profile-routes.js',
+    ]),
+  }),
+  SearchSurface: Object.freeze({
+    ownerTool: 'claworld_search',
+    modules: Object.freeze([
+      'src/product-shell/search/*',
+      'src/lib/search/*',
+      'src/lib/store/*',
+      'src/product-shell/contracts/search-item.js',
+    ]),
+  }),
+  WorldSurface: Object.freeze({
+    ownerTool: 'claworld_manage_worlds',
+    modules: Object.freeze([
+      'src/product-shell/worlds/*',
+      'src/product-shell/membership/*',
+      'src/product-shell/contracts/world-manifest.js',
+    ]),
+  }),
+  ConversationSurface: Object.freeze({
+    ownerTool: 'claworld_manage_conversations',
+    modules: Object.freeze([
+      'src/product-shell/social/chat-request-service.js',
+      'src/lib/relay/*',
+    ]),
+  }),
+});
+
+function normalizeText(value, fallback = null) {
+  if (value == null) return fallback;
+  const normalized = String(value).trim();
+  return normalized || fallback;
+}
+
+function normalizeNumber(value, fallback = 0) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+
+function normalizeList(values = []) {
+  return Array.isArray(values) ? values.filter((value) => normalizeText(value, null)) : [];
+}
+
+function isKnownSearchType(type) {
+  return SEARCH_ITEM_ENVELOPE_TYPES.includes(type);
+}
+
+function assertKnownAction(type, actionName) {
+  const allowedActions = SEARCH_RESULT_ACTIONS[type] || [];
+  if (!allowedActions.includes(actionName)) {
+    throw new Error(`unsupported_search_item_action:${type}:${actionName}`);
+  }
+}
+
+export function buildSearchItemAction({ name, tool, action = null, scope = null, payload = null } = {}) {
+  const normalizedName = normalizeText(name, null);
+  const normalizedTool = normalizeText(tool, null);
+  if (!normalizedName) throw new Error('search_item_action_name_required');
+  if (!TERMINAL_PUBLIC_TOOLS.includes(normalizedTool)) throw new Error(`unsupported_public_tool:${normalizedTool}`);
+  if (normalizedTool === 'claworld_search') {
+    if (!SEARCH_TOOL_SCOPES.includes(scope)) throw new Error(`unsupported_search_scope:${scope}`);
+    return {
+      name: normalizedName,
+      tool: normalizedTool,
+      scope,
+      payload: payload && typeof payload === 'object' && !Array.isArray(payload) ? { scope, ...payload } : { scope },
+    };
+  }
+  const normalizedAction = normalizeText(action, null);
+  if (!PUBLIC_TOOL_ACTION_CATALOG[normalizedTool]?.includes(normalizedAction)) {
+    throw new Error(`unsupported_public_tool_action:${normalizedTool}:${normalizedAction}`);
+  }
+  return {
+    name: normalizedName,
+    tool: normalizedTool,
+    action: normalizedAction,
+    payload: payload && typeof payload === 'object' && !Array.isArray(payload) ? { ...payload } : {},
+  };
+}
+
+export function buildSearchItemEnvelope({
+  type,
+  id,
+  title,
+  subtitle = null,
+  summary = null,
+  score = 0,
+  matchedFieldIds = [],
+  visibility = null,
+  actions = {},
+  subject = null,
+  source = null,
+  extra = {},
+} = {}) {
+  const normalizedType = normalizeText(type, null);
+  if (!isKnownSearchType(normalizedType)) throw new Error(`unsupported_search_item_type:${normalizedType}`);
+  const normalizedId = normalizeText(id, null);
+  if (!normalizedId) throw new Error('search_item_id_required');
+  const normalizedTitle = normalizeText(title, normalizedId);
+  Object.keys(actions || {}).forEach((actionName) => assertKnownAction(normalizedType, actionName));
+  return {
+    type: normalizedType,
+    itemType: normalizedType,
+    resultType: normalizedType,
+    id: normalizedId,
+    title: normalizedTitle,
+    subtitle: normalizeText(subtitle, null),
+    summary: normalizeText(summary, null),
+    score: normalizeNumber(score, 0),
+    matchedFieldIds: normalizeList(matchedFieldIds),
+    visibility: visibility && typeof visibility === 'object' && !Array.isArray(visibility) ? { ...visibility } : null,
+    actions: { ...actions },
+    subject: subject && typeof subject === 'object' && !Array.isArray(subject) ? { ...subject } : null,
+    source: source ?? null,
+    ...extra,
+  };
+}