feedtack 1.1.0 → 1.2.0

package/README.md

@@ -80,49 +80,12 @@ The `FeedtackAdapter` interface has five methods. Here are copy-paste implementa
 
 ### Disk / JSON files (Node.js)
 
-Git-trackable feedback — each submission becomes a JSON file in `.feedback/`.
+Git-trackable feedback — each submission becomes a JSON file in `.feedback/`. `DiskAdapter` ships with the package and also implements `ContentAdapter` + `ContentEditAdapter`.
 
 ```ts
-import type { FeedtackAdapter, FeedbackItem, FeedtackPayload } from 'feedtack'
-import { readdir, readFile, writeFile, mkdir } from 'node:fs/promises'
-import { join } from 'node:path'
+import { DiskAdapter } from 'feedtack/node'
 
-const DIR = '.feedback'
-
-class DiskAdapter implements FeedtackAdapter {
-  async submit(payload: FeedtackPayload) {
-    await mkdir(DIR, { recursive: true })
-    const item: FeedbackItem = { payload, replies: [], resolutions: [], archives: [] }
-    await writeFile(join(DIR, `${payload.id}.json`), JSON.stringify(item, null, 2))
-  }
-
-  async reply(feedbackId: string, reply: Omit<FeedbackItem['replies'][0], 'id' | 'feedbackId'>) {
-    const item = await this.read(feedbackId)
-    item.replies.push({ ...reply, id: crypto.randomUUID(), feedbackId })
-    await this.write(feedbackId, item)
-  }
-
-  async resolve(feedbackId: string, resolution: Omit<FeedbackItem['resolutions'][0], 'feedbackId'>) {
-    const item = await this.read(feedbackId)
-    item.resolutions.push({ ...resolution, feedbackId })
-    await this.write(feedbackId, item)
-  }
-
-  async archive(feedbackId: string, userId: string) {
-    const item = await this.read(feedbackId)
-    item.archives.push({ feedbackId, archivedBy: { id: userId, name: '', role: '' }, timestamp: new Date().toISOString() })
-    await this.write(feedbackId, item)
-  }
-
-  async loadFeedback() {
-    await mkdir(DIR, { recursive: true })
-    const files = (await readdir(DIR)).filter((f) => f.endsWith('.json'))
-    return Promise.all(files.map(async (f) => JSON.parse(await readFile(join(DIR, f), 'utf-8')) as FeedbackItem))
-  }
-
-  private async read(id: string) { return JSON.parse(await readFile(join(DIR, `${id}.json`), 'utf-8')) as FeedbackItem }
-  private async write(id: string, item: FeedbackItem) { await writeFile(join(DIR, `${id}.json`), JSON.stringify(item, null, 2)) }
-}
+const adapter = new DiskAdapter({ directory: '.feedback' }) // default: '.feedback'
 ```
 
 ### Supabase
