@rose42/t3-feedback 0.1.0

package/dist/client/ui/shortcuts.d.ts

@@ -0,0 +1,32 @@
+import { type T3FeedbackShortcutConfig, type T3FeedbackShortcutOptions } from "../../types.js";
+import { type FeedbackReportType } from "../reportType.js";
+import type { T3FeedbackShortcutRunContext } from "./host.js";
+export type { T3FeedbackShortcutRunContext } from "./host.js";
+/**
+ * Shortcut chord a plugin registers with the host.
+ * Matched globally via {@link shouldOpenFromShortcut}.
+ */
+export type T3FeedbackPluginShortcut = {
+    id: string;
+    shortcut: T3FeedbackShortcutOptions;
+    reportTypes?: readonly FeedbackReportType[];
+    run: (ctx: T3FeedbackShortcutRunContext) => void | Promise<void>;
+};
+/** Resolved shortcut ready for the host keydown loop. */
+export type T3FeedbackRegisteredShortcut = {
+    id: string;
+    shortcut: T3FeedbackShortcutConfig;
+    reportTypes?: readonly FeedbackReportType[];
+    run: (ctx: T3FeedbackShortcutRunContext) => void | Promise<void>;
+};
+type PluginWithShortcuts = {
+    shortcuts?: T3FeedbackPluginShortcut | readonly T3FeedbackPluginShortcut[];
+};
+/** Collect `shortcuts` declarations from capture plugins. */
+export declare function collectPluginShortcuts(plugins: readonly PluginWithShortcuts[]): T3FeedbackPluginShortcut[];
+/** Resolve plugin shortcut options into host-ready entries. */
+export declare function resolvePluginShortcuts(plugins: readonly PluginWithShortcuts[]): T3FeedbackRegisteredShortcut[];
+/**
+ * First matching shortcut wins (`preventDefault` is the caller's responsibility).
+ */
+export declare function matchRegisteredShortcut(event: Pick<KeyboardEvent, "key" | "ctrlKey" | "metaKey" | "shiftKey" | "altKey" | "target">, shortcuts: readonly T3FeedbackRegisteredShortcut[], reportType: FeedbackReportType): T3FeedbackRegisteredShortcut | undefined;

package/dist/client/ui/shortcuts.js

@@ -0,0 +1,40 @@
+import { resolveShortcut, shouldOpenFromShortcut, } from "../../types.js";
+import { pluginAppliesToReportType } from "../reportType.js";
+function normalizeShortcutList(value) {
+    if (value == null)
+        return [];
+    const list = Array.isArray(value) ? value : [value];
+    return [...list];
+}
+/** Collect `shortcuts` declarations from capture plugins. */
+export function collectPluginShortcuts(plugins) {
+    const out = [];
+    for (const plugin of plugins) {
+        out.push(...normalizeShortcutList(plugin.shortcuts));
+    }
+    return out;
+}
+/** Resolve plugin shortcut options into host-ready entries. */
+export function resolvePluginShortcuts(plugins) {
+    return collectPluginShortcuts(plugins).map((entry) => ({
+        id: entry.id,
+        shortcut: resolveShortcut(entry.shortcut),
+        ...(entry.reportTypes ? { reportTypes: entry.reportTypes } : {}),
+        run: entry.run,
+    }));
+}
+/**
+ * First matching shortcut wins (`preventDefault` is the caller's responsibility).
+ */
+export function matchRegisteredShortcut(event, shortcuts, reportType) {
+    for (const entry of shortcuts) {
+        if (entry.reportTypes &&
+            !pluginAppliesToReportType({ reportTypes: entry.reportTypes }, reportType)) {
+            continue;
+        }
+        if (shouldOpenFromShortcut(event, entry.shortcut)) {
+            return entry;
+        }
+    }
+    return undefined;
+}

package/dist/client/ui/slots.d.ts

