@rose42/t3-feedback 0.1.0

package/dist/cli/init.js

@@ -0,0 +1,165 @@
+import path from "node:path";
+import { CLI_NAME, PACKAGE_NAME } from "./constants.js";
+import { detectProject } from "./detect.js";
+import { detectPackageManager, installDevDependency } from "./pm.js";
+import { confirm } from "./prompt.js";
+import { wireNextApp } from "./wire/next.js";
+import { wireNodeBridge } from "./wire/node.js";
+import { wireViteConfig, writeNewViteConfig } from "./wire/vite.js";
+function formatWire(result) {
+    const rel = result.path;
+    switch (result.status) {
+        case "written":
+            return `write  ${rel}${result.detail ? ` (${result.detail})` : ""}`;
+        case "updated":
+            return `update ${rel}${result.detail ? ` (${result.detail})` : ""}`;
+        case "skipped":
+            return `skip   ${rel} — ${result.detail}`;
+        case "manual":
+            return `manual ${rel} — ${result.detail}`;
+    }
+}
+function printPlan(detection, pm, willInstall) {
+    console.log("");
+    console.log(`${CLI_NAME} init`);
+    console.log(`  root:   ${detection.root}`);
+    console.log(`  host:   ${detection.host} (${detection.reasons.join("; ")})`);
+    console.log(`  pm:     ${pm}`);
+    console.log(`  pkg:    ${PACKAGE_NAME}${detection.alreadyInstalled ? " (already installed)" : ""}`);
+    if (detection.alreadyWiredHint) {
+        console.log("  note:   project already looks wired (will skip existing files)");
+    }
+    console.log("");
+    console.log("Plan:");
+    if (willInstall) {
+        console.log(`  1. install ${PACKAGE_NAME} as a devDependency via ${pm}`);
+    }
+    else {
+        console.log("  1. skip install");
+    }
+    if (detection.host === "vite") {
+        console.log(detection.viteConfigPath
+            ? `  2. wire Vite plugin into ${path.basename(detection.viteConfigPath)}`
+            : "  2. create vite.config.ts with t3FeedbackPlugin");
+    }
+    else if (detection.host === "next") {
+        console.log("  2. add App Router route: app/api/t3-feedback/[[...path]]/route.ts");
+        console.log("  3. add client bootstrap: app/components/T3FeedbackDev.tsx");
+        console.log("  4. you mount <T3FeedbackDev /> in app/layout.tsx (printed after)");
+    }
+    else {
+        console.log("  2. write t3-feedback-bridge.mjs (Fetch bridge stub, no UI)");
+    }
+    console.log("");
+}
+async function applyWire(detection) {
+    if (detection.host === "vite") {
+        if (detection.viteConfigPath) {
+            return [wireViteConfig(detection.viteConfigPath)];
+        }
+        return [writeNewViteConfig(path.join(detection.root, "vite.config.ts"))];
+    }
+    if (detection.host === "next") {
+        const { route, client, layoutHint } = wireNextApp(detection.root);
+        console.log("");
+        console.log(layoutHint);
+        return [route, client];
+    }
+    return [wireNodeBridge(detection.root)];
+}
+/**
+ * Hybrid init: detect host → confirm → install if missing → wire files.
+ */
+export async function runInit(options = {}) {
+    const cwd = path.resolve(options.cwd ?? process.cwd());
+    let detection = detectProject(cwd);
+    if (options.host) {
+        detection = { ...detection, host: options.host, reasons: [`forced --host ${options.host}`] };
+    }
+    if (!detection.packageJsonPath) {
+        console.error(`No package.json in ${cwd}. Run this from your app root.`);
+        return 1;
+    }
+    const pm = detectPackageManager(cwd);
+    const willInstall = !options.noInstall && !detection.alreadyInstalled;
+    printPlan(detection, pm, willInstall);
+    if (options.dryRun) {
+        console.log("Dry run — no changes made.");
+        return 0;
+    }
+    const ok = options.yes === true ? true : await confirm("Apply this plan?", true);
+    if (!ok) {
+        console.log("Aborted.");
+        return 1;
+    }
+    if (willInstall) {
+        console.log("");
+        console.log(`Installing with ${pm}…`);
+        const result = installDevDependency(cwd, PACKAGE_NAME, pm);
+        if (!result.ok) {
+            console.error(`Install failed (${result.command}): ${result.detail}`);
+            console.error("Re-run with --no-install after adding the dependency yourself.");
+            return 1;
+        }
+    }
+    const results = await applyWire(detection);
+    console.log("");
+    console.log("Result:");
+    for (const result of results) {
+        console.log(`  ${formatWire(result)}`);
+        if (result.status === "manual") {
+            console.log("");
+            console.log("Snippet to paste:");
+            console.log(result.snippet);
+        }
+    }
+    console.log("");
+    console.log("Next: start your DEV server with T3 Code running, then open the feedback panel.");
+    console.log(`Docs: https://gitlab.com/rose42/t3-feedback`);
+    return 0;
+}
+export function parseInitArgs(argv) {
+    const options = {};
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--yes" || arg === "-y")
+            options.yes = true;
+        else if (arg === "--dry-run")
+            options.dryRun = true;
+        else if (arg === "--no-install")
+            options.noInstall = true;
+        else if (arg === "--cwd" && argv[i + 1]) {
+            options.cwd = argv[i + 1];
+            i += 1;
+        }
+        else if (arg === "--host" && argv[i + 1]) {
+            const host = argv[i + 1];
+            i += 1;
+            if (host === "next" || host === "vite" || host === "node")
+                options.host = host;
+            else
+                throw new Error(`Unknown --host ${host} (expected next|vite|node)`);
+        }
+        else if (arg === "--help" || arg === "-h") {
+            throw new Error("help");
+        }
+        else if (arg?.startsWith("-")) {
+            throw new Error(`Unknown flag ${arg}`);
+        }
+    }
+    return options;
+}
+export function printInitHelp() {
+    console.log(`Usage: ${CLI_NAME} init [options]
+
+Detect Next / Vite / Node, confirm, install ${PACKAGE_NAME} if missing, then wire files.
+
+Options:
+  --yes, -y       Skip confirmation
+  --dry-run       Show plan only
+  --no-install    Do not install the package (wire only)
+  --host <kind>   Force next | vite | node
+  --cwd <path>    App root (default: cwd)
+  -h, --help      Show help
+`);
+}