@@ -243,6 +206,51 @@ function MyButton() {
 }
 ```
 
+## Content approval (opt-in)
+
+Feedtack can also track whether copywriting fields on a page have been reviewed and approved. Annotate elements with `data-feedtack-field`, use an adapter that implements `ContentAdapter` (`DiskAdapter` and `WebhookAdapter` both do), and call the hook:
+
+```tsx
+<h1 data-feedtack-field="hero.heading">Welcome to Acme</h1>
+<p data-feedtack-field="hero.subheading">The best tools for your team.</p>
+```
+
+```tsx
+import { useContentApproval } from 'feedtack/react'
+
+const { fields, approve, checkDeploy } = useContentApproval(adapter, currentUser.id)
+
+// Gate deploys on all fields being approved
+const result = await checkDeploy()
+// => { approved: false, pending: ['hero.subheading'] }
+```
+
+Approvals are hash-based — if the content changes, the approval goes stale automatically. See the [Content Approval docs](site-docs/content/docs/concepts/content-approval.mdx) for the full API.
+
+## Content editing (opt-in)
+
+For teams that want to edit content inline, `useContentEdit` builds on top of content approval. It hydrates the DOM with stored values, makes annotated fields `contenteditable`, and auto-saves on blur. The adapter must implement `ContentEditAdapter` (`DiskAdapter` and `WebhookAdapter` both do).
+
+```tsx
+import { useContentEdit, ContentEditToolbar } from 'feedtack/react'
+
+function AdminLayout({ adapter, children }) {
+  const edit = useContentEdit(adapter, currentUser.id)
+
+  return (
+    <>
+      {children}
+      {edit.active && <ContentEditToolbar {...edit.toolbarProps} />}
+      <button onClick={edit.active ? edit.deactivate : edit.activate}>
+        {edit.active ? 'Exit edit mode' : 'Edit content'}
+      </button>
+    </>
+  )
+}
+```
+
+The toolbar shows approve/revert actions per field, a session changes panel, and a deploy gate. See the [Content Editing docs](site-docs/content/docs/concepts/content-editing.mdx) for details.
+
 ## What feedtack does NOT do
 
 - LLM triage or routing (downstream concern — feedtack emits, others act)
@@ -251,6 +259,7 @@ function MyButton() {
 
 ## ICEBOX
 
+- Vanilla JS content editing (no React dependency)
 - Script tag CDN distribution
 - Next.js plugin
 - `allowedCaptures` config for scoping DOM access

package/dist/{types-Cu4Oahg4.d.ts → adapter-Cn59URIG.d.ts}

@@ -132,7 +132,74 @@ interface FeedtackFilter {
     userId?: string;
     scope?: FeedtackScope;
 }
+/** Recorded approval for a content field — keyed by dot-path (e.g. "hero.heading") */
+interface FieldApproval {
+    /** 12-char truncated SHA-256 of the approved content */
+    hash: string;
+    /** User IDs who have approved this field */
+    by: string[];
+    /** ISO 8601 UTC timestamp of most recent approval */
+    at: string;
+}
+/** Combined field identity, approval record, and staleness flag */
+interface FieldApprovalState {
+    /** Dot-path field identifier (value of data-feedtack-field attribute) */
+    fieldPath: string;
+    /** Null when the field has never been approved */
+    approval: FieldApproval | null;
+    /** True when the current content hash differs from the stored approval hash */
+    stale: boolean;
+}
+interface FieldFilter {
+    pathname?: string;
+    fieldPath?: string;
+}
+/** A single field edit recorded in the current editing session */
+interface FieldChange {
+    fieldPath: string;
+    /** Value at session start (pre-first-edit for this field) */
+    from: string;
+    /** Most recent saved value */
+    to: string;
+    /** Unix ms timestamp of most recent save */
+    savedAt: number;
+}
+/** Info about the currently focused content field — used by the edit toolbar */
+interface FocusedFieldInfo {
+    element: HTMLElement;
+    fieldPath: string;
+}
 
+/**
+ * Optional extension interface for adapters that support content field approvals.
+ * Implement alongside FeedtackAdapter — adapters that omit this continue to work unchanged.
+ */
+interface ContentAdapter {
+    /** Record approval for a field at its current hash */
+    approve(fieldPath: string, approval: FieldApproval): Promise<void>;
+    /** Remove approval for a field by a specific user */
+    revokeApproval(fieldPath: string, userId: string): Promise<void>;
+    /** Load approval states, optionally filtered */
+    loadApprovals(filter?: FieldFilter): Promise<FieldApprovalState[]>;
+}
+/**
+ * Optional extension of ContentAdapter for adapters that support inline content editing.
+ * saveField MUST atomically persist the new value AND clear the stored approval.
+ */
+interface ContentEditAdapter extends ContentAdapter {
+    /** Fetch all stored field values for DOM hydration — keyed by dot-path */
+    loadFields(): Promise<Record<string, string>>;
+    /** Persist a field edit. MUST clear the stored approval for the field. */
+    saveField(fieldPath: string, value: string): Promise<void>;
+}
+/** Returns true if the adapter implements ContentEditAdapter */
+declare function isContentEditAdapter(adapter: unknown): adapter is ContentEditAdapter;
+/** Warn in dev mode when an edit method is called on a non-ContentEditAdapter */
+declare function warnIfNotContentEditAdapter(adapter: unknown, method: string): void;
+/** Returns true if the adapter implements ContentAdapter */
+declare function isContentAdapter(adapter: unknown): adapter is ContentAdapter;
+/** Warn in dev mode when a ContentAdapter method is called on a non-ContentAdapter */
+declare function warnIfNotContentAdapter(adapter: unknown, method: string): void;
 /** Plugin contract — implement this interface to create a custom feedtack backend */
 interface FeedtackAdapter {
     /** Submit new feedback payload */
@@ -147,62 +214,4 @@ interface FeedtackAdapter {
     loadFeedback(filter?: FeedtackFilter): Promise<FeedbackItem[]>;
 }
 
-interface FeedtackTheme {
-    /** Accent color — pin button active state, focus rings, selected states */
-    primary?: string;
-    /** Panel and picker background */
-    background?: string;
-    /** Input and card surface background */
-    surface?: string;
-    /** Primary text color */
-    text?: string;
-    /** Secondary/placeholder text color */
-    textMuted?: string;
-    /** Panel and input border color */
-    border?: string;
-    /** Border radius applied to panels and inputs */
-    radius?: string;
-    /** Notification badge color */
-    badge?: string;
-}
-/** Maps FeedtackTheme fields to CSS custom properties on #feedtack-root */
-declare function themeToCSS(theme: FeedtackTheme): Record<string, string>;
-
-declare function generateId(): string;
-interface FeedtackFlushEvent {
-    pathname: string;
-    items: FeedbackItem[];
-}
-interface FeedtackEngineOpts {
-    adapter: FeedtackAdapter;
-    currentUser: FeedtackUser;
-    hotkey?: string;
-    theme?: FeedtackTheme;
-    onError?: (err: Error) => void;
-    disabled?: boolean;
-    onFlush?: (event: FeedtackFlushEvent) => void;
-    flushIdleMs?: number;
-    rescopeRoles?: string[];
-}
-interface FeedtackEngineState {
-    isPinModeActive: boolean;
-    pendingPins: Array<Omit<FeedtackPin, 'index'>>;
-    selectedColor: string;
-    showForm: boolean;
-    comment: string;
-    sentiment: FeedtackSentiment;
-    commentError: boolean;
-    submitting: boolean;
-    feedbackItems: FeedbackItem[];
-    siteFeedback: FeedbackItem[];
-    pageFeedback: FeedbackItem[];
-    loading: boolean;
-    openThreadId: string | null;
-    replyBody: string;
-    isModalOpen: boolean;
-    composeScope: 'site' | 'page';
-    pathname: string;
-}
-type FeedtackStateListener = (state: FeedtackEngineState, changedKeys: Array<keyof FeedtackEngineState>) => void;
-
-export { type AncestorNode as A, type FeedtackAdapter as F, SCHEMA_VERSION as S, type FeedtackPayload as a, type FeedtackReply as b, type FeedtackResolution as c, type FeedtackFilter as d, type FeedbackItem as e, type FeedtackDeviceMeta as f, type FeedtackPageMeta as g, type FeedtackViewportMeta as h, type FeedtackPinTarget as i, type FeedtackEngineOpts as j, type FeedtackEngineState as k, type FeedtackStateListener as l, type FeedtackArchive as m, type FeedtackBoundingRect as n, type FeedtackFlushEvent as o, type FeedtackPin as p, type FeedtackScope as q, type FeedtackSentiment as r, type FeedtackTheme as s, type FeedtackUser as t, generateId as u, themeToCSS as v };
+export { type AncestorNode as A, type ContentAdapter as C, type FeedtackAdapter as F, SCHEMA_VERSION as S, type FeedtackPayload as a, type FeedtackReply as b, type FeedtackResolution as c, type FeedtackFilter as d, type FeedbackItem as e, type ContentEditAdapter as f, type FieldFilter as g, type FieldApprovalState as h, type FieldApproval as i, type FeedtackDeviceMeta as j, type FeedtackPageMeta as k, type FeedtackViewportMeta as l, type FeedtackPinTarget as m, type FeedtackArchive as n, type FeedtackBoundingRect as o, type FeedtackPin as p, type FeedtackScope as q, type FeedtackSentiment as r, type FeedtackUser as s, type FieldChange as t, type FocusedFieldInfo as u, isContentAdapter as v, isContentEditAdapter as w, warnIfNotContentAdapter as x, warnIfNotContentEditAdapter as y };

package/dist/{chunk-3INDOI4N.js → chunk-GD2SY64K.js}

@@ -1,3 +1,40 @@
+// src/capture/content.ts
+var DEV = typeof process !== "undefined" && process.env.NODE_ENV !== "production";
+function scanFields(root) {
+  const searchRoot = root ?? document.body;
+  const nodes = Array.from(
+    searchRoot.querySelectorAll("[data-feedtack-field]")
+  );
+  const seen = /* @__PURE__ */ new Map();
+  const fields = [];
+  for (const el of nodes) {
+    const fieldPath = el.dataset.feedtackField ?? "";
+    if (!fieldPath) continue;
+    seen.set(fieldPath, (seen.get(fieldPath) ?? 0) + 1);
+    fields.push({
+      fieldPath,
+      element: el,
+      content: el.textContent ?? ""
+    });
+  }
+  if (DEV) {
+    for (const [path, count] of seen) {
+      if (count > 1) {
+        console.warn(
+          `[feedtack] Duplicate data-feedtack-field="${path}" found ${count} times on this page. Field paths must be unique.`
+        );
+      }
+    }
+  }
+  return fields;
+}
+async function hashField(content) {
+  const encoded = new TextEncoder().encode(content);
+  const buffer = await crypto.subtle.digest("SHA-256", encoded);
+  const hex = Array.from(new Uint8Array(buffer)).map((b) => b.toString(16).padStart(2, "0")).join("");
+  return hex.slice(0, 12);
+}
+
 // src/capture/meta.ts
 function getViewportMeta() {
   return {
@@ -406,6 +443,8 @@ var FEEDTACK_MODAL_STYLES = `
     right: 24px;
     width: 360px;
     max-height: 70vh;
