@useorgx/openclaw-plugin 0.4.6 → 0.4.9

package/dist/activity-actor-fields.js

@@ -0,0 +1,128 @@
+function asRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    return value;
+}
+function nonEmptyString(value) {
+    if (typeof value !== "string")
+        return null;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+function firstString(record, keys) {
+    if (!record)
+        return null;
+    for (const key of keys) {
+        const candidate = nonEmptyString(record[key]);
+        if (candidate)
+            return candidate;
+    }
+    return null;
+}
+function normalizedMetadata(item) {
+    const metadata = asRecord(item.metadata);
+    if (!metadata)
+        return null;
+    const nested = asRecord(metadata.metadata);
+    if (!nested)
+        return metadata;
+    return { ...metadata, ...nested };
+}
+function hasActorValue(id, name) {
+    return Boolean((id && id.trim().length > 0) || (name && name.trim().length > 0));
+}
+export function enrichActivityActorFields(item) {
+    const metadata = normalizedMetadata(item);
+    let requesterAgentId = nonEmptyString(item.requesterAgentId) ??
+        firstString(metadata, [
+            "requested_by_agent_id",
+            "requestedByAgentId",
+            "requester_agent_id",
+            "requesterAgentId",
+            "requester_id",
+            "requesterId",
+            "runner_agent_id",
+            "runnerAgentId",
+            "handoff_from_agent_id",
+            "handoffFromAgentId",
+            "from_agent_id",
+            "fromAgentId",
+            "source_agent_id",
+            "sourceAgentId",
+        ]);
+    let requesterAgentName = nonEmptyString(item.requesterAgentName) ??
+        firstString(metadata, [
+            "requested_by_agent_name",
+            "requestedByAgentName",
+            "requester_agent_name",
+            "requesterAgentName",
+            "requester_name",
+            "requesterName",
+            "runner_agent_name",
+            "runnerAgentName",
+            "handoff_from_agent_name",
+            "handoffFromAgentName",
+            "from_agent_name",
+            "fromAgentName",
+            "source_agent_name",
+            "sourceAgentName",
+        ]);
+    const executorAgentId = nonEmptyString(item.executorAgentId) ??
+        firstString(metadata, [
+            "executed_by_agent_id",
+            "executedByAgentId",
+            "executor_agent_id",
+            "executorAgentId",
+            "executor_id",
+            "executorId",
+            "delegated_to_agent_id",
+            "delegatedToAgentId",
+            "handoff_to_agent_id",
+            "handoffToAgentId",
+            "target_agent_id",
+            "targetAgentId",
+            "agent_id",
+            "agentId",
+        ]) ??
+        nonEmptyString(item.agentId);
+    const executorAgentName = nonEmptyString(item.executorAgentName) ??
+        firstString(metadata, [
+            "executed_by_agent_name",
+            "executedByAgentName",
+            "executor_agent_name",
+            "executorAgentName",
+            "executor_name",
+            "executorName",
+            "delegated_to_agent_name",
+            "delegatedToAgentName",
+            "handoff_to_agent_name",
+            "handoffToAgentName",
+            "target_agent_name",
+            "targetAgentName",
+            "agent_name",
+            "agentName",
+        ]) ??
+        nonEmptyString(item.agentName);
+    if (!hasActorValue(requesterAgentId, requesterAgentName) && hasActorValue(executorAgentId, executorAgentName)) {
+        requesterAgentId = executorAgentId;
+        requesterAgentName = executorAgentName;
+    }
+    const unchanged = nonEmptyString(item.requesterAgentId) === requesterAgentId &&
+        nonEmptyString(item.requesterAgentName) === requesterAgentName &&
+        nonEmptyString(item.executorAgentId) === executorAgentId &&
+        nonEmptyString(item.executorAgentName) === executorAgentName;
+    if (unchanged)
+        return item;
+    return {
+        ...item,
+        requesterAgentId: requesterAgentId ?? null,
+        requesterAgentName: requesterAgentName ?? null,
+        executorAgentId: executorAgentId ?? null,
+        executorAgentName: executorAgentName ?? null,
+    };
+}
+export function enrichActivityActorFieldsList(items) {
+    if (!Array.isArray(items) || items.length === 0)
+        return [];
+    return items.map((item) => enrichActivityActorFields(item));
+}

package/dist/activity-store.js

@@ -1,7 +1,9 @@
-import { chmodSync, existsSync, mkdirSync, readFileSync, } from "node:fs";
+import { existsSync, readFileSync, } from "node:fs";
 import { Buffer } from "node:buffer";
+import { enrichActivityActorFieldsList } from "./activity-actor-fields.js";
 import { getOrgxPluginConfigDir, getOrgxPluginConfigPath } from "./paths.js";
 import { backupCorruptFileSync, writeJsonFileAtomicSync } from "./fs-utils.js";
+import { ensureStoreDirSync, parseJsonSafe } from "./stores/json-store.js";
 const STORE_VERSION = 1;
 const STORE_FILENAME = "activity-store.json";
 const MAX_ITEMS = 50_000;
@@ -9,26 +11,11 @@ const RETENTION_DAYS = 45;
 const FLUSH_DEBOUNCE_MS = 1_250;
 let cached = null;
 function ensureDir() {
-    const dir = getOrgxPluginConfigDir();
-    mkdirSync(dir, { recursive: true, mode: 0o700 });
-    try {
-        chmodSync(dir, 0o700);
-    }
-    catch {
-        // best effort
-    }
+    ensureStoreDirSync(getOrgxPluginConfigDir());
 }
 function storePath() {
     return getOrgxPluginConfigPath(STORE_FILENAME);
 }
-function parseJson(value) {
-    try {
-        return JSON.parse(value);
-    }
-    catch {
-        return null;
-    }
-}
 function toEpoch(value) {
     if (!value)
         return 0;
@@ -62,7 +49,9 @@ function normalizeItems(source) {
             continue;
         byId.set(id, item);
     }
-    return Array.from(byId.values()).sort(compareActivity).slice(0, MAX_ITEMS);
+    return enrichActivityActorFieldsList(Array.from(byId.values()))
+        .sort(compareActivity)
+        .slice(0, MAX_ITEMS);
 }
 function readPersistedStore() {
     ensureDir();
@@ -72,7 +61,7 @@ function readPersistedStore() {
     }
     try {
         const raw = readFileSync(file, "utf8");
-        const parsed = parseJson(raw);
+        const parsed = parseJsonSafe(raw);
         if (!parsed || parsed.version !== STORE_VERSION || !Array.isArray(parsed.items)) {
             backupCorruptFileSync(file);
             return { version: STORE_VERSION, updatedAt: new Date().toISOString(), items: [] };
@@ -181,6 +170,10 @@ export function appendActivityItems(items) {
             existing.type !== item.type ||
             existing.title !== item.title ||
             existing.description !== item.description ||
+            (existing.requesterAgentId ?? null) !== (item.requesterAgentId ?? null) ||
+            (existing.requesterAgentName ?? null) !== (item.requesterAgentName ?? null) ||
+            (existing.executorAgentId ?? null) !== (item.executorAgentId ?? null) ||
+            (existing.executorAgentName ?? null) !== (item.executorAgentName ?? null) ||
             existing.summary !== item.summary ||
             JSON.stringify(existing.metadata ?? null) !== JSON.stringify(item.metadata ?? null)) {
             state.byId.set(id, item);

package/dist/agent-context-store.js

@@ -1,6 +1,7 @@
-import { chmodSync, existsSync, mkdirSync, readFileSync, rmSync, } from "node:fs";
+import { existsSync, readFileSync, } from "node:fs";
 import { getOrgxPluginConfigDir, getOrgxPluginConfigPath } from "./paths.js";
 import { backupCorruptFileSync, writeJsonFileAtomicSync } from "./fs-utils.js";
+import { clearStoreFileSync, ensureStoreDirSync, parseJsonSafe, } from "./stores/json-store.js";
 const MAX_AGENTS = 120;
 const MAX_RUNS = 480;
 function contextDir() {
@@ -10,22 +11,7 @@ function contextFile() {
     return getOrgxPluginConfigPath("agent-contexts.json");
 }
 function ensureContextDir() {
-    const dir = contextDir();
-    mkdirSync(dir, { recursive: true, mode: 0o700 });
-    try {
-        chmodSync(dir, 0o700);
-    }
-    catch {
-        // best effort
-    }
-}
-function parseJson(value) {
-    try {
-        return JSON.parse(value);
-    }
-    catch {
-        return null;
-    }
+    ensureStoreDirSync(contextDir());
 }
 function normalizeContext(input) {
     return {
@@ -55,7 +41,7 @@ export function readAgentContexts() {
             return { updatedAt: new Date().toISOString(), agents: {}, runs: {} };
         }
         const raw = readFileSync(file, "utf8");
-        const parsed = parseJson(raw);
+        const parsed = parseJsonSafe(raw);
         if (!parsed || typeof parsed !== "object") {
             backupCorruptFileSync(file);
             return { updatedAt: new Date().toISOString(), agents: {}, runs: {} };
@@ -157,11 +143,5 @@ export function upsertRunContext(input) {
     return next;
 }
 export function clearAgentContexts() {
-    const file = contextFile();
-    try {
-        rmSync(file, { force: true });
-    }
-    catch {
-        // best effort
-    }
+    clearStoreFileSync(contextFile());
 }

package/dist/agent-run-store.js

@@ -1,6 +1,7 @@
-import { chmodSync, existsSync, mkdirSync, readFileSync, rmSync, } from "node:fs";
+import { existsSync, readFileSync, } from "node:fs";
 import { getOrgxPluginConfigDir, getOrgxPluginConfigPath } from "./paths.js";
 import { backupCorruptFileSync, writeJsonFileAtomicSync } from "./fs-utils.js";
+import { clearStoreFileSync, ensureStoreDirSync, parseJsonSafe, } from "./stores/json-store.js";
 const MAX_RUNS = 240;
 function runDir() {
     return getOrgxPluginConfigDir();
@@ -9,22 +10,7 @@ function runFile() {
     return getOrgxPluginConfigPath("agent-runs.json");
 }
 function ensureRunDir() {
-    const dir = runDir();
-    mkdirSync(dir, { recursive: true, mode: 0o700 });
-    try {
-        chmodSync(dir, 0o700);
-    }
-    catch {
-        // best effort
-    }
-}
-function parseJson(value) {
-    try {
-        return JSON.parse(value);
-    }
-    catch {
-        return null;
-    }
+    ensureStoreDirSync(runDir());
 }
 function normalizeNullableString(value) {
     if (typeof value !== "string")
@@ -56,7 +42,7 @@ export function readAgentRuns() {
             return { updatedAt: new Date().toISOString(), runs: {} };
         }
         const raw = readFileSync(file, "utf8");
-        const parsed = parseJson(raw);
+        const parsed = parseJsonSafe(raw);
         if (!parsed || typeof parsed !== "object") {
             backupCorruptFileSync(file);
             return { updatedAt: new Date().toISOString(), runs: {} };
@@ -148,11 +134,5 @@ export function markAgentRunStopped(runId) {
     return updated ? normalizeRecord(updated) : null;
 }
 export function clearAgentRuns() {
-    const file = runFile();
-    try {
-        rmSync(file, { force: true });
-    }
-    catch {
-        // best effort
-    }
+    clearStoreFileSync(runFile());
 }

package/dist/agent-suite.js

@@ -3,6 +3,7 @@ import { existsSync, mkdirSync, readFileSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { writeFileAtomicSync } from "./fs-utils.js";
+import { parseJsonSafe } from "./json-utils.js";
 import { getOpenClawDir } from "./paths.js";
 export const ORGX_AGENT_SUITE_PACK_ID = "orgx-agent-suite";
 export const ORGX_AGENT_SUITE_AGENTS = [
@@ -29,14 +30,6 @@ const SUITE_FILES = [
 function isRecord(value) {
     return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
-function parseJsonSafe(raw) {
-    try {
-        return JSON.parse(raw);
-    }
-    catch {
-        return null;
-    }
-}
 function isSafeAgentId(value) {
     const trimmed = value.trim();
     if (!trimmed)

package/dist/artifacts/register-artifact.d.ts

@@ -0,0 +1,47 @@
+import type { OrgXClient } from "../contracts/client.js";
+export type ArtifactEntityType = "initiative" | "milestone" | "task" | "decision" | "project";
+export interface RegisterArtifactInput {
+    /** Optional deterministic artifact id (UUID). Enables idempotent retries/outbox replay. */
+    artifact_id?: string | null;
+    entity_type: ArtifactEntityType;
+    entity_id: string;
+    name: string;
+    artifact_type: string;
+    /**
+     * Required by OrgX work_artifacts schema.
+     * If omitted, defaults to "human" (safe default for user-scoped oxk_ keys).
+     */
+    created_by_type?: "human" | "agent" | null;
+    /**
+     * Optional explicit creator id. OrgX can typically infer this from auth context,
+     * but allow callers to supply it when they have a stable UUID.
+     */
+    created_by_id?: string | null;
+    description?: string | null;
+    external_url?: string | null;
+    preview_markdown?: string | null;
+    status?: string;
+    metadata?: Record<string, unknown> | null;
+    /**
+     * When true, do a read-after-write check against:
+     * - GET /api/artifacts/:id
+     * - GET /api/work-artifacts/by-entity
+     */
+    validate_persistence?: boolean;
+}
+export interface RegisterArtifactResult {
+    ok: boolean;
+    artifact_id: string | null;
+    artifact_url: string | null;
+    created: boolean;
+    persistence: {
+        checked: boolean;
+        artifact_detail_ok: boolean;
+        linked_ok: boolean;
+        attempts: number;
+        last_error: string | null;
+    };
+    warnings: string[];
+}
+export declare function validateRegisterArtifactInput(input: RegisterArtifactInput): string[];
+export declare function registerArtifact(client: OrgXClient, baseUrl: string, input: RegisterArtifactInput): Promise<RegisterArtifactResult>;

package/dist/artifacts/register-artifact.js

@@ -0,0 +1,271 @@
+import { randomUUID } from "node:crypto";
+const MAX_PREVIEW_MARKDOWN = 25_000;
+function normalizeText(value) {
+    return typeof value === "string" ? value.trim() : "";
+}
+function isUuid(value) {
+    return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value);
+}
+function resolveCreatedById(client, input) {
+    const explicit = normalizeText(input.created_by_id);
+    if (explicit && isUuid(explicit))
+        return explicit;
+    const fromClient = typeof client?.getUserId === "function"
+        ? normalizeText(client.getUserId())
+        : "";
+    if (fromClient && isUuid(fromClient))
+        return fromClient;
+    const fromEnv = normalizeText(process.env.ORGX_CREATED_BY_ID);
+    if (fromEnv && isUuid(fromEnv))
+        return fromEnv;
+    return null;
+}
+export function validateRegisterArtifactInput(input) {
+    const errors = [];
+    if (!input || typeof input !== "object") {
+        return ["input must be an object"];
+    }
+    const entityType = normalizeText(input.entity_type);
+    if (!entityType)
+        errors.push("entity_type is required");
+    const entityId = normalizeText(input.entity_id);
+    if (!entityId)
+        errors.push("entity_id is required");
+    // In production OrgX uses UUIDs, but tests/mocks sometimes use short ids like "init-1".
+    // Keep this as a soft constraint (persistence validation will catch mismatches upstream).
+    const name = normalizeText(input.name);
+    if (!name)
+        errors.push("name is required");
+    const artifactType = normalizeText(input.artifact_type);
+    if (!artifactType)
+        errors.push("artifact_type is required");
+    const createdByType = normalizeText(input.created_by_type);
+    if (createdByType && createdByType !== "human" && createdByType !== "agent") {
+        errors.push("created_by_type must be 'human' or 'agent' when provided");
+    }
+    const externalUrl = normalizeText(input.external_url);
+    const preview = normalizeText(input.preview_markdown);
+    if (!externalUrl && !preview) {
+        errors.push("at least one of external_url or preview_markdown is required");
+    }
+    return errors;
+}
+function safeErrorMessage(err) {
+    if (err instanceof Error)
+        return err.message;
+    return String(err);
+}
+function isArtifactTypeConstraintError(err) {
+    const msg = safeErrorMessage(err).toLowerCase();
+    return (msg.includes("artifact_type") &&
+        (msg.includes("constraint") || msg.includes("foreign") || msg.includes("violat")));
+}
+function normalizeBaseUrl(baseUrl) {
+    return baseUrl.replace(/\/+$/, "");
+}
+async function sleep(ms) {
+    await new Promise((r) => setTimeout(r, ms));
+}
+async function validateArtifactPersistence(client, input) {
+    // Use API-key compatible entity CRUD endpoints for validation.
+    // The web UI endpoints (/api/artifacts/*, /api/work-artifacts/*) are session-authenticated (401 for API keys).
+    const detail = await client.rawRequest("GET", `/api/entities?type=artifact&id=${encodeURIComponent(input.artifactId)}`);
+    const rows = detail && typeof detail === "object" ? detail.data : null;
+    const artifact = Array.isArray(rows) ? rows.find((r) => r && typeof r === "object" && r.id === input.artifactId) : null;
+    const artifactOk = artifact && typeof artifact === "object" && typeof artifact.id === "string" && artifact.id === input.artifactId;
+    const linkedOk = artifactOk &&
+        typeof artifact.entity_type === "string" &&
+        typeof artifact.entity_id === "string" &&
+        artifact.entity_type === input.entity_type &&
+        artifact.entity_id === input.entity_id;
+    return { artifact_detail_ok: Boolean(artifactOk), linked_ok: Boolean(linkedOk) };
+}
+export async function registerArtifact(client, baseUrl, input) {
+    const warnings = [];
+    const errors = validateRegisterArtifactInput(input);
+    if (errors.length > 0) {
+        return {
+            ok: false,
+            artifact_id: null,
+            artifact_url: null,
+            created: false,
+            persistence: {
+                checked: false,
+                artifact_detail_ok: false,
+                linked_ok: false,
+                attempts: 0,
+                last_error: errors.join("; "),
+            },
+            warnings: [],
+        };
+    }
+    const requestedId = normalizeText(input.artifact_id);
+    const desiredId = requestedId && isUuid(requestedId) ? requestedId : randomUUID();
+    const artifactUrl = `${normalizeBaseUrl(baseUrl)}/artifacts/${desiredId}`;
+    const status = normalizeText(input.status) || "draft";
+    const createdByType = normalizeText(input.created_by_type) || "human";
+    const createdById = resolveCreatedById(client, input);
+    const createdBy = createdById ? { created_by_type: createdByType, created_by_id: createdById } : { created_by_type: createdByType };
+    const metadata = {
+        ...(input.metadata && typeof input.metadata === "object" && !Array.isArray(input.metadata)
+            ? input.metadata
+            : {}),
+    };
+    if (input.external_url)
+        metadata.external_url = String(input.external_url);
+    if (input.preview_markdown) {
+        const preview = String(input.preview_markdown);
+        metadata.preview_markdown =
+            preview.length > MAX_PREVIEW_MARKDOWN
+                ? preview.slice(0, MAX_PREVIEW_MARKDOWN)
+                : preview;
+        if (preview.length > MAX_PREVIEW_MARKDOWN)
+            metadata.preview_truncated = true;
+    }
+    const metadataInitiativeId = typeof metadata.initiative_id === "string" && metadata.initiative_id.trim().length > 0
+        ? metadata.initiative_id.trim()
+        : null;
+    const initiativeIdHint = input.entity_type === "initiative" ? input.entity_id : metadataInitiativeId;
+    let entity = null;
+    let created = false;
+    // Attempt idempotent create using a client-provided UUID id (preferred).
+    try {
+        try {
+            entity = await client.createEntity("artifact", {
+                id: desiredId,
+                name: input.name,
+                description: input.description ?? undefined,
+                artifact_type: input.artifact_type,
+                entity_type: input.entity_type,
+                entity_id: input.entity_id,
+                ...(initiativeIdHint ? { initiative_id: initiativeIdHint } : {}),
+                artifact_url: artifactUrl,
+                status,
+                metadata,
+                ...createdBy,
+            });
+            created = true;
+        }
+        catch (err) {
+            if (!isArtifactTypeConstraintError(err)) {
+                throw err;
+            }
+            warnings.push(`artifact_type rejected; retrying with shared.project_handbook`);
+            metadata.requested_artifact_type = input.artifact_type;
+            entity = await client.createEntity("artifact", {
+                id: desiredId,
+                name: input.name,
+                description: input.description ?? undefined,
+                artifact_type: "shared.project_handbook",
+                entity_type: input.entity_type,
+                entity_id: input.entity_id,
+                ...(initiativeIdHint ? { initiative_id: initiativeIdHint } : {}),
+                artifact_url: artifactUrl,
+                status,
+                metadata,
+                ...createdBy,
+            });
+            created = true;
+        }
+    }
+    catch (err) {
+        warnings.push(`artifact create with explicit id failed: ${safeErrorMessage(err)}`);
+        // Fallback: create without id, then patch artifact_url once we know the server id.
+        try {
+            entity = await client.createEntity("artifact", {
+                name: input.name,
+                description: input.description ?? undefined,
+                artifact_type: input.artifact_type,
+                entity_type: input.entity_type,
+                entity_id: input.entity_id,
+                ...(initiativeIdHint ? { initiative_id: initiativeIdHint } : {}),
+                artifact_url: input.external_url ?? `${normalizeBaseUrl(baseUrl)}/artifacts/pending`,
+                status,
+                metadata,
+                ...createdBy,
+            });
+            created = true;
+        }
+        catch (inner) {
+            if (!isArtifactTypeConstraintError(inner)) {
+                throw inner;
+            }
+            warnings.push(`artifact_type rejected; retrying with shared.project_handbook`);
+            metadata.requested_artifact_type = input.artifact_type;
+            entity = await client.createEntity("artifact", {
+                name: input.name,
+                description: input.description ?? undefined,
+                artifact_type: "shared.project_handbook",
+                entity_type: input.entity_type,
+                entity_id: input.entity_id,
+                ...(initiativeIdHint ? { initiative_id: initiativeIdHint } : {}),
+                artifact_url: input.external_url ?? `${normalizeBaseUrl(baseUrl)}/artifacts/pending`,
+                status,
+                metadata,
+                ...createdBy,
+            });
+            created = true;
+        }
+    }
+    const artifactId = entity && typeof entity === "object" && typeof entity.id === "string"
+        ? String(entity.id)
+        : null;
+    let finalArtifactUrl = artifactId
+        ? `${normalizeBaseUrl(baseUrl)}/artifacts/${artifactId}`
+        : null;
+    if (artifactId) {
+        try {
+            await client.updateEntity("artifact", artifactId, {
+                artifact_url: finalArtifactUrl,
+            });
+        }
+        catch (err) {
+            warnings.push(`artifact_url patch failed: ${safeErrorMessage(err)}`);
+            // Keep whatever we sent originally.
+            finalArtifactUrl = typeof entity?.artifact_url === "string" ? entity.artifact_url : finalArtifactUrl;
+        }
+    }
+    const shouldValidate = input.validate_persistence === true;
+    const persistence = {
+        checked: false,
+        artifact_detail_ok: false,
+        linked_ok: false,
+        attempts: 0,
+        last_error: null,
+    };
+    if (shouldValidate && artifactId) {
+        persistence.checked = true;
+        const maxAttempts = 4;
+        for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+            persistence.attempts = attempt;
+            try {
+                const result = await validateArtifactPersistence(client, {
+                    artifactId,
+                    entity_type: input.entity_type,
+                    entity_id: input.entity_id,
+                });
+                persistence.artifact_detail_ok = result.artifact_detail_ok;
+                persistence.linked_ok = result.linked_ok;
+                if (result.artifact_detail_ok && result.linked_ok) {
+                    break;
+                }
+            }
+            catch (err) {
+                persistence.last_error = safeErrorMessage(err);
+            }
+            // quick backoff for eventual consistency
+            await sleep(250 * attempt);
+        }
+        if (!persistence.artifact_detail_ok || !persistence.linked_ok) {
+            warnings.push(`artifact persistence check failed (detail_ok=${persistence.artifact_detail_ok}, linked_ok=${persistence.linked_ok})`);
+        }
+    }
+    return {
+        ok: Boolean(artifactId),
+        artifact_id: artifactId,
+        artifact_url: finalArtifactUrl,
+        created,
+        persistence,
+        warnings,
+    };
+}