@insitue/capture-core 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Rod Leviton
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,351 @@
+/**
+ * Pure DOM → data helpers. Browser APIs only — no transport/agent/fs,
+ * no dependencies. Shared by every vehicle.
+ */
+
+/** Prune + sanitize a subtree: depth/breadth-capped, event handlers
+ *  and secret-looking attrs stripped, text truncated. */
+declare function serializeNode(el: Element, depth?: number, maxChildren?: number): SerializedNode;
+declare function curateComputedStyles(el: Element): Record<string, string>;
+/** The verbatim class list — the agent edits Tailwind classes, not
+ *  inline styles, so the source-of-truth is `className`. */
+declare function extractTailwindClasses(el: Element): string[];
+/** A robust, reasonably-stable CSS path. Prefers #id, then a
+ *  data-testid, else tag + nth-of-type up to a shortest unique path.
+ *  Always present — the last-resort locator. */
+declare function buildSelector(el: Element): string;
+/** Tailwind-ish breakpoint label from viewport width. */
+declare function breakpointFor(w: number): string;
+
+/**
+ * Pure React-fiber → source resolver. No React dependency: reads the
+ * `__reactFiber$*` expando React attaches to host DOM nodes in dev,
+ * walks `_debugOwner`/`return`, and harvests `_debugSource`
+ * ({ fileName, lineNumber, columnNumber }) plus component names.
+ * Falls back to a build-injected `data-insitu-source` attribute.
+ */
+
+declare function resolveTarget(el: Element): CaptureTarget;
+
+/**
+ * @insitue/capture-core — THE SEAM.
+ *
+ * Pure, serializable data model + interfaces shared by every InSitue
+ * vehicle (dev SDK now; production capture-only, browser extension or
+ * Electron later). This package MUST NOT import transport (ws), an
+ * agent SDK, or fs/git — that is enforced by lint (see eslint config)
+ * and by keeping this file dependency-free. The whole point: a
+ * `CaptureBundle` can cross any boundary unchanged, and swapping the
+ * `CaptureSink` is what turns "local agentic edit" into "prod
+ * capture-only" without a rewrite.
+ */
+/** Bump when `CaptureBundle`'s shape changes; sinks branch on it.
+ *  v2: additive `screenshotUnavailable` (M5 — honest screenshots).
+ *  v3: additive `screenshot.source` + `screenshot.qualityNote`
+ *      (pixel-perfect layered capture — rasterise vs display-media). */
+declare const CAPTURE_SCHEMA_VERSION: 3;
+/** Bump when the WS envelope below changes; companion/SDK pin it.
+ *  v2: agent edit-loop messages (M2). v3: session undo/commit (M3).
+ *  v4: agent-activity (M6 — live "what it's doing" feedback). */
+declare const PROTOCOL_VERSION: 4;
+interface SourceLoc {
+    /** Repo-relative POSIX path, e.g. `components/MainBar.tsx`. */
+    file: string;
+    line: number;
+    column: number;
+}
+type SelectionMode = "element" | "rect" | "multi";
+interface SelectionInput {
+    mode: SelectionMode;
+    /** `elementsFromPoint` chain at the click (outermost→innermost). */
+    pointerPath?: Element[];
+    /** Freeform region in viewport CSS px. */
+    rect?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+}
+interface SerializedNode {
+    tag: string;
+    attrs: Record<string, string>;
+    /** Truncated text content for leaf-ish nodes. */
+    text?: string;
+    children: SerializedNode[];
+}
+interface ConsoleEntry {
+    level: "log" | "info" | "warn" | "error" | "debug";
+    args: string[];
+    ts: number;
+}
+interface NetworkEntry {
+    url: string;
+    method: string;
+    status?: number;
+    ok: boolean;
+    ts: number;
+}
+interface RuntimeError {
+    message: string;
+    stack?: string;
+    ts: number;
+}
+/** How confident the DOM→source resolution is. Surfaced in the UI and
+ *  handed to the agent so it knows whether file:line is trustworthy. */
+type SourceConfidence = "exact" | "approximate" | "selector-only";
+interface CaptureTarget {
+    source?: SourceLoc;
+    confidence: SourceConfidence;
+    /** Outer→inner component ownership chain (React fiber `_debugOwner`). */
+    componentStack: Array<{
+        name: string;
+        source?: SourceLoc;
+    }>;
+    /** Robust CSS path — always present, the last-resort locator. */
+    selector: string;
+}
+interface CaptureBundle {
+    schemaVersion: typeof CAPTURE_SCHEMA_VERSION;
+    id: string;
+    createdAt: string;
+    target: CaptureTarget | null;
+    domSubtree: SerializedNode;
+    computedStyles: Record<string, string>;
+    tailwindClasses: string[];
+    screenshot?: {
+        mime: "image/png";
+        dataUrl: string;
+        bounds: {
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        };
+        /** Which capture path produced this screenshot. `rasterise` =
+         *  html-to-image full-document render + crop (no permission).
+         *  `display-media` = `getDisplayMedia` OS-compositor capture (one
+         *  permission per session, pixel-perfect across any content). */
+        source?: "rasterise" | "display-media";
+        /** Human-readable note when the capture is structurally complete
+         *  but visually imperfect — e.g. some non-CORS images fell back
+         *  to a placeholder because the user declined `getDisplayMedia`. */
+        qualityNote?: string;
+    };
+    /** Set (and `screenshot` omitted) when an in-browser rasterise was
+     *  impossible — e.g. cross-origin media taints the canvas. Honest
+     *  signal so the UI/sink never shows a blank box claiming success. */
+    screenshotUnavailable?: string;
+    viewport: {
+        w: number;
+        h: number;
+        dpr: number;
+        breakpoint?: string;
+    };
+    runtime: {
+        url: string;
+        route?: string;
+        console: ConsoleEntry[];
+        network: NetworkEntry[];
+        errors: RuntimeError[];
+    };
+    userNote?: string;
+}
+/** Builds bundles from a selection. Implemented by the SDK; the
+ *  contract is what an extension/Electron vehicle reuses verbatim. */
+interface CaptureCore {
+    beginPick(opts?: {
+        mode?: SelectionMode;
+    }): Promise<SelectionInput>;
+    buildBundle(sel: SelectionInput): Promise<CaptureBundle>;
+}
+/** The swap point. v1 local = WebSocketAgentSink (→ companion → agent
+ *  edits). Future prod = IssueTrackerSink (same bundle → hosted task,
+ *  no auto-edit). capture-core never knows which. */
+interface CaptureSink {
+    readonly kind: string;
+    submit(bundle: CaptureBundle): Promise<void>;
+}
+interface IssueDraft {
+    title: string;
+    /** Markdown summary a human/tracker can read at a glance. */
+    body: string;
+    /** Full bundle, attached verbatim for the agent-ready future. */
+    bundle: CaptureBundle;
+}
+/** Turn a bundle into a tracker-ready draft. Source is included when
+ *  present (fiber/attribute resolved it client-side) and degrades
+ *  gracefully to the always-present selector when it isn't. */
+declare function toIssueDraft(bundle: CaptureBundle): IssueDraft;
+/** A CaptureSink that produces an `IssueDraft` and hands it to a
+ *  caller-supplied delivery fn (download/gh/HTTP — not our concern).
+ *  Same bundle, different sink: this is the local→prod door. */
+declare class IssueTrackerSink implements CaptureSink {
+    private readonly deliver;
+    readonly kind = "issue-tracker";
+    constructor(deliver: (draft: IssueDraft) => void | Promise<void>);
+    submit(bundle: CaptureBundle): Promise<void>;
+}
+interface HelloMsg {
+    t: "hello";
+    protocolVersion: typeof PROTOCOL_VERSION;
+    token: string;
+}
+interface HelloOkMsg {
+    t: "hello-ok";
+    companionVersion: string;
+}
+interface PingMsg {
+    t: "ping";
+    nonce: string;
+}
+interface PongMsg {
+    t: "pong";
+    nonce: string;
+}
+interface ErrorMsg {
+    t: "error";
+    code: "bad-token" | "bad-origin" | "bad-protocol" | "internal";
+    message: string;
+}
+interface CaptureSubmitMsg {
+    t: "capture";
+    bundle: CaptureBundle;
+}
+/** Companion's resolution of a submitted bundle's source target. */
+interface ResolvedSource {
+    /** Repo-relative POSIX path the companion resolved. */
+    file: string;
+    line: number;
+    column: number;
+    /** A few lines around `line` from the real file. */
+    snippet: string;
+    /** Whole component file path, if distinct/known. */
+    componentFile?: string;
+}
+interface CaptureResolvedMsg {
+    t: "capture-resolved";
+    id: string;
+    resolved: ResolvedSource | null;
+    /** Human note, e.g. why resolution was selector-only. */
+    note: string;
+}
+type AgentErrorCode = "not-logged-in" | "api-key-set" | "claude-missing" | "transport" | "internal";
+/** A normalized file edit the agent proposes (never auto-applied). */
+interface ProposedEdit {
+    /** Repo-relative POSIX path. */
+    file: string;
+    /** Whole new file contents (companion diffs vs disk). */
+    contents: string;
+    /** Optional one-line rationale from the agent. */
+    why?: string;
+}
+type AgentEvent = {
+    t: "agent-text";
+    turnId: string;
+    delta: string;
+} | {
+    t: "agent-thinking";
+    turnId: string;
+    note: string;
+}
+/** Live "what it's doing" signal (tool use / phase) — UI progress
+ *  only, never part of the transcript. */
+ | {
+    t: "agent-activity";
+    turnId: string;
+    kind: "tool" | "thinking" | "start";
+    label: string;
+} | {
+    t: "agent-tool-proposal";
+    turnId: string;
+    edit: ProposedEdit;
+} | {
+    t: "agent-turn-complete";
+    turnId: string;
+} | {
+    t: "agent-error";
+    turnId: string;
+    code: AgentErrorCode;
+    message: string;
+};
+/** Companion preflight result for the active provider/transport. */
+interface AgentStatusMsg {
+    t: "agent-status";
+    ready: boolean;
+    transport: "cli-headless" | "mcp" | "sdk";
+    warnings: string[];
+    blockers: string[];
+}
+interface AgentStreamMsg {
+    t: "agent-stream";
+    event: AgentEvent;
+}
+interface ChangesetProposedMsg {
+    t: "changeset-proposed";
+    turnId: string;
+    files: Array<{
+        file: string;
+        diff: string;
+        bytes: number;
+    }>;
+}
+interface ChangesetAppliedMsg {
+    t: "changeset-applied";
+    turnId: string;
+    files: string[];
+    checkpointRef: string;
+}
+interface AgentUndoneMsg {
+    t: "agent-undone";
+    turnId: string;
+    restored: string[];
+}
+interface AgentTurnMsg {
+    t: "agent-turn";
+    turnId: string;
+    bundleId: string;
+    userMessage: string;
+}
+interface AgentDecisionMsg {
+    t: "agent-decision";
+    turnId: string;
+    decision: "approve" | "reject";
+    /** Subset of files to act on; omitted = whole changeset. */
+    files?: string[];
+    reason?: string;
+}
+interface AgentCancelMsg {
+    t: "agent-cancel";
+    turnId: string;
+}
+interface AgentUndoMsg {
+    t: "agent-undo";
+    turnId: string;
+}
+/** Undo every checkpoint applied this session (reverse order). */
+interface AgentUndoSessionMsg {
+    t: "agent-undo-session";
+}
+/** Explicit, user-initiated git commit of ONLY the files InSitue
+ *  applied this session. Never auto; never pushes. */
+interface AgentCommitSessionMsg {
+    t: "agent-commit-session";
+    message?: string;
+}
+interface AgentSessionUndoneMsg {
+    t: "agent-session-undone";
+    restored: string[];
+}
+interface AgentSessionCommittedMsg {
+    t: "agent-session-committed";
+    /** Short commit sha. */
+    commit: string;
+    files: string[];
+}
+/** Client→server messages. */
+type ClientMessage = HelloMsg | PingMsg | CaptureSubmitMsg | AgentTurnMsg | AgentDecisionMsg | AgentCancelMsg | AgentUndoMsg | AgentUndoSessionMsg | AgentCommitSessionMsg;
+/** Server→client messages. */
+type ServerMessage = HelloOkMsg | PongMsg | ErrorMsg | CaptureResolvedMsg | AgentStatusMsg | AgentStreamMsg | ChangesetProposedMsg | ChangesetAppliedMsg | AgentUndoneMsg | AgentSessionUndoneMsg | AgentSessionCommittedMsg;
+
+export { type AgentCancelMsg, type AgentCommitSessionMsg, type AgentDecisionMsg, type AgentErrorCode, type AgentEvent, type AgentSessionCommittedMsg, type AgentSessionUndoneMsg, type AgentStatusMsg, type AgentStreamMsg, type AgentTurnMsg, type AgentUndoMsg, type AgentUndoSessionMsg, type AgentUndoneMsg, CAPTURE_SCHEMA_VERSION, type CaptureBundle, type CaptureCore, type CaptureResolvedMsg, type CaptureSink, type CaptureSubmitMsg, type CaptureTarget, type ChangesetAppliedMsg, type ChangesetProposedMsg, type ClientMessage, type ConsoleEntry, type ErrorMsg, type HelloMsg, type HelloOkMsg, type IssueDraft, IssueTrackerSink, type NetworkEntry, PROTOCOL_VERSION, type PingMsg, type PongMsg, type ProposedEdit, type ResolvedSource, type RuntimeError, type SelectionInput, type SelectionMode, type SerializedNode, type ServerMessage, type SourceConfidence, type SourceLoc, breakpointFor, buildSelector, curateComputedStyles, extractTailwindClasses, resolveTarget, serializeNode, toIssueDraft };