+    margin: 0;
+    padding: 0;
     background: var(--ft-bg);
     border: 1px solid var(--ft-border);
     border-radius: calc(var(--ft-radius) + 4px);
@@ -416,6 +455,10 @@ var FEEDTACK_MODAL_STYLES = `
     overflow: hidden;
   }
 
+  .feedtack-modal::backdrop {
+    background: transparent;
+  }
+
   .feedtack-modal-header {
     display: flex;
     align-items: center;
@@ -621,6 +664,7 @@ var FEEDTACK_MODAL_STYLES = `
       bottom: 64px;
       width: 100vw;
       max-height: 85vh;
+      margin: 0;
       border-radius: var(--ft-radius) var(--ft-radius) 0 0;
       border-left: none;
       border-right: none;
@@ -1220,7 +1264,32 @@ var FeedtackEngine = class {
   }
 };
 
+// src/types/adapter.ts
+function isContentEditAdapter(adapter) {
+  return isContentAdapter(adapter) && typeof adapter.loadFields === "function" && typeof adapter.saveField === "function";
+}
+function warnIfNotContentEditAdapter(adapter, method) {
+  if (DEV2 && !isContentEditAdapter(adapter)) {
+    console.warn(
+      `[feedtack] ${method}() called but the adapter does not implement ContentEditAdapter. Content editing features are unavailable with this adapter.`
+    );
+  }
+}
+var DEV2 = typeof process !== "undefined" && process.env.NODE_ENV !== "production";
+function isContentAdapter(adapter) {
+  return typeof adapter === "object" && adapter !== null && typeof adapter.approve === "function" && typeof adapter.revokeApproval === "function" && typeof adapter.loadApprovals === "function";
+}
+function warnIfNotContentAdapter(adapter, method) {
+  if (DEV2 && !isContentAdapter(adapter)) {
+    console.warn(
+      `[feedtack] ${method}() called but the adapter does not implement ContentAdapter. Content approval features are unavailable with this adapter.`
+    );
+  }
+}
+
 export {
+  scanFields,
+  hashField,
   getViewportMeta,
   getPageMeta,
   getDeviceMeta,
@@ -1231,5 +1300,9 @@ export {
   SCHEMA_VERSION,
   generateId,
   themeToCSS,
-  FeedtackEngine
+  FeedtackEngine,
+  isContentEditAdapter,
+  warnIfNotContentEditAdapter,
+  isContentAdapter,
+  warnIfNotContentAdapter
 };

package/dist/index.d.ts

@@ -1,5 +1,7 @@
-import { F as FeedtackAdapter, a as FeedtackPayload, b as FeedtackReply, c as FeedtackResolution, d as FeedtackFilter, e as FeedbackItem, f as FeedtackDeviceMeta, g as FeedtackPageMeta, h as FeedtackViewportMeta, i as FeedtackPinTarget, j as FeedtackEngineOpts, k as FeedtackEngineState, l as FeedtackStateListener } from './types-Cu4Oahg4.js';
-export { A as AncestorNode, m as FeedtackArchive, n as FeedtackBoundingRect, o as FeedtackFlushEvent, p as FeedtackPin, q as FeedtackScope, r as FeedtackSentiment, s as FeedtackTheme, t as FeedtackUser, S as SCHEMA_VERSION, u as generateId, v as themeToCSS } from './types-Cu4Oahg4.js';
+import { F as FeedtackAdapter, a as FeedtackPayload, b as FeedtackReply, c as FeedtackResolution, d as FeedtackFilter, e as FeedbackItem, C as ContentAdapter, f as ContentEditAdapter, g as FieldFilter, h as FieldApprovalState, i as FieldApproval, j as FeedtackDeviceMeta, k as FeedtackPageMeta, l as FeedtackViewportMeta, m as FeedtackPinTarget } from './adapter-Cn59URIG.js';
+export { A as AncestorNode, n as FeedtackArchive, o as FeedtackBoundingRect, p as FeedtackPin, q as FeedtackScope, r as FeedtackSentiment, s as FeedtackUser, t as FieldChange, u as FocusedFieldInfo, S as SCHEMA_VERSION, v as isContentAdapter, w as isContentEditAdapter, x as warnIfNotContentAdapter, y as warnIfNotContentEditAdapter } from './adapter-Cn59URIG.js';
+import { F as FeedtackEngineOpts, a as FeedtackEngineState, b as FeedtackStateListener } from './types-CHrWe7xT.js';
+export { c as FeedtackFlushEvent, d as FeedtackTheme, g as generateId, t as themeToCSS } from './types-CHrWe7xT.js';
 
 /** Development adapter — logs all operations to the browser console */
 declare class ConsoleAdapter implements FeedtackAdapter {
@@ -10,23 +12,6 @@ declare class ConsoleAdapter implements FeedtackAdapter {
     loadFeedback(_filter?: FeedtackFilter): Promise<FeedbackItem[]>;
 }
 
-interface DiskAdapterConfig {
-    /** Directory to store JSON files in. Default: '.feedback' */
-    directory?: string;
-}
-/** Node.js adapter — persists each feedback item as a JSON file on disk */
-declare class DiskAdapter implements FeedtackAdapter {
-    private dir;
-    constructor(config?: DiskAdapterConfig);
-    submit(payload: FeedtackPayload): Promise<void>;
-    reply(feedbackId: string, reply: Omit<FeedtackReply, 'id' | 'feedbackId'>): Promise<void>;
-    resolve(feedbackId: string, resolution: Omit<FeedtackResolution, 'feedbackId'>): Promise<void>;
-    archive(feedbackId: string, userId: string): Promise<void>;
-    loadFeedback(filter?: FeedtackFilter): Promise<FeedbackItem[]>;
-    private read;
-    private write;
-}
-
 interface LocalStorageAdapterConfig {
     /** localStorage key. Default: 'feedtack' */
     key?: string;
@@ -51,9 +36,13 @@ interface WebhookAdapterConfig {
     updateUrl?: string;
     /** Required: async function that returns persisted feedback items */
     loadFeedback: (filter?: FeedtackFilter) => Promise<FeedbackItem[]>;
+    /** Optional: async function that returns stored field approvals */
+    loadApprovals?: (filter?: FieldFilter) => Promise<FieldApprovalState[]>;
+    /** Optional: async function that returns all stored field values for hydration */
+    loadFields?: () => Promise<Record<string, string>>;
 }
 /** Production adapter — POSTs feedback as JSON to a webhook endpoint */
-declare class WebhookAdapter implements FeedtackAdapter {
+declare class WebhookAdapter implements FeedtackAdapter, ContentAdapter, ContentEditAdapter {
     private config;
     constructor(config: WebhookAdapterConfig);
     private post;
@@ -62,7 +51,27 @@ declare class WebhookAdapter implements FeedtackAdapter {
     resolve(feedbackId: string, resolution: Omit<FeedtackResolution, 'feedbackId'>): Promise<void>;
     archive(feedbackId: string, userId: string): Promise<void>;
     loadFeedback(filter?: FeedtackFilter): Promise<FeedbackItem[]>;
+    approve(fieldPath: string, approval: FieldApproval): Promise<void>;
+    revokeApproval(fieldPath: string, userId: string): Promise<void>;
+    loadApprovals(filter?: FieldFilter): Promise<FieldApprovalState[]>;
+    loadFields(): Promise<Record<string, string>>;
+    saveField(fieldPath: string, value: string): Promise<void>;
+}
+
+interface ScannedField {
+    fieldPath: string;
+    element: Element;
+    content: string;
 }
+/**
+ * Scans the DOM for elements annotated with data-feedtack-field.
+ * @param root - Element to search within. Defaults to document.body.
+ */
+declare function scanFields(root?: Element): ScannedField[];
+/**
+ * Computes a 12-character truncated SHA-256 hash of a string using Web Crypto API.
+ */
+declare function hashField(content: string): Promise<string>;
 
 declare function getViewportMeta(): FeedtackViewportMeta;
 declare function getPageMeta(): FeedtackPageMeta;
@@ -127,4 +136,4 @@ declare class FeedtackEngine {
     handleArchive(id: string): Promise<void>;
 }
 
-export { ConsoleAdapter, DiskAdapter, type DiskAdapterConfig, FeedbackItem, FeedtackAdapter, FeedtackDeviceMeta, FeedtackEngine, FeedtackEngineOpts, FeedtackEngineState, FeedtackFilter, FeedtackPageMeta, FeedtackPayload, FeedtackPinTarget, FeedtackReply, FeedtackResolution, FeedtackStateListener, FeedtackViewportMeta, LocalStorageAdapter, type LocalStorageAdapterConfig, WebhookAdapter, type WebhookAdapterConfig, getCSSSelector, getDeviceMeta, getPageMeta, getPinCoords, getTargetMeta, getViewportMeta };
+export { ConsoleAdapter, ContentAdapter, ContentEditAdapter, FeedbackItem, FeedtackAdapter, FeedtackDeviceMeta, FeedtackEngine, FeedtackEngineOpts, FeedtackEngineState, FeedtackFilter, FeedtackPageMeta, FeedtackPayload, FeedtackPinTarget, FeedtackReply, FeedtackResolution, FeedtackStateListener, FeedtackViewportMeta, FieldApproval, FieldApprovalState, FieldFilter, LocalStorageAdapter, type LocalStorageAdapterConfig, WebhookAdapter, type WebhookAdapterConfig, getCSSSelector, getDeviceMeta, getPageMeta, getPinCoords, getTargetMeta, getViewportMeta, hashField, scanFields };

package/dist/index.js

@@ -8,8 +8,14 @@ import {
   getPinCoords,
   getTargetMeta,
   getViewportMeta,
-  themeToCSS
-} from "./chunk-3INDOI4N.js";
+  hashField,
+  isContentAdapter,
+  isContentEditAdapter,
+  scanFields,
+  themeToCSS,
+  warnIfNotContentAdapter,
+  warnIfNotContentEditAdapter
+} from "./chunk-GD2SY64K.js";
 
 // src/adapters/ConsoleAdapter.ts
 var ConsoleAdapter = class {
@@ -31,85 +37,6 @@ var ConsoleAdapter = class {
   }
 };
 
-// src/adapters/DiskAdapter.ts
-import { readdir, readFile, writeFile, mkdir } from "fs/promises";
-import { join } from "path";
-var DiskAdapter = class {
-  constructor(config = {}) {
-    this.dir = config.directory ?? ".feedback";
-  }
-  async submit(payload) {
-    await mkdir(this.dir, { recursive: true });
-    const item = {
-      payload,
-      replies: [],
-      resolutions: [],
-      archives: []
-    };
-    await this.write(payload.id, item);
-  }
-  async reply(feedbackId, reply) {
-    const item = await this.read(feedbackId);
-    item.replies.push({
-      id: `r_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 7)}`,
-      feedbackId,
-      ...reply
-    });
-    await this.write(feedbackId, item);
-  }
-  async resolve(feedbackId, resolution) {
-    const item = await this.read(feedbackId);
-    item.resolutions.push({ feedbackId, ...resolution });
-    await this.write(feedbackId, item);
-  }
-  async archive(feedbackId, userId) {
-    const item = await this.read(feedbackId);
-    item.archives.push({
-      feedbackId,
-      archivedBy: { id: userId, name: "", role: "" },
-      timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    });
-    await this.write(feedbackId, item);
-  }
-  async loadFeedback(filter) {
-    let files;
-    try {
-      await mkdir(this.dir, { recursive: true });
-      files = (await readdir(this.dir)).filter((f) => f.endsWith(".json"));
-    } catch {
-      return [];
-    }
-    const items = await Promise.all(
-      files.map(
-        async (f) => JSON.parse(
-          await readFile(join(this.dir, f), "utf-8")
-        )
-      )
-    );
-    if (!filter) return items;
-    return items.filter((item) => {
-      if (filter.scope && item.payload.scope !== filter.scope) return false;
-      if (filter.pathname && item.payload.page.pathname !== filter.pathname)
-        return false;
-      if (filter.url && item.payload.page.url !== filter.url) return false;
-      if (filter.userId && item.payload.submittedBy.id !== filter.userId)
-        return false;
-      return true;
-    });
-  }
-  async read(id) {
-    return JSON.parse(
-      await readFile(join(this.dir, `${id}.json`), "utf-8")
-    );
-  }
-  async write(id, item) {
-    await writeFile(
-      join(this.dir, `${id}.json`),
-      JSON.stringify(item, null, 2)
-    );
-  }
-};
-
 // src/adapters/LocalStorageAdapter.ts
 var LocalStorageAdapter = class {
   constructor(config = {}) {
@@ -213,10 +140,40 @@ var WebhookAdapter = class {
   async loadFeedback(filter) {
     return this.config.loadFeedback(filter);
   }
+  // ContentAdapter implementation
+  async approve(fieldPath, approval) {
+    const url = this.config.updateUrl ?? this.config.submitUrl;
+    await this.post(url, { type: "approve", fieldPath, ...approval });
+  }
+  async revokeApproval(fieldPath, userId) {
+    const url = this.config.updateUrl ?? this.config.submitUrl;
+    await this.post(url, { type: "revoke", fieldPath, userId });
+  }
+  async loadApprovals(filter) {
+    if (this.config.loadApprovals) {
+      return this.config.loadApprovals(filter);
+    }
+    return [];
+  }
+  // ContentEditAdapter implementation
+  async loadFields() {
+    if (this.config.loadFields) {
+      return this.config.loadFields();
+    }
+    return {};
+  }
+  async saveField(fieldPath, value) {
+    const url = this.config.updateUrl ?? this.config.submitUrl;
+    await this.post(url, {
+      type: "save-field",
+      fieldPath,
+      value,
+      clearApproval: true
+    });
+  }
 };
 export {
   ConsoleAdapter,
-  DiskAdapter,
   FeedtackEngine,
   LocalStorageAdapter,
   SCHEMA_VERSION,
@@ -228,5 +185,11 @@ export {
   getPinCoords,
   getTargetMeta,
   getViewportMeta,
-  themeToCSS
+  hashField,
+  isContentAdapter,
+  isContentEditAdapter,
+  scanFields,
+  themeToCSS,
+  warnIfNotContentAdapter,
+  warnIfNotContentEditAdapter
 };

package/dist/node/index.d.ts

@@ -0,0 +1,27 @@
+import { F as FeedtackAdapter, C as ContentAdapter, f as ContentEditAdapter, a as FeedtackPayload, b as FeedtackReply, c as FeedtackResolution, d as FeedtackFilter, e as FeedbackItem, i as FieldApproval, g as FieldFilter, h as FieldApprovalState } from '../adapter-Cn59URIG.js';
+
+interface DiskAdapterConfig {
+    /** Directory to store JSON files in. Default: '.feedback' */
+    directory?: string;
+}
+/** Node.js adapter — persists each feedback item as a JSON file on disk */
+declare class DiskAdapter implements FeedtackAdapter, ContentAdapter, ContentEditAdapter {
+    private dir;
+    private approvalsDir;
+    private fieldsDir;
+    constructor(config?: DiskAdapterConfig);
+    submit(payload: FeedtackPayload): Promise<void>;
+    reply(feedbackId: string, reply: Omit<FeedtackReply, 'id' | 'feedbackId'>): Promise<void>;
+    resolve(feedbackId: string, resolution: Omit<FeedtackResolution, 'feedbackId'>): Promise<void>;
+    archive(feedbackId: string, userId: string): Promise<void>;
+    loadFeedback(filter?: FeedtackFilter): Promise<FeedbackItem[]>;
+    approve(fieldPath: string, approval: FieldApproval): Promise<void>;
+    revokeApproval(fieldPath: string, userId: string): Promise<void>;
+    loadApprovals(filter?: FieldFilter): Promise<FieldApprovalState[]>;
+    loadFields(): Promise<Record<string, string>>;
+    saveField(fieldPath: string, value: string): Promise<void>;
+    private read;
+    private write;
+}
+
+export { DiskAdapter, type DiskAdapterConfig };