@yanolja-next/noya-sdk 0.1.0

package/dist/src/runner.js

@@ -0,0 +1,423 @@
+import fs from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import { spawn } from "node:child_process";
+import { redactValue } from "./redaction.js";
+export async function runOnce(config) {
+    const capabilities = config.capabilities ?? {
+        collect: { enabled: true },
+        fix: { enabled: true },
+    };
+    const nextUrl = new URL("/runner/jobs/next", config.server_url);
+    nextUrl.searchParams.set("project_key", config.project_key);
+    nextUrl.searchParams.set("runner_id", config.runner_id ?? "agency-platform-local-runner");
+    nextUrl.searchParams.set("capabilities", JSON.stringify(capabilities));
+    const auth = authHeader(config);
+    const next = await getJson(nextUrl, auth);
+    if (!next.job)
+        return { idle: true };
+    const job = next.job;
+    try {
+        const result = job.type === "collect" ? await collect(job, config) : await fix(job, config);
+        return await postJson(new URL(`/runner/jobs/${job.id}/complete`, config.server_url), result, auth);
+    }
+    catch (error) {
+        await postJson(new URL(`/runner/jobs/${job.id}/fail`, config.server_url), {
+            message: error instanceof Error ? error.message : String(error),
+        }, auth);
+        throw error;
+    }
+}
+async function collect(job, config) {
+    const report = job.payload.report;
+    const collectorPlan = job.payload.collector_plan;
+    const repoPath = config.repo_path ?? collectorPlan?.repo_path;
+    const context = {};
+    const policy = [];
+    for (const source of collectorPlan?.sources ?? []) {
+        const decision = evaluateSource(source, report);
+        policy.push(decision);
+        if (decision.decision !== "allow")
+            continue;
+        if (source.type === "fixture_logs") {
+            context.logs = limitBytes(limitEntries(collectFixtureLogs(report), source.max_entries), source.max_bytes);
+        }
+        else if (source.type === "fixture_domain") {
+            context.domain_snapshot = limitBytes(collectDomainSnapshot(report), source.max_bytes);
+        }
+        else if (source.type === "repo_snapshot") {
+            context.repo_snapshot = limitBytes(snapshotRepo(repoPath), source.max_bytes);
+        }
+        else if (source.type === "command_ref" && source.command_ref === "workspace_manifest_v1") {
+            context.workspace_manifest = limitBytes(snapshotRepo(repoPath), source.max_bytes);
+        }
+    }
+    return {
+        mode: "collect",
+        context: redactValue(context, { mode: "strict" }),
+        policy,
+        summary: "Runner collected redacted logs, domain hints, and repository metadata. No production writes were performed.",
+    };
+}
+function limitEntries(items, maxEntries) {
+    if (typeof maxEntries !== "number" || maxEntries < 0)
+        return items;
+    return items.slice(0, maxEntries);
+}
+function limitBytes(value, maxBytes) {
+    if (typeof maxBytes !== "number" || maxBytes < 0)
+        return value;
+    const json = JSON.stringify(value);
+    const bytes = Buffer.byteLength(json, "utf8");
+    if (bytes <= maxBytes)
+        return value;
+    return {
+        truncated: true,
+        original_bytes: bytes,
+        max_bytes: maxBytes,
+        preview: json.slice(0, maxBytes),
+    };
+}
+async function fix(job, config) {
+    const repoPath = path.resolve(config.repo_path ?? "/workspace/agency-platform");
+    const packageJson = path.join(repoPath, "package.json");
+    const changedFiles = [];
+    const tests = [];
+    const transcript = [
+        "Local fix mode prepared issue context for an approved command ref.",
+        "Push, deploy, merge, and production writes were intentionally skipped by Noya.",
+    ];
+    if (fs.existsSync(packageJson)) {
+        tests.push("Detected package.json; recommended verification: package-level focused tests before opening a real PR.");
+    }
+    const draftDir = path.resolve(config.artifact_dir ?? ".noya/artifacts/agency-platform", "agent-work", job.id);
+    fs.mkdirSync(draftDir, { recursive: true });
+    const contextPath = path.join(draftDir, "context.md");
+    const jobPath = path.join(draftDir, "job.json");
+    fs.writeFileSync(contextPath, String(job.payload.context_markdown ?? ""));
+    fs.writeFileSync(jobPath, `${JSON.stringify(job, null, 2)}\n`);
+    changedFiles.push(contextPath);
+    const branch = `noya/${job.issue_id}`;
+    const workspace = await prepareAgentWorkspace({
+        config,
+        repoPath,
+        draftDir,
+        branch,
+    });
+    tests.push(...workspace.tests);
+    transcript.push(...workspace.transcript);
+    const agentResult = await runFixAgent(config, {
+        cwd: workspace.cwd,
+        contextPath,
+        jobPath,
+        resultPath: path.join(draftDir, "agent-result.json"),
+    });
+    const checkoutChanges = await collectCheckoutChanges(workspace.checkoutPath, draftDir);
+    changedFiles.push(...(agentResult.changed_files ?? []));
+    changedFiles.push(...checkoutChanges.changedFiles);
+    tests.push(...(agentResult.tests ?? []));
+    tests.push(...checkoutChanges.tests);
+    if (workspace.checkoutPath)
+        changedFiles.push(workspace.checkoutPath);
+    return {
+        mode: "fix",
+        branch,
+        changed_files: [...new Set(changedFiles)],
+        tests,
+        transcript: [...transcript, agentResult.transcript, ...checkoutChanges.transcript]
+            .filter(Boolean)
+            .join("\n\n"),
+        checkout: workspace.checkoutPath
+            ? {
+                path: workspace.checkoutPath,
+                source_repo: repoPath,
+                branch,
+                status_artifact: checkoutChanges.statusPath,
+                patch_artifact: checkoutChanges.patchPath,
+            }
+            : null,
+        agent: agentResult.agent,
+    };
+}
+async function collectCheckoutChanges(checkoutPath, draftDir) {
+    if (!checkoutPath)
+        return { changedFiles: [], tests: [], transcript: [] };
+    const status = await spawnCommand("git", ["status", "--short", "--untracked-files=all"], {
+        cwd: checkoutPath,
+        timeoutMs: 30_000,
+        env: minimalEnv(),
+    });
+    const changedFiles = parseGitStatusFiles(status.stdout);
+    const statusPath = path.join(draftDir, "checkout-status.txt");
+    fs.writeFileSync(statusPath, status.stdout || "No checkout changes detected.\n");
+    let patchPath;
+    const diff = await spawnCommand("git", ["diff", "--", "."], {
+        cwd: checkoutPath,
+        timeoutMs: 30_000,
+        env: minimalEnv(),
+    });
+    if (diff.stdout.trim().length > 0) {
+        patchPath = path.join(draftDir, "checkout.diff.patch");
+        fs.writeFileSync(patchPath, diff.stdout);
+    }
+    return {
+        changedFiles: [statusPath, ...(patchPath ? [patchPath] : []), ...changedFiles],
+        tests: [`Detected ${changedFiles.length} checkout file change(s) after agent execution.`],
+        transcript: [
+            changedFiles.length > 0
+                ? `Checkout changes detected:\n${status.stdout.trim()}`
+                : "No checkout changes detected after agent execution.",
+        ],
+        statusPath,
+        patchPath,
+    };
+}
+function parseGitStatusFiles(status) {
+    return status
+        .split("\n")
+        .map((line) => line.trimEnd())
+        .filter(Boolean)
+        .map((line) => line.slice(3).trim())
+        .filter(Boolean);
+}
+async function prepareAgentWorkspace({ config, repoPath, draftDir, branch, }) {
+    const commandRef = config.agent?.fix?.command_ref;
+    if (!commandRef)
+        return { cwd: draftDir, tests: [], transcript: [] };
+    const checkoutPath = path.join(draftDir, "repo");
+    const gitDir = path.join(repoPath, ".git");
+    if (fs.existsSync(gitDir)) {
+        await spawnCommand("git", ["clone", "--local", "--no-hardlinks", "--quiet", repoPath, checkoutPath], {
+            cwd: draftDir,
+            timeoutMs: 60_000,
+            env: minimalEnv(),
+        });
+        await spawnCommand("git", ["checkout", "-b", branch], {
+            cwd: checkoutPath,
+            timeoutMs: 30_000,
+            env: minimalEnv(),
+        });
+        return {
+            cwd: checkoutPath,
+            checkoutPath,
+            tests: [`Prepared isolated git checkout at ${checkoutPath}.`],
+            transcript: [`Prepared isolated git checkout from ${repoPath} on branch ${branch}.`],
+        };
+    }
+    if (!fs.existsSync(repoPath)) {
+        return {
+            cwd: draftDir,
+            tests: [`Repo path unavailable; fix agent ran with context only: ${repoPath}`],
+            transcript: [`Repo path unavailable; isolated checkout was skipped: ${repoPath}.`],
+        };
+    }
+    fs.cpSync(repoPath, checkoutPath, {
+        recursive: true,
+        filter: (source) => !ignoredCheckoutPath(source),
+    });
+    return {
+        cwd: checkoutPath,
+        checkoutPath,
+        tests: [`Prepared isolated file checkout at ${checkoutPath}.`],
+        transcript: [`Prepared isolated file checkout from ${repoPath}.`],
+    };
+}
+function ignoredCheckoutPath(source) {
+    const parts = source.split(path.sep);
+    return !parts.some((part) => [".git", "node_modules", ".next", "dist", "build"].includes(part));
+}
+async function runFixAgent(config, jobFiles) {
+    const commandRef = config.agent?.fix?.command_ref;
+    if (!commandRef) {
+        return {
+            tests: ["No fix command_ref configured; generated local draft PR context only."],
+            transcript: "No fix agent command was configured.",
+            agent: { command_ref: null, decision: "skipped" },
+        };
+    }
+    const command = config.agent?.fix?.commands?.[commandRef];
+    if (!command) {
+        throw new Error(`Unregistered fix command_ref: ${commandRef}`);
+    }
+    if (!command.bin || command.bin.includes(" ")) {
+        throw new Error(`Invalid fix command for ${commandRef}: bin must be an executable, not a shell string`);
+    }
+    const execution = await spawnCommand(command.bin, command.args ?? [], {
+        cwd: jobFiles.cwd,
+        timeoutMs: command.timeout_ms ?? 30_000,
+        env: {
+            PATH: process.env.PATH ?? "",
+            NODE_PATH: process.env.NODE_PATH ?? "",
+            NOYA_CONTEXT_PATH: jobFiles.contextPath,
+            NOYA_JOB_PATH: jobFiles.jobPath,
+            NOYA_AGENT_RESULT_PATH: jobFiles.resultPath,
+            NOYA_REPO_PATH: jobFiles.cwd,
+        },
+    });
+    const resultPath = jobFiles.resultPath;
+    const result = fs.existsSync(resultPath)
+        ? JSON.parse(fs.readFileSync(resultPath, "utf8"))
+        : {};
+    return {
+        changed_files: result.changed_files ?? [],
+        tests: result.tests ?? [],
+        transcript: [
+            result.transcript,
+            execution.stdout ? `stdout:\n${execution.stdout}` : "",
+            execution.stderr ? `stderr:\n${execution.stderr}` : "",
+        ]
+            .filter(Boolean)
+            .join("\n\n"),
+        agent: {
+            command_ref: commandRef,
+            exit_code: execution.exitCode,
+            cwd: jobFiles.cwd,
+        },
+    };
+}
+function minimalEnv() {
+    return {
+        PATH: process.env.PATH ?? "",
+        NODE_PATH: process.env.NODE_PATH ?? "",
+    };
+}
+async function spawnCommand(bin, args, options) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(bin, args, {
+            cwd: options.cwd,
+            env: options.env,
+            shell: false,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let stdout = "";
+        let stderr = "";
+        const timer = setTimeout(() => {
+            child.kill("SIGKILL");
+            reject(new Error(`Fix command timed out after ${options.timeoutMs}ms`));
+        }, options.timeoutMs);
+        child.stdout.on("data", (chunk) => {
+            stdout += String(chunk);
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += String(chunk);
+        });
+        child.on("error", (error) => {
+            clearTimeout(timer);
+            reject(error);
+        });
+        child.on("close", (code) => {
+            clearTimeout(timer);
+            if (code !== 0) {
+                reject(new Error(`Fix command exited with ${code}: ${stderr || stdout}`));
+                return;
+            }
+            resolve({ exitCode: code ?? 0, stdout, stderr });
+        });
+    });
+}
+function collectFixtureLogs(report) {
+    return [
+        {
+            severity: "ERROR",
+            request_id: report.request_id ?? report.hints?.request_id,
+            message: "Reserve validation rejected incomplete booker nationality state.",
+        },
+        {
+            severity: "WARNING",
+            trace_id: report.hints?.trace_id ?? "trace-local-fixture",
+            message: "Frontend submitted reservation precheck with stale form completeness.",
+        },
+    ];
+}
+function collectDomainSnapshot(report) {
+    return {
+        trip_id: report.hints?.trip_id,
+        booking_id: report.hints?.booking_id,
+        tenant_id: report.hints?.tenant_id,
+        reservation_state: "blocked_before_supplier_hold",
+        pii_note: "Fixture domain snapshot is redacted before upload.",
+    };
+}
+function snapshotRepo(repoPath) {
+    const normalizedPath = typeof repoPath === "string" ? repoPath : undefined;
+    if (!normalizedPath || !fs.existsSync(normalizedPath)) {
+        return { available: false, reason: "repo path unavailable", repo_path: normalizedPath ?? null };
+    }
+    return {
+        available: true,
+        repo_path: normalizedPath,
+        package_json: fs.existsSync(path.join(normalizedPath, "package.json")),
+        git_dir: fs.existsSync(path.join(normalizedPath, ".git")),
+    };
+}
+function evaluateSource(source, report) {
+    if ("command" in source || "sql" in source) {
+        return {
+            source: source.name,
+            decision: "deny",
+            reason: "raw command or raw SQL collectors are not allowed",
+        };
+    }
+    if (!["fixture_logs", "fixture_domain", "repo_snapshot", "command_ref"].includes(source.type)) {
+        return {
+            source: source.name,
+            decision: "deny",
+            reason: `unsupported collector type: ${String(source.type)}`,
+        };
+    }
+    if (source.type === "command_ref" && source.command_ref !== "workspace_manifest_v1") {
+        return {
+            source: source.name,
+            decision: "deny",
+            reason: `unregistered command_ref: ${String(source.command_ref)}`,
+        };
+    }
+    const requiredHint = source.when?.has;
+    if (requiredHint && !report.hints?.[requiredHint]) {
+        return {
+            source: source.name,
+            decision: "skip",
+            reason: `missing hint: ${requiredHint}`,
+        };
+    }
+    return {
+        source: source.name,
+        decision: "allow",
+    };
+}
+async function getJson(url, authorization) {
+    const response = await fetch(url, authorization ? { headers: { authorization } } : undefined);
+    if (!response.ok)
+        throw new Error(`GET ${url} failed: ${response.status}`);
+    return response.json();
+}
+async function postJson(url, body, authorization) {
+    const response = await fetch(url, {
+        method: "POST",
+        headers: { "content-type": "application/json", ...(authorization ? { authorization } : {}) },
+        body: JSON.stringify(body),
+    });
+    if (!response.ok)
+        throw new Error(`POST ${url} failed: ${response.status}`);
+    return response.json();
+}
+function authHeader(config) {
+    const token = config.token ?? (config.token_env ? process.env[config.token_env] : undefined);
+    return token ? `Bearer ${token}` : undefined;
+}
+function loadConfig(filePath) {
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+}
+if (import.meta.url === `file://${process.argv[1]}`) {
+    const configPath = process.argv[2] ?? "examples/agency-platform/noya.runner.json";
+    const config = loadConfig(configPath);
+    const interval = Number(process.env.NOYA_RUNNER_INTERVAL_MS ?? 0);
+    if (interval > 0) {
+        setInterval(() => {
+            runOnce(config).catch((error) => console.error(error));
+        }, interval);
+    }
+    else {
+        runOnce(config).then((result) => console.log(JSON.stringify(result, null, 2)));
+    }
+}