package/dist/cli/pm.d.ts

@@ -0,0 +1,12 @@
+export type PackageManager = "pnpm" | "npm";
+export declare function detectPackageManager(root: string): PackageManager;
+export type InstallResult = {
+    ok: true;
+    command: string;
+} | {
+    ok: false;
+    command: string;
+    detail: string;
+};
+/** Install `packageName` as a devDependency using the detected package manager. */
+export declare function installDevDependency(root: string, packageName: string, pm?: PackageManager): InstallResult;

package/dist/cli/pm.js

@@ -0,0 +1,49 @@
+import fs from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+export function detectPackageManager(root) {
+    const pkgPath = path.join(root, "package.json");
+    if (fs.existsSync(pkgPath)) {
+        try {
+            const data = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+            const pm = data.packageManager?.trim() ?? "";
+            if (pm.startsWith("pnpm@"))
+                return "pnpm";
+            if (pm.startsWith("npm@"))
+                return "npm";
+        }
+        catch {
+            // fall through
+        }
+    }
+    if (fs.existsSync(path.join(root, "pnpm-lock.yaml")))
+        return "pnpm";
+    if (fs.existsSync(path.join(root, "package-lock.json")))
+        return "npm";
+    if (fs.existsSync(path.join(root, "yarn.lock")))
+        return "npm";
+    if (fs.existsSync(path.join(root, "bun.lock")) || fs.existsSync(path.join(root, "bun.lockb"))) {
+        return "npm";
+    }
+    const ua = process.env.npm_config_user_agent ?? "";
+    if (ua.includes("pnpm"))
+        return "pnpm";
+    return "npm";
+}
+/** Install `packageName` as a devDependency using the detected package manager. */
+export function installDevDependency(root, packageName, pm = detectPackageManager(root)) {
+    const args = pm === "pnpm" ? ["add", "-D", packageName] : ["install", "-D", packageName];
+    const command = `${pm} ${args.join(" ")}`;
+    const result = spawnSync(pm, args, {
+        cwd: root,
+        encoding: "utf8",
+        stdio: "inherit",
+    });
+    if (result.status === 0)
+        return { ok: true, command };
+    const detail = result.error?.message ||
+        result.stderr?.trim() ||
+        result.stdout?.trim() ||
+        `exit ${result.status ?? "unknown"}`;
+    return { ok: false, command, detail };
+}