@@ -0,0 +1,73 @@
+import type { FeedbackCapturePlugin } from "@rose42/feedback-capture";
+import type { FeedbackReportType } from "../reportType.js";
+import type { T3FeedbackUiContext } from "./host.js";
+import type { T3FeedbackPluginShortcut } from "./shortcuts.js";
+export type { FeedbackReportType };
+export type { T3FeedbackUiContext } from "./host.js";
+/**
+ * Shared panel regions plugins may register into.
+ * Shell owns FAB + send-action cluster only; panel body is slot-hosted plugins.
+ */
+export type T3FeedbackUiSlot = "beforeComment" | "comment" | "attachments" | "actionsTools";
+export declare const T3_FEEDBACK_UI_SLOTS: readonly T3FeedbackUiSlot[];
+export type T3FeedbackUiMountResult = {
+    dispose?: () => void;
+    /** Optional imperative handle for the shell (draft restore, focus). */
+    api?: unknown;
+};
+/**
+ * A UI fragment owned by a plugin (or built-in) and mounted into a shared slot.
+ */
+export type T3FeedbackUiContribution = {
+    id: string;
+    slot: T3FeedbackUiSlot;
+    /** Lower first. Default: `0`. */
+    order?: number;
+    /** When set, host hides this contribution outside these report types. */
+    reportTypes?: readonly FeedbackReportType[];
+    mount: (container: HTMLElement, ctx: T3FeedbackUiContext) => void | (() => void) | T3FeedbackUiMountResult;
+};
+/** Capture plugin that may also register overlay UI and/or shortcut chords. */
+export type FeedbackCapturePluginWithUi = FeedbackCapturePlugin & {
+    /**
+     * Optional human label for the panel.
+     * When set without `ui`, auto-registers a live preview chip in `beforeComment`.
+     */
+    label?: string;
+    /**
+     * When set, only collect (and show gated UI/shortcuts) for these report types
+     * (omit = all report types).
+     */
+    reportTypes?: readonly FeedbackReportType[];
+    ui?: T3FeedbackUiContribution | readonly T3FeedbackUiContribution[];
+    /**
+     * Global keyboard chords owned by this plugin.
+     * Registered for the lifetime of the feedback mount (panel open or closed).
+     */
+    shortcuts?: T3FeedbackPluginShortcut | readonly T3FeedbackPluginShortcut[];
+};
+export type MountedUiContribution = {
+    id: string;
+    slot: T3FeedbackUiSlot;
+    host: HTMLElement;
+    api?: unknown;
+    dispose: () => void;
+};
+/** Sort contributions for stable mount order within and across slots. */
+export declare function sortUiContributions(contributions: readonly T3FeedbackUiContribution[]): T3FeedbackUiContribution[];
+/**
+ * Mount contributions into `[data-slot="…"]` hosts under `root`.
+ */
+export declare function mountSlotContributions(root: ParentNode, contributions: readonly T3FeedbackUiContribution[], ctx: T3FeedbackUiContext): {
+    mounted: MountedUiContribution[];
+    dispose: () => void;
+    syncReportType: (type: FeedbackReportType) => void;
+};
+/** Collect explicit `ui` contributions from capture plugins. */
+export declare function collectPluginUiContributions(plugins: readonly FeedbackCapturePluginWithUi[]): T3FeedbackUiContribution[];
+/**
+ * Plugins with `label` and no `ui` get an auto preview contribution in `beforeComment`.
+ */
+export declare function pluginsNeedingLabelPreview(plugins: readonly FeedbackCapturePluginWithUi[]): Array<FeedbackCapturePluginWithUi & {
+    label: string;
+}>;

package/dist/client/ui/slots.js