package/dist/src/sdk.d.ts

@@ -0,0 +1,64 @@
+type ContextProvider = {
+    name: string;
+    collect: () => unknown | Promise<unknown>;
+    redact?: "strict" | "none";
+};
+type NoyaConfig = {
+    projectKey: string;
+    endpoint?: string;
+    environment?: string;
+    release?: string;
+    contextProviders?: ContextProvider[];
+    autoCaptureNetwork?: boolean;
+    recording?: {
+        client?: {
+            init?: (options: Record<string, unknown>) => void;
+            setTag?: (key: string, value: string) => void;
+            setContext?: (key: string, value: Record<string, unknown>) => void;
+        };
+        initOptions?: Record<string, unknown>;
+        replayIntegration?: false | unknown | (() => unknown);
+        feedbackIntegration?: false | unknown | (() => unknown);
+    };
+    sentry?: {
+        client?: {
+            init?: (options: Record<string, unknown>) => void;
+            setTag?: (key: string, value: string) => void;
+            setContext?: (key: string, value: Record<string, unknown>) => void;
+        };
+        initOptions?: Record<string, unknown>;
+        replayIntegration?: false | unknown | (() => unknown);
+        feedbackIntegration?: false | unknown | (() => unknown);
+    };
+};
+type ReportInput = {
+    reportId?: string;
+    message?: string;
+    impact?: string;
+    expectedBehavior?: string;
+    actualBehavior?: string;
+    reproductionSteps?: string[];
+    requestId?: string;
+    route?: string;
+    telemetry?: unknown;
+    sentry?: unknown;
+    feedback?: unknown;
+    screenshotUrl?: string;
+};
+declare global {
+    interface Window {
+        Noya?: {
+            initNoya: typeof initNoya;
+        };
+    }
+}
+export declare function initNoya(config: NoyaConfig): {
+    reportIssue: (input: ReportInput) => Promise<unknown>;
+    sessionId: string;
+    getCorrelation: () => {
+        request_id?: string;
+        trace_id?: string;
+        traceparent?: string;
+    };
+};
+export {};