package/dist/cli/prompt.d.ts

@@ -0,0 +1,2 @@
+/** Ask a yes/no question. Default is yes when `defaultYes` is true. */
+export declare function confirm(question: string, defaultYes?: boolean): Promise<boolean>;

package/dist/cli/prompt.js

@@ -0,0 +1,19 @@
+import readline from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+/** Ask a yes/no question. Default is yes when `defaultYes` is true. */
+export async function confirm(question, defaultYes = true) {
+    if (!input.isTTY || !output.isTTY) {
+        return defaultYes;
+    }
+    const rl = readline.createInterface({ input, output });
+    try {
+        const hint = defaultYes ? "Y/n" : "y/N";
+        const answer = (await rl.question(`${question} [${hint}] `)).trim().toLowerCase();
+        if (!answer)
+            return defaultYes;
+        return answer === "y" || answer === "yes";
+    }
+    finally {
+        rl.close();
+    }
+}

package/dist/cli/wire/next.d.ts

@@ -0,0 +1,8 @@
+import type { WireResult } from "./vite.js";
+export type NextWireResult = {
+    route: WireResult;
+    client: WireResult;
+    layoutHint: string;
+};
+/** Write App Router route handler + client bootstrap component. */
+export declare function wireNextApp(root: string): NextWireResult;

package/dist/cli/wire/next.js

@@ -0,0 +1,71 @@
+import fs from "node:fs";
+import path from "node:path";
+import { PACKAGE_NAME } from "../constants.js";
+function ensureDir(filePath) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+}
+function writeNewFile(filePath, contents, skipIfExistsDetail) {
+    if (fs.existsSync(filePath)) {
+        return { status: "skipped", path: filePath, detail: skipIfExistsDetail };
+    }
+    ensureDir(filePath);
+    fs.writeFileSync(filePath, contents, "utf8");
+    return { status: "written", path: filePath };
+}
+const ROUTE_SOURCE = `import { handleT3FeedbackRequest } from "${PACKAGE_NAME}/bridge";
+
+const bridge = {
+  basePath: "/api/t3-feedback",
+  workspaceRootHints: [process.cwd()],
+};
+
+async function handle(request: Request) {
+  const response = await handleT3FeedbackRequest(request, bridge);
+  return response ?? new Response(null, { status: 404 });
+}
+
+export const GET = handle;
+export const POST = handle;
+`;
+const CLIENT_SOURCE = `"use client";
+
+import { useEffect } from "react";
+
+/**
+ * DEV-only T3 feedback overlay. Mount once near the root layout.
+ * The bridge refuses requests unless NODE_ENV=development.
+ */
+export function T3FeedbackDev() {
+  useEffect(() => {
+    if (process.env.NODE_ENV !== "development") return;
+    let cancelled = false;
+    let unmount: (() => void) | undefined;
+    void import("${PACKAGE_NAME}/client").then(({ mountT3Feedback }) => {
+      if (cancelled) return;
+      const api = mountT3Feedback({
+        endpoint: "/api/t3-feedback",
+      });
+      unmount = () => api.unmount();
+    });
+    return () => {
+      cancelled = true;
+      unmount?.();
+    };
+  }, []);
+  return null;
+}
+`;
+/** Write App Router route handler + client bootstrap component. */
+export function wireNextApp(root) {
+    const routePath = path.join(root, "app", "api", "t3-feedback", "[[...path]]", "route.ts");
+    const clientPath = path.join(root, "app", "components", "T3FeedbackDev.tsx");
+    const route = writeNewFile(routePath, ROUTE_SOURCE, "route handler already exists");
+    const client = writeNewFile(clientPath, CLIENT_SOURCE, "client component already exists");
+    const layoutHint = `Add to app/layout.tsx (DEV-only mount is inside the component):
+
+  import { T3FeedbackDev } from "./components/T3FeedbackDev";
+  // …
+  <T3FeedbackDev />
+`;
+    return { route, client, layoutHint };
+}

package/dist/cli/wire/node.d.ts

@@ -0,0 +1,3 @@
+import type { WireResult } from "./vite.js";
+/** Write a standalone Node HTTP bridge stub (no UI). */
+export declare function wireNodeBridge(root: string): WireResult;

package/dist/cli/wire/node.js