@@ -0,0 +1,112 @@
+export const T3_FEEDBACK_UI_SLOTS = [
+    "beforeComment",
+    "comment",
+    "attachments",
+    "actionsTools",
+];
+function normalizeMountResult(result) {
+    if (typeof result === "function") {
+        return { dispose: result };
+    }
+    if (result && typeof result === "object") {
+        return {
+            dispose: result.dispose ?? (() => undefined),
+            ...(result.api !== undefined ? { api: result.api } : {}),
+        };
+    }
+    return { dispose: () => undefined };
+}
+function contributionVisible(contribution, reportType) {
+    const allowed = contribution.reportTypes;
+    if (!allowed || allowed.length === 0)
+        return true;
+    return allowed.includes(reportType);
+}
+/** Sort contributions for stable mount order within and across slots. */
+export function sortUiContributions(contributions) {
+    return [...contributions].sort((a, b) => {
+        const slotDelta = T3_FEEDBACK_UI_SLOTS.indexOf(a.slot) - T3_FEEDBACK_UI_SLOTS.indexOf(b.slot);
+        if (slotDelta !== 0)
+            return slotDelta;
+        const orderDelta = (a.order ?? 0) - (b.order ?? 0);
+        if (orderDelta !== 0)
+            return orderDelta;
+        return a.id.localeCompare(b.id);
+    });
+}
+/**
+ * Mount contributions into `[data-slot="…"]` hosts under `root`.
+ */
+export function mountSlotContributions(root, contributions, ctx) {
+    const mounted = [];
+    const unsubReport = ctx.subscribeReportType((type) => {
+        for (const entry of mounted) {
+            const contrib = contributions.find((c) => c.id === entry.id);
+            if (!contrib)
+                continue;
+            entry.host.hidden = !contributionVisible(contrib, type);
+        }
+    });
+    for (const contribution of sortUiContributions(contributions)) {
+        const slotEl = root.querySelector(`[data-slot="${contribution.slot}"]`);
+        if (!(slotEl instanceof HTMLElement))
+            continue;
+        const host = document.createElement("div");
+        host.dataset.uiId = contribution.id;
+        host.hidden = !contributionVisible(contribution, ctx.getReportType());
+        slotEl.append(host);
+        const { dispose, api } = normalizeMountResult(contribution.mount(host, ctx));
+        mounted.push({
+            id: contribution.id,
+            slot: contribution.slot,
+            host,
+            ...(api !== undefined ? { api } : {}),
+            dispose,
+        });
+    }
+    return {
+        mounted,
+        syncReportType: (type) => {
+            for (const entry of mounted) {
+                const contrib = contributions.find((c) => c.id === entry.id);
+                if (!contrib)
+                    continue;
+                entry.host.hidden = !contributionVisible(contrib, type);
+            }
+        },
+        dispose: () => {
+            unsubReport();
+            for (let i = mounted.length - 1; i >= 0; i--) {
+                try {
+                    mounted[i].dispose();
+                }
+                catch {
+                    // ignore
+                }
+            }
+            mounted.length = 0;
+        },
+    };
+}
+/** Collect explicit `ui` contributions from capture plugins. */
+export function collectPluginUiContributions(plugins) {
+    const out = [];
+    for (const plugin of plugins) {
+        const ui = plugin.ui;
+        if (!ui)
+            continue;
+        if (Array.isArray(ui)) {
+            out.push(...ui);
+        }
+        else {
+            out.push(ui);
+        }
+    }
+    return out;
+}
+/**
+ * Plugins with `label` and no `ui` get an auto preview contribution in `beforeComment`.
+ */
+export function pluginsNeedingLabelPreview(plugins) {
+    return plugins.filter((plugin) => typeof plugin.label === "string" && plugin.label.trim().length > 0 && plugin.ui === undefined);
+}

package/dist/controls.d.ts

@@ -0,0 +1,8 @@
+/** Dispatched on `window` to open the mounted feedback panel. */
+export declare const T3_FEEDBACK_OPEN_EVENT = "t3-feedback:open";
+/** Dispatched on `window` to close the mounted feedback panel. */
+export declare const T3_FEEDBACK_CLOSE_EVENT = "t3-feedback:close";
+/** Open the feedback panel (no-op if the client is not mounted). */
+export declare function openT3Feedback(): void;
+/** Close the feedback panel (no-op if the client is not mounted). */
+export declare function closeT3Feedback(): void;

package/dist/controls.js