package/dist/src/sdk.js

@@ -0,0 +1,172 @@
+import { redactValue } from "./redaction.js";
+export function initNoya(config) {
+    if (!config?.projectKey)
+        throw new Error("initNoya requires projectKey");
+    const endpoint = config.endpoint ?? "/api/reports";
+    const contextProviders = config.contextProviders ?? [];
+    const sessionId = stableSessionId();
+    const correlation = {};
+    if (config.autoCaptureNetwork !== false) {
+        installFetchInterceptor(correlation);
+        installXhrInterceptor(correlation);
+    }
+    const recording = config.recording ?? config.sentry;
+    recording?.client?.init?.(recordingInitOptions(config));
+    recording?.client?.setTag?.("noya.project_key", config.projectKey);
+    recording?.client?.setTag?.("noya.session_id", sessionId);
+    async function collectContext() {
+        const values = {};
+        for (const provider of contextProviders) {
+            try {
+                values[provider.name] = redactValue(await provider.collect(), {
+                    mode: provider.redact ?? "strict",
+                });
+            }
+            catch (error) {
+                values[provider.name] = {
+                    error: error instanceof Error ? error.message : String(error),
+                };
+            }
+        }
+        return values;
+    }
+    async function reportIssue(input) {
+        const context = await collectContext();
+        recording?.client?.setContext?.("noya_report", {
+            project_key: config.projectKey,
+            session_id: sessionId,
+            route: input.route ?? globalThis.location?.pathname,
+            request_id: input.requestId ?? correlation.request_id,
+            trace_id: correlation.trace_id,
+        });
+        const envelope = redactValue({
+            report_id: input.reportId ?? crypto.randomUUID(),
+            project_key: config.projectKey,
+            session_id: sessionId,
+            environment: config.environment,
+            release: config.release,
+            route: input.route ?? globalThis.location?.pathname,
+            browser: globalThis.navigator?.userAgent,
+            message: input.message,
+            impact: input.impact,
+            expected_behavior: input.expectedBehavior,
+            actual_behavior: input.actualBehavior,
+            reproduction_steps: input.reproductionSteps,
+            request_id: input.requestId ?? correlation.request_id,
+            trace_id: correlation.trace_id,
+            traceparent: correlation.traceparent,
+            telemetry: input.telemetry ?? input.sentry,
+            sentry: input.sentry,
+            feedback: input.feedback,
+            screenshot_url: input.screenshotUrl,
+            context,
+        }, { mode: "strict" });
+        const response = await fetch(endpoint, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify(envelope),
+        });
+        if (!response.ok)
+            throw new Error(`Noya report failed: ${response.status}`);
+        return response.json();
+    }
+    return {
+        reportIssue,
+        sessionId,
+        getCorrelation: () => ({ ...correlation }),
+    };
+}
+if (typeof window !== "undefined") {
+    window.Noya = { initNoya };
+}
+function recordingInitOptions(config) {
+    const recording = config.recording ?? config.sentry;
+    const initOptions = {
+        ...(recording?.initOptions ?? {}),
+        environment: config.environment,
+        release: config.release,
+    };
+    const additions = [
+        resolveIntegration(recording?.replayIntegration),
+        resolveIntegration(recording?.feedbackIntegration),
+    ].filter((value) => value !== undefined);
+    if (additions.length === 0)
+        return initOptions;
+    const existing = initOptions.integrations;
+    if (Array.isArray(existing)) {
+        return { ...initOptions, integrations: [...existing, ...additions] };
+    }
+    if (typeof existing === "function") {
+        return {
+            ...initOptions,
+            integrations: (...args) => [...arrayFromIntegrationResult(existing(...args)), ...additions],
+        };
+    }
+    return { ...initOptions, integrations: additions };
+}
+function resolveIntegration(value) {
+    if (!value)
+        return undefined;
+    return typeof value === "function" ? value() : value;
+}
+function arrayFromIntegrationResult(value) {
+    return Array.isArray(value) ? value : value ? [value] : [];
+}
+function stableSessionId() {
+    const storageKey = "noya.session_id";
+    try {
+        const existing = globalThis.sessionStorage?.getItem(storageKey);
+        if (existing)
+            return existing;
+        const next = `noya_sess_${randomId()}`;
+        globalThis.sessionStorage?.setItem(storageKey, next);
+        return next;
+    }
+    catch {
+        return `noya_sess_${randomId()}`;
+    }
+}
+function randomId() {
+    return globalThis.crypto?.randomUUID?.() ?? Math.random().toString(36).slice(2);
+}
+let fetchInstalled = false;
+function installFetchInterceptor(correlation) {
+    if (fetchInstalled || typeof globalThis.fetch !== "function")
+        return;
+    fetchInstalled = true;
+    const originalFetch = globalThis.fetch.bind(globalThis);
+    globalThis.fetch = async (input, init) => {
+        const response = await originalFetch(input, init);
+        captureHeaders(correlation, response.headers);
+        return response;
+    };
+}
+let xhrInstalled = false;
+function installXhrInterceptor(correlation) {
+    if (xhrInstalled || typeof globalThis.XMLHttpRequest === "undefined")
+        return;
+    xhrInstalled = true;
+    const proto = globalThis.XMLHttpRequest.prototype;
+    const originalOpen = proto.open;
+    const originalSend = proto.send;
+    proto.open = function open(...args) {
+        this.addEventListener("loadend", () => {
+            captureHeaderValue(correlation, "request_id", this.getResponseHeader("x-request-id"));
+            captureHeaderValue(correlation, "trace_id", this.getResponseHeader("x-trace-id"));
+            captureHeaderValue(correlation, "traceparent", this.getResponseHeader("traceparent"));
+        });
+        return originalOpen.apply(this, args);
+    };
+    proto.send = function send(...args) {
+        return originalSend.apply(this, args);
+    };
+}
+function captureHeaders(correlation, headers) {
+    captureHeaderValue(correlation, "request_id", headers.get("x-request-id"));
+    captureHeaderValue(correlation, "trace_id", headers.get("x-trace-id"));
+    captureHeaderValue(correlation, "traceparent", headers.get("traceparent"));
+}
+function captureHeaderValue(correlation, key, value) {
+    if (value)
+        correlation[key] = value;
+}

package/dist/src/sentry.d.ts

@@ -0,0 +1,7 @@
+import type { Project, Report } from "./types.js";
+export declare function fetchSentryEventContext(project: Project, sentry: Report["sentry"]): Promise<Partial<Report>>;
+export declare function verifySentryWebhookSignature({ project, rawBody, signature, }: {
+    project: Project;
+    rawBody: string;
+    signature: string | undefined;
+}): void;