@@ -0,0 +1,76 @@
+import fs from "node:fs";
+import path from "node:path";
+import { PACKAGE_NAME } from "../constants.js";
+const BRIDGE_SOURCE = `/**
+ * Generic Node bridge stub for ${PACKAGE_NAME}.
+ * DEV-only: handleT3FeedbackRequest returns 404 unless NODE_ENV=development.
+ *
+ * Mount this Fetch handler in your HTTP framework, or run the tiny server below.
+ */
+import { createServer } from "node:http";
+import { handleT3FeedbackRequest } from "${PACKAGE_NAME}/bridge";
+
+const basePath = "/__t3-feedback";
+const bridge = {
+  basePath,
+  workspaceRootHints: [process.cwd()],
+};
+
+async function toFetchRequest(req, body) {
+  const host = req.headers.host ?? "127.0.0.1";
+  const url = new URL(req.url ?? "/", \`http://\${host}\`);
+  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: req.method ?? "GET", headers };
+  if (body?.length && req.method !== "GET" && req.method !== "HEAD") {
+    init.body = body;
+  }
+  return new Request(url, init);
+}
+
+const server = createServer((req, res) => {
+  const chunks = [];
+  req.on("data", (c) => chunks.push(c));
+  req.on("end", async () => {
+    try {
+      const body = Buffer.concat(chunks);
+      const request = await toFetchRequest(req, body);
+      const response = await handleT3FeedbackRequest(request, bridge);
+      if (!response) {
+        res.statusCode = 404;
+        res.end("Not found");
+        return;
+      }
+      res.statusCode = response.status;
+      response.headers.forEach((value, key) => res.setHeader(key, value));
+      res.end(Buffer.from(await response.arrayBuffer()));
+    } catch (error) {
+      res.statusCode = 500;
+      res.end(error instanceof Error ? error.message : String(error));
+    }
+  });
+});
+
+const port = Number(process.env.PORT ?? 8787);
+server.listen(port, () => {
+  console.log(\`[t3-feedback] bridge on http://127.0.0.1:\${port}\${basePath}\`);
+  console.log("[t3-feedback] Mount the /client overlay from your frontend separately.");
+});
+`;
+/** Write a standalone Node HTTP bridge stub (no UI). */
+export function wireNodeBridge(root) {
+    const target = path.join(root, "t3-feedback-bridge.mjs");
+    if (fs.existsSync(target)) {
+        return { status: "skipped", path: target, detail: "bridge stub already exists" };
+    }
+    fs.writeFileSync(target, BRIDGE_SOURCE, "utf8");
+    return {
+        status: "written",
+        path: target,
+        detail: "run with: node t3-feedback-bridge.mjs (NODE_ENV=development)",
+    };
+}

package/dist/cli/wire/vite.d.ts

@@ -0,0 +1,25 @@
+export type WireResult = {
+    status: "written";
+    path: string;
+    detail?: string;
+} | {
+    status: "updated";
+    path: string;
+    detail?: string;
+} | {
+    status: "skipped";
+    path: string;
+    detail: string;
+} | {
+    status: "manual";
+    path: string;
+    detail: string;
+    snippet: string;
+};
+/**
+ * Add the Vite plugin to an existing config, or report a manual snippet if
+ * the file shape is too unusual to edit safely.
+ */
+export declare function wireViteConfig(viteConfigPath: string): WireResult;
+/** Create a minimal vite.config.ts when none exists. */
+export declare function writeNewViteConfig(targetPath: string): WireResult;

package/dist/cli/wire/vite.js