@@ -0,0 +1,16 @@
+/** Dispatched on `window` to open the mounted feedback panel. */
+export const T3_FEEDBACK_OPEN_EVENT = "t3-feedback:open";
+/** Dispatched on `window` to close the mounted feedback panel. */
+export const T3_FEEDBACK_CLOSE_EVENT = "t3-feedback:close";
+/** Open the feedback panel (no-op if the client is not mounted). */
+export function openT3Feedback() {
+    if (typeof window === "undefined")
+        return;
+    window.dispatchEvent(new CustomEvent(T3_FEEDBACK_OPEN_EVENT));
+}
+/** Close the feedback panel (no-op if the client is not mounted). */
+export function closeT3Feedback() {
+    if (typeof window === "undefined")
+        return;
+    window.dispatchEvent(new CustomEvent(T3_FEEDBACK_CLOSE_EVENT));
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { t3FeedbackPlugin, T3_FEEDBACK_API_PATH, T3_FEEDBACK_OPEN_PATH, T3_FEEDBACK_SETTLE_PATH, T3_FEEDBACK_THREADS_PATH, default, } from "./plugin.js";
+export type { FeedbackSendResult, ThreadListItem, ThreadProbeResult, ThreadProbeState, ThreadSettleResult, ThreadsListResponse, ThreadsProbeResponse, ThreadsSettleResponse, T3BuiltinPluginId, T3FeedbackAfterPick, T3FeedbackBuiltinPluginOptions, T3FeedbackClientConfig, T3FeedbackFabConfig, T3FeedbackFabOptions, T3FeedbackFabPosition, T3FeedbackFabVisibility, T3FeedbackOpenHandoff, T3FeedbackOpenInEditorConfig, T3FeedbackOpenInEditorOptions, T3FeedbackPickConfig, T3FeedbackPickOptions, T3FeedbackPluginOptions, T3FeedbackRecordConfig, T3FeedbackRecordOptions, T3FeedbackReportTypeGlyph, T3FeedbackReportTypeGlyphCustom, T3FeedbackReportTypeGlyphMap, T3FeedbackReportTypeGlyphResolved, T3FeedbackScreenshotConfig, T3FeedbackScreenshotCrop, T3FeedbackScreenshotOptions, T3FeedbackShortcutConfig, T3FeedbackShortcutOptions, T3FeedbackThreadReuse, } from "./types.js";
+export { DEFAULT_FAB_CONFIG, DEFAULT_OPEN_IN_EDITOR_ENDPOINT, DEFAULT_PICK_SHORTCUT, DEFAULT_RECORD_SHORTCUT, DEFAULT_REPORT_TYPE_EMOJIS, DEFAULT_REPORT_TYPE_GLYPH, DEFAULT_SCREENSHOT_SHORTCUT, DEFAULT_SHORTCUT, T3_BUILTIN_PLUGIN_IDS, formatShortcutLabel, isEditableKeyboardTarget, matchesBareKeyOverride, matchesShortcut, resolveActivePluginList, resolveActivePlugins, resolveFabConfig, resolveOpenInEditorConfig, resolvePickConfig, resolveRecordConfig, resolveReportTypeGlyph, resolveScreenshotConfig, resolveShortcut, shortcutRequiresModifier, shouldOpenFromShortcut, } from "./types.js";

package/dist/index.js

@@ -0,0 +1,2 @@
+export { t3FeedbackPlugin, T3_FEEDBACK_API_PATH, T3_FEEDBACK_OPEN_PATH, T3_FEEDBACK_SETTLE_PATH, T3_FEEDBACK_THREADS_PATH, default, } from "./plugin.js";
+export { DEFAULT_FAB_CONFIG, DEFAULT_OPEN_IN_EDITOR_ENDPOINT, DEFAULT_PICK_SHORTCUT, DEFAULT_RECORD_SHORTCUT, DEFAULT_REPORT_TYPE_EMOJIS, DEFAULT_REPORT_TYPE_GLYPH, DEFAULT_SCREENSHOT_SHORTCUT, DEFAULT_SHORTCUT, T3_BUILTIN_PLUGIN_IDS, formatShortcutLabel, isEditableKeyboardTarget, matchesBareKeyOverride, matchesShortcut, resolveActivePluginList, resolveActivePlugins, resolveFabConfig, resolveOpenInEditorConfig, resolvePickConfig, resolveRecordConfig, resolveReportTypeGlyph, resolveScreenshotConfig, resolveShortcut, shortcutRequiresModifier, shouldOpenFromShortcut, } from "./types.js";

package/dist/plugin.d.ts

@@ -0,0 +1,9 @@
+import type { Plugin } from "vite";
+import { type T3FeedbackPluginOptions } from "./types.js";
+export { T3_FEEDBACK_API_PATH, T3_FEEDBACK_OPEN_PATH, T3_FEEDBACK_SETTLE_PATH, T3_FEEDBACK_THREADS_PATH, } from "./bridge/paths.js";
+export { parseFeedbackPost, parseOpenHandoffRequest, parseSettlePost, parseThreadProbeIds, } from "./bridge/parse.js";
+/** Resolve a `customPlugins` entry against the Vite project root (bare ids stay bare). */
+export declare function resolveCustomPluginModuleId(entry: string, root: string): string;
+/** Vite plugin that exposes POST /__t3-feedback and bridges envelopes to T3. */
+export declare function t3FeedbackPlugin(options?: T3FeedbackPluginOptions): Plugin;
+export default t3FeedbackPlugin;

package/dist/plugin.js

@@ -0,0 +1,186 @@
+import path from "node:path";
+import { normalizePath } from "vite";
+import { handleT3FeedbackRequest } from "./bridge/http.js";
+import { T3_FEEDBACK_API_PATH } from "./bridge/paths.js";
+import { resolveActivePluginList, resolveFabConfig, resolvePickConfig, resolveRecordConfig, resolveReportTypeGlyph, resolveScreenshotConfig, resolveShortcut, } from "./types.js";
+export { T3_FEEDBACK_API_PATH, T3_FEEDBACK_OPEN_PATH, T3_FEEDBACK_SETTLE_PATH, T3_FEEDBACK_THREADS_PATH, } from "./bridge/paths.js";
+export { parseFeedbackPost, parseOpenHandoffRequest, parseSettlePost, parseThreadProbeIds, } from "./bridge/parse.js";
+/** Resolve a `customPlugins` entry against the Vite project root (bare ids stay bare). */
+export function resolveCustomPluginModuleId(entry, root) {
+    const trimmed = entry.trim();
+    if (!trimmed)
+        return trimmed;
+    if (path.isAbsolute(trimmed) || trimmed.startsWith("\0"))
+        return normalizePath(trimmed);
+    if (trimmed.startsWith(".")) {
+        return normalizePath(path.resolve(root, trimmed));
+    }
+    return trimmed;
+}
+function resolvePluginOptions(options) {
+    if (!options)
+        return undefined;
+    const maxEntries = options.consoleLogs?.maxEntries;
+    if (maxEntries === undefined || !Number.isFinite(maxEntries)) {
+        return Object.keys(options).length > 0 ? options : undefined;
+    }
+    return {
+        ...options,
+        consoleLogs: {
+            ...options.consoleLogs,
+            maxEntries: Math.max(1, Math.floor(maxEntries)),
+        },
+    };
+}
+const DEFAULT_THREAD_REUSE = "ask";
+const VIRTUAL_CLIENT_ID = "virtual:t3-feedback-client";
+const RESOLVED_VIRTUAL_CLIENT_ID = `\0${VIRTUAL_CLIENT_ID}`;
+/** Browser-safe URL for the virtual module (bare `virtual:` is not a fetchable scheme). */
+const VIRTUAL_CLIENT_URL = `/@id/${VIRTUAL_CLIENT_ID}`;
+function readRawBody(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        req.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
+        req.on("end", () => resolve(Buffer.concat(chunks)));
+        req.on("error", reject);
+    });
+}
+async function connectRequestToFetch(req) {
+    const url = req.url ?? "/";
+    const method = req.method ?? "GET";
+    const headers = new Headers();
+    for (const [key, value] of Object.entries(req.headers ?? {})) {
+        if (value === undefined)
+            continue;
+        if (Array.isArray(value)) {
+            for (const item of value)
+                headers.append(key, item);
+        }
+        else {
+            headers.set(key, value);
+        }
+    }
+    const init = { method, headers };
+    if (method !== "GET" && method !== "HEAD") {
+        const raw = await readRawBody(req);
+        if (raw.length > 0) {
+            init.body = Uint8Array.from(raw);
+        }
+    }
+    return new Request(`http://vite.local${url}`, init);
+}
+async function writeFetchResponse(res, response) {
+    res.statusCode = response.status;
+    response.headers.forEach((value, key) => {
+        res.setHeader(key, value);
+    });
+    const buf = Buffer.from(await response.arrayBuffer());
+    res.end(buf);
+}
+/** Vite plugin that exposes POST /__t3-feedback and bridges envelopes to T3. */
+export function t3FeedbackPlugin(options = {}) {
+    const threadTitlePrefix = options.threadTitle?.trim() || undefined;
+    const workspaceRootHints = options.workspaceRootHints;
+    const injectClient = options.injectClient !== false;
+    const threadReuse = options.threadReuse ?? DEFAULT_THREAD_REUSE;
+    const reportTypeGlyph = resolveReportTypeGlyph(options.reportTypeGlyph);
+    const pickConfig = resolvePickConfig(options.pick);
+    const version = options.version?.trim() || undefined;
+    const pluginOptions = resolvePluginOptions(options.pluginOptions);
+    const clientConfig = {
+        shortcut: resolveShortcut(options.shortcut, options.shortcutKey),
+        endpoint: T3_FEEDBACK_API_PATH,
+        fab: resolveFabConfig(options.fab),
+        threadReuse,
+        pick: pickConfig,
+        screenshot: resolveScreenshotConfig(options.screenshot, pickConfig.cropPaddingPx),
+        record: resolveRecordConfig(options.record),
+        reportTypeGlyph,
+        activePlugins: resolveActivePluginList(options.activePlugins),
+        ...(pluginOptions ? { pluginOptions } : {}),
+        ...(version ? { version } : {}),
+    };
+    let viteRoot = process.cwd();
+    const customPluginEntries = (options.customPlugins ?? [])
+        .map((entry) => (typeof entry === "string" ? entry.trim() : ""))
+        .filter(Boolean);
+    const bridgeServerOptions = {
+        basePath: T3_FEEDBACK_API_PATH,
+        ...(options.origin ? { origin: options.origin } : {}),
+        ...(options.openOrigin ? { openOrigin: options.openOrigin } : {}),
+        ...(workspaceRootHints ? { workspaceRootHints } : {}),
+        ...(threadTitlePrefix ? { threadTitlePrefix } : {}),
+        reportTypeGlyph,
+    };
+    return {
+        name: "t3-feedback",
+        apply: "serve",
+        configResolved(config) {
+            viteRoot = config.root;
+        },
+        resolveId(id) {
+            if (id === VIRTUAL_CLIENT_ID)
+                return RESOLVED_VIRTUAL_CLIENT_ID;
+        },
+        load(id) {
+            if (id !== RESOLVED_VIRTUAL_CLIENT_ID)
+                return;
+            const resolvedCustoms = customPluginEntries.map((entry) => resolveCustomPluginModuleId(entry, viteRoot));
+            const customImports = resolvedCustoms
+                .map((modId, i) => `import * as custom${i} from ${JSON.stringify(modId)};`)
+                .join("\n");
+            const customArgs = resolvedCustoms.length === 0
+                ? ""
+                : `, [\n${resolvedCustoms
+                    .map((_, i) => `  ...normalizeCustomPluginExport(custom${i})`)
+                    .join(",\n")}\n]`;
+            const clientImports = resolvedCustoms.length === 0
+                ? `import { mountT3FeedbackFromConfig } from "@rose42/t3-feedback/client";`
+                : `import { mountT3FeedbackFromConfig, normalizeCustomPluginExport } from "@rose42/t3-feedback/client";`;
+            return `
+${clientImports}
+${customImports}
+mountT3FeedbackFromConfig(${JSON.stringify(clientConfig)}${customArgs});
+`;
+        },
+        transformIndexHtml() {
+            if (!injectClient)
+                return;
+            return [
+                {
+                    tag: "script",
+                    attrs: { type: "module", src: VIRTUAL_CLIENT_URL },
+                    injectTo: "body",
+                },
+            ];
+        },
+        configureServer(server) {
+            server.middlewares.use(async (req, res, next) => {
+                const url = req.url ?? "";
+                // Fast path: ignore unrelated requests without buffering the body.
+                // Subpaths (`/threads`, `/settle`, `/open`) also start with the API prefix.
+                if (!url.startsWith(T3_FEEDBACK_API_PATH)) {
+                    next();
+                    return;
+                }
+                try {
+                    const request = await connectRequestToFetch(req);
+                    const response = await handleT3FeedbackRequest(request, bridgeServerOptions);
+                    if (!response) {
+                        next();
+                        return;
+                    }
+                    await writeFetchResponse(res, response);
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    console.error("[t3-feedback]", message);
+                    res.statusCode = 502;
+                    res.setHeader("Content-Type", "application/json");
+                    res.end(JSON.stringify({ error: message }));
+                }
+            });
+        },
+    };
+}
+export default t3FeedbackPlugin;