package/dist/index.js

@@ -0,0 +1,234 @@
+// src/dom.ts
+var SKIP_TAGS = /* @__PURE__ */ new Set(["SCRIPT", "STYLE", "NOSCRIPT", "TEMPLATE"]);
+var ATTR_DENY = /^(on|data-insitu)/i;
+var SECRETISH = /(token|secret|key|password|authorization|bearer)/i;
+function serializeNode(el, depth = 3, maxChildren = 12) {
+  const attrs = {};
+  for (const a of Array.from(el.attributes)) {
+    if (ATTR_DENY.test(a.name)) continue;
+    const v = SECRETISH.test(a.name) ? "[redacted]" : a.value;
+    attrs[a.name] = v.length > 300 ? v.slice(0, 300) + "\u2026" : v;
+  }
+  const node = {
+    tag: el.tagName.toLowerCase(),
+    attrs,
+    children: []
+  };
+  const directText = Array.from(el.childNodes).filter((n) => n.nodeType === Node.TEXT_NODE).map((n) => n.textContent ?? "").join(" ").trim();
+  if (directText) node.text = directText.slice(0, 200);
+  if (depth > 0) {
+    const kids = Array.from(el.children).filter((c) => !SKIP_TAGS.has(c.tagName)).slice(0, maxChildren);
+    node.children = kids.map((c) => serializeNode(c, depth - 1, maxChildren));
+  }
+  return node;
+}
+var STYLE_KEYS = [
+  "display",
+  "position",
+  "boxSizing",
+  "width",
+  "height",
+  "margin",
+  "padding",
+  "border",
+  "flexDirection",
+  "alignItems",
+  "justifyContent",
+  "gap",
+  "gridTemplateColumns",
+  "color",
+  "backgroundColor",
+  "fontFamily",
+  "fontSize",
+  "fontWeight",
+  "lineHeight",
+  "letterSpacing",
+  "textAlign",
+  "borderRadius",
+  "boxShadow",
+  "opacity",
+  "zIndex"
+];
+function curateComputedStyles(el) {
+  const cs = getComputedStyle(el);
+  const out = {};
+  for (const k of STYLE_KEYS) {
+    const v = cs[k];
+    if (typeof v === "string" && v && v !== "normal" && v !== "none") {
+      out[k] = v;
+    }
+  }
+  return out;
+}
+function extractTailwindClasses(el) {
+  const cls = typeof el.className === "string" ? el.className : el.getAttribute("class") ?? "";
+  return cls.split(/\s+/).filter(Boolean);
+}
+function buildSelector(el) {
+  if (el.id && document.querySelectorAll(`#${CSS.escape(el.id)}`).length === 1) {
+    return `#${CSS.escape(el.id)}`;
+  }
+  const parts = [];
+  let cur = el;
+  while (cur && cur.nodeType === Node.ELEMENT_NODE && parts.length < 6) {
+    const tid = cur.getAttribute("data-testid");
+    if (tid) {
+      parts.unshift(`[data-testid="${CSS.escape(tid)}"]`);
+      break;
+    }
+    const tag = cur.tagName.toLowerCase();
+    const parent = cur.parentElement;
+    if (!parent) {
+      parts.unshift(tag);
+      break;
+    }
+    const sibs = Array.from(parent.children).filter(
+      (c) => c.tagName === cur.tagName
+    );
+    const idx = sibs.indexOf(cur);
+    parts.unshift(
+      sibs.length > 1 ? `${tag}:nth-of-type(${idx + 1})` : tag
+    );
+    if (cur.id) {
+      parts.unshift(`#${CSS.escape(cur.id)}`);
+      break;
+    }
+    cur = parent;
+  }
+  return parts.join(" > ");
+}
+function breakpointFor(w) {
+  if (w < 640) return "xs";
+  if (w < 768) return "sm";
+  if (w < 1024) return "md";
+  if (w < 1280) return "lg";
+  if (w < 1536) return "xl";
+  return "2xl";
+}
+
+// src/react-source.ts
+function getFiber(el) {
+  for (const k of Object.keys(el)) {
+    if (k.startsWith("__reactFiber$") || k.startsWith("__reactInternalInstance$")) {
+      return el[k] ?? null;
+    }
+  }
+  return null;
+}
+function compName(type) {
+  if (typeof type === "function") {
+    const f = type;
+    return f.displayName || f.name || "Anonymous";
+  }
+  if (type && typeof type === "object") {
+    const o = type;
+    return o.displayName || o.render?.name || null;
+  }
+  return null;
+}
+function toLoc(workspaceCwdRelative) {
+  if (!workspaceCwdRelative.fileName) return null;
+  return {
+    // React gives an absolute path in dev; the companion re-roots it.
+    file: workspaceCwdRelative.fileName,
+    line: workspaceCwdRelative.lineNumber ?? 1,
+    column: workspaceCwdRelative.columnNumber ?? 1
+  };
+}
+function fromAttribute(el) {
+  let cur = el;
+  for (let i = 0; cur && i < 8; i++, cur = cur.parentElement) {
+    const raw = cur.getAttribute("data-insitu-source");
+    if (raw) {
+      const m = /^(.*):(\d+):(\d+)$/.exec(raw);
+      if (m) return { file: m[1], line: Number(m[2]), column: Number(m[3]) };
+    }
+  }
+  return null;
+}
+function resolveTarget(el) {
+  const selector = buildSelector(el);
+  const fiber = getFiber(el);
+  const componentStack = [];
+  if (fiber) {
+    let f = fiber;
+    let guard = 0;
+    while (f && guard++ < 60) {
+      const name = compName(f.type);
+      if (name) {
+        const src = f._debugSource ? toLoc(f._debugSource) : null;
+        componentStack.push(
+          src ? { name, source: src } : { name }
+        );
+      }
+      f = f._debugOwner ?? f.return ?? null;
+    }
+  }
+  let source;
+  let confidence = "selector-only";
+  const hostSrc = fiber?._debugSource ? toLoc(fiber._debugSource) : null;
+  if (hostSrc) {
+    source = hostSrc;
+    confidence = "exact";
+  } else {
+    const attrSrc = fromAttribute(el);
+    if (attrSrc) {
+      source = attrSrc;
+      confidence = "exact";
+    } else {
+      const ownerWithSrc = componentStack.find((c) => c.source);
+      if (ownerWithSrc?.source) {
+        source = ownerWithSrc.source;
+        confidence = "approximate";
+      }
+    }
+  }
+  return source === void 0 ? { confidence, componentStack, selector } : { source, confidence, componentStack, selector };
+}
+
+// src/index.ts
+var CAPTURE_SCHEMA_VERSION = 3;
+var PROTOCOL_VERSION = 4;
+function toIssueDraft(bundle) {
+  const t = bundle.target;
+  const where = t?.source ? `\`${t.source.file}:${t.source.line}\` (${t.confidence})` : t ? `\`${t.selector}\` (selector-only \u2014 no source resolver)` : "(empty selection)";
+  const stack = t?.componentStack.map((c) => c.name).join(" < ") || "(none)";
+  const errs = bundle.runtime.errors.length;
+  const title = `[InSitue] ${t?.componentStack[0]?.name ?? t?.selector ?? "selection"} on ${bundle.runtime.route ?? new URL(bundle.runtime.url).pathname}`;
+  const body = [
+    `**Where:** ${where}`,
+    `**Components:** ${stack}`,
+    `**URL:** ${bundle.runtime.url}`,
+    `**Viewport:** ${bundle.viewport.w}\xD7${bundle.viewport.h}${bundle.viewport.breakpoint ? ` (${bundle.viewport.breakpoint})` : ""}`,
+    `**Tailwind:** ${bundle.tailwindClasses.join(" ") || "\u2014"}`,
+    `**Runtime:** ${bundle.runtime.console.length} log \xB7 ${bundle.runtime.network.length} net \xB7 ${errs} err`,
+    `**Screenshot:** ${bundle.screenshot ? `attached` + (bundle.screenshot.source ? ` (${bundle.screenshot.source})` : "") + (bundle.screenshot.qualityNote ? ` \u2014 ${bundle.screenshot.qualityNote}` : "") : bundle.screenshotUnavailable ? `unavailable \u2014 ${bundle.screenshotUnavailable}` : "\u2014"}`,
+    bundle.userNote ? `
+> ${bundle.userNote}` : "",
+    `
+_Captured ${bundle.createdAt} \xB7 schema v${bundle.schemaVersion}_`
+  ].join("\n");
+  return { title, body, bundle };
+}
+var IssueTrackerSink = class {
+  constructor(deliver) {
+    this.deliver = deliver;
+  }
+  deliver;
+  kind = "issue-tracker";
+  async submit(bundle) {
+    await this.deliver(toIssueDraft(bundle));
+  }
+};
+export {
+  CAPTURE_SCHEMA_VERSION,
+  IssueTrackerSink,
+  PROTOCOL_VERSION,
+  breakpointFor,
+  buildSelector,
+  curateComputedStyles,
+  extractTailwindClasses,
+  resolveTarget,
+  serializeNode,
+  toIssueDraft
+};

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@insitue/capture-core",
+  "version": "0.1.0",
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": "The seam: pure, transport/agent/fs-free capture model shared by every InSitue vehicle.",
+  "license": "MIT",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "tsup": "^8.3.5",
+    "typescript": "^5.6.3"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "dev": "tsup src/index.ts --format esm --dts --watch",
+    "typecheck": "tsc --noEmit",
+    "lint": "tsc --noEmit"
+  }
+}