@@ -0,0 +1,71 @@
+import fs from "node:fs";
+import { PACKAGE_NAME } from "../constants.js";
+const IMPORT_LINE = `import { t3FeedbackPlugin } from "${PACKAGE_NAME}/plugin";`;
+const PLUGIN_ENTRY = `t3FeedbackPlugin({
+      workspaceRootHints: [process.cwd()],
+    })`;
+/**
+ * Add the Vite plugin to an existing config, or report a manual snippet if
+ * the file shape is too unusual to edit safely.
+ */
+export function wireViteConfig(viteConfigPath) {
+    const original = fs.readFileSync(viteConfigPath, "utf8");
+    if (original.includes("t3FeedbackPlugin") || original.includes(`${PACKAGE_NAME}/plugin`)) {
+        return {
+            status: "skipped",
+            path: viteConfigPath,
+            detail: "t3FeedbackPlugin already referenced",
+        };
+    }
+    let next = original;
+    if (!next.includes(IMPORT_LINE)) {
+        const importBlock = next.match(/^(?:import[\s\S]*?;\s*)+/m);
+        if (importBlock) {
+            const end = importBlock.index + importBlock[0].length;
+            next = `${next.slice(0, end)}${IMPORT_LINE}\n${next.slice(end)}`;
+        }
+        else {
+            next = `${IMPORT_LINE}\n${next}`;
+        }
+    }
+    const pluginsOpen = next.match(/plugins\s*:\s*\[/);
+    if (!pluginsOpen || pluginsOpen.index === undefined) {
+        const snippet = `${IMPORT_LINE}\n\n// add to defineConfig({ plugins: [ … ] })\n${PLUGIN_ENTRY},`;
+        return {
+            status: "manual",
+            path: viteConfigPath,
+            detail: "could not find a plugins: [ … ] array to edit safely",
+            snippet,
+        };
+    }
+    const insertAt = pluginsOpen.index + pluginsOpen[0].length;
+    const before = next.slice(0, insertAt);
+    const after = next.slice(insertAt);
+    // `plugins: []` — expand to a short multi-line list; otherwise prepend an entry.
+    if (/^\s*\]/.test(after)) {
+        next = `${before}\n    ${PLUGIN_ENTRY},\n  ${after.replace(/^\s*/, "")}`;
+    }
+    else {
+        const sep = after.startsWith("\n") ? "" : "\n";
+        next = `${before}\n    ${PLUGIN_ENTRY},${sep}${after}`;
+    }
+    fs.writeFileSync(viteConfigPath, next, "utf8");
+    return { status: "updated", path: viteConfigPath, detail: "inserted t3FeedbackPlugin" };
+}
+/** Create a minimal vite.config.ts when none exists. */
+export function writeNewViteConfig(targetPath) {
+    if (fs.existsSync(targetPath)) {
+        return wireViteConfig(targetPath);
+    }
+    const contents = `import { defineConfig } from "vite";
+${IMPORT_LINE}
+
+export default defineConfig({
+  plugins: [
+    ${PLUGIN_ENTRY},
+  ],
+});
+`;
+    fs.writeFileSync(targetPath, contents, "utf8");
+    return { status: "written", path: targetPath };
+}

package/dist/client/activeThreads.d.ts

@@ -0,0 +1,23 @@
+import type { SessionThreadReportType } from "./sessionThread.js";
+/** How long a thread stays in the activity list without live settle / dismiss. */
+export declare const ACTIVE_THREAD_TTL_MS: number;
+/** How often the client polls `/__t3-feedback/threads` while any are working. */
+export declare const ACTIVE_THREAD_POLL_MS = 18000;
+export type ActiveThreadRecord = {
+    threadId: string;
+    threadTitle: string;
+    openUrl: string;
+    projectId: string;
+    /** T3 environment id for deep links; optional for older sessionStorage rows. */
+    environmentId?: string;
+    pathname: string;
+    reportType: SessionThreadReportType;
+    startedAt: number;
+};
+/** Drop TTL-expired entries; returns the survivors. */
+export declare function pruneActiveThreads(now?: number, ttlMs?: number): ActiveThreadRecord[];
+export declare function listActiveThreads(now?: number, ttlMs?: number): ActiveThreadRecord[];
+export declare function upsertActiveThread(record: ActiveThreadRecord): ActiveThreadRecord[];
+export declare function removeActiveThread(threadId: string): ActiveThreadRecord[];
+export declare function clearActiveThreads(): void;
+export declare function removeActiveThreads(threadIds: Iterable<string>): ActiveThreadRecord[];

package/dist/client/activeThreads.js

@@ -0,0 +1,89 @@
+const STORAGE_KEY = "t3-feedback:active-threads";
+/** How long a thread stays in the activity list without live settle / dismiss. */
+export const ACTIVE_THREAD_TTL_MS = 45 * 60 * 1000;
+/** How often the client polls `/__t3-feedback/threads` while any are working. */
+export const ACTIVE_THREAD_POLL_MS = 18_000;
+function parseRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const record = value;
+    const threadId = typeof record.threadId === "string" ? record.threadId.trim() : "";
+    const openUrl = typeof record.openUrl === "string" ? record.openUrl.trim() : "";
+    const projectId = typeof record.projectId === "string" ? record.projectId.trim() : "";
+    if (!threadId || !openUrl || !projectId)
+        return undefined;
+    const reportType = record.reportType;
+    if (reportType !== "bug" && reportType !== "feedback" && reportType !== "suggestion") {
+        return undefined;
+    }
+    const startedAt = typeof record.startedAt === "number" && Number.isFinite(record.startedAt)
+        ? record.startedAt
+        : 0;
+    const environmentId = typeof record.environmentId === "string" && record.environmentId.trim()
+        ? record.environmentId.trim()
+        : undefined;
+    return {
+        threadId,
+        threadTitle: typeof record.threadTitle === "string" ? record.threadTitle.trim() : "",
+        openUrl,
+        projectId,
+        ...(environmentId ? { environmentId } : {}),
+        pathname: typeof record.pathname === "string" ? record.pathname : "/",
+        reportType,
+        startedAt,
+    };
+}
+function readRaw() {
+    try {
+        const raw = sessionStorage.getItem(STORAGE_KEY);
+        if (!raw)
+            return [];
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed))
+            return [];
+        return parsed.map(parseRecord).filter((r) => r !== undefined);
+    }
+    catch {
+        return [];
+    }
+}
+function writeRaw(records) {
+    try {
+        sessionStorage.setItem(STORAGE_KEY, JSON.stringify(records));
+    }
+    catch {
+        // Private mode / quota — activity is best-effort.
+    }
+}
+/** Drop TTL-expired entries; returns the survivors. */
+export function pruneActiveThreads(now = Date.now(), ttlMs = ACTIVE_THREAD_TTL_MS) {
+    const next = readRaw().filter((r) => now - r.startedAt <= ttlMs);
+    writeRaw(next);
+    return next;
+}
+export function listActiveThreads(now = Date.now(), ttlMs = ACTIVE_THREAD_TTL_MS) {
+    return pruneActiveThreads(now, ttlMs);
+}
+export function upsertActiveThread(record) {
+    const pruned = pruneActiveThreads(Date.now());
+    const without = pruned.filter((r) => r.threadId !== record.threadId);
+    const next = [record, ...without];
+    writeRaw(next);
+    return next;
+}
+export function removeActiveThread(threadId) {
+    const next = readRaw().filter((r) => r.threadId !== threadId);
+    writeRaw(next);
+    return pruneActiveThreads();
+}
+export function clearActiveThreads() {
+    writeRaw([]);
+}
+export function removeActiveThreads(threadIds) {
+    const drop = new Set(threadIds);
+    if (drop.size === 0)
+        return pruneActiveThreads();
+    const next = readRaw().filter((r) => !drop.has(r.threadId));
+    writeRaw(next);
+    return pruneActiveThreads();
+}

package/dist/client/cropScreenshot.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Fullscreen crop dialog lives here; headless crop geometry + `cropDataUrl` come
+ * from `@rose42/feedback-capture`.
+ */
+import { clientPointToNatural, containedImageLayout, cropDataUrl, rectFromPoints, type ContainedImageLayout, type CropRect } from "@rose42/feedback-capture";
+export type { ContainedImageLayout, CropRect };
+export { clientPointToNatural, containedImageLayout, cropDataUrl, rectFromPoints };
+export type SelectScreenshotRegionCopy = {
+    hint: string;
+    cropLabel: string;
+    useFullLabel: string;
+    cancelLabel: string;
+    discardLabel: string;
+};
+export type SelectScreenshotRegionOptions = {
+    parent: HTMLElement;
+    dataUrl: string;
+    /** Prefill the marquee (natural image pixels); user can still adjust. */
+    initialRect?: CropRect;
+    /** When false, hide Discard (e.g. first capture before the image is in the gallery). Default true. */
+    allowDiscard?: boolean;
+    copy?: Partial<SelectScreenshotRegionCopy>;
+};
+/** Outcome of the fullscreen crop dialog. */
+export type SelectScreenshotRegionResult = {
+    action: "cancel";
+} | {
+    action: "discard";
+} | {
+    action: "image";
+    dataUrl: string;
+};
+/** Cancel any crop dialogs still open under `parent` and drop their window listeners. */
+export declare function abortScreenshotRegions(parent: ParentNode): void;
+/**
+ * Fullscreen overlay: drag a region on the screenshot.
+ * Resolves with an image data URL, cancel (keep prior), or discard (drop the shot).
+ */
+export declare function selectScreenshotRegion(options: SelectScreenshotRegionOptions): Promise<SelectScreenshotRegionResult>;