@fabrika/canvas-kernel 0.1.45 → 0.2.0

package/src/engine/watcher.ts

@@ -1,84 +1,87 @@
-import { watch, existsSync, readFileSync, readdirSync } from "fs";
-import { join } from "path";
-import { compileJsx, type CanvasComponents } from "./compiler";
-import type { SessionManager } from "./session";
+import { existsSync, readdirSync, readFileSync, watch } from 'fs'
+import { join } from 'path'
+import { type CanvasComponents, compileJsx } from './compiler'
+import type { SessionManager } from './session'
 
-type BroadcastFn = (sessionId: string) => void;
+type BroadcastFn = (sessionId: string) => void
 
 export interface WatchOptions {
-  /** Scratch dir for recompiles, from `createCanvasPaths()`. */
-  tempDir?: string;
-  /** Host components, same value the push path compiles with — a recompile
-   *  that dropped them would fail on canvases the original push accepted. */
-  components?: CanvasComponents;
+	/** Scratch dir for recompiles, from `createCanvasPaths()`. */
+	tempDir?: string
+	/** Host components, same value the push path compiles with — a recompile
+	 *  that dropped them would fail on canvases the original push accepted. */
+	components?: CanvasComponents
 }
 
-const watchers = new Map<string, ReturnType<typeof watch>[]>();
+const watchers = new Map<string, ReturnType<typeof watch>[]>()
 
 export function watchSession(
-  sessionId: string,
-  sessionManager: SessionManager,
-  broadcast: BroadcastFn,
-  options: WatchOptions = {},
+	sessionId: string,
+	sessionManager: SessionManager,
+	broadcast: BroadcastFn,
+	options: WatchOptions = {},
 ) {
-  // Close existing watchers for this session
-  unwatchSession(sessionId);
+	// Close existing watchers for this session
+	unwatchSession(sessionId)
 
-  const session = sessionManager.get(sessionId);
-  if (!session) return;
+	const session = sessionManager.get(sessionId)
+	if (!session) return
 
-  const rev = session.currentRevision;
-  const canvasFiles = sessionManager.getRevisionCanvasFiles(sessionId, rev);
-  if (canvasFiles.length === 0) return;
+	const rev = session.currentRevision
+	const canvasFiles = sessionManager.getRevisionCanvasFiles(sessionId, rev)
+	if (canvasFiles.length === 0) return
 
-  const fileWatchers: ReturnType<typeof watch>[] = [];
-  const debounceTimers = new Map<string, ReturnType<typeof setTimeout>>();
+	const fileWatchers: ReturnType<typeof watch>[] = []
+	const debounceTimers = new Map<string, ReturnType<typeof setTimeout>>()
 
-  for (const filename of canvasFiles) {
-    const filePath = sessionManager.getRevisionJsxPath(sessionId, rev, filename);
-    if (!existsSync(filePath)) continue;
+	for (const filename of canvasFiles) {
+		const filePath = sessionManager.getRevisionJsxPath(sessionId, rev, filename)
+		if (!existsSync(filePath)) continue
 
-    const watcher = watch(filePath, async (event) => {
-      if (event !== "change") return;
+		const watcher = watch(filePath, async (event) => {
+			if (event !== 'change') return
 
-      // Debounce per-file
-      const existing = debounceTimers.get(filename);
-      if (existing) clearTimeout(existing);
+			// Debounce per-file
+			const existing = debounceTimers.get(filename)
+			if (existing) clearTimeout(existing)
 
-      debounceTimers.set(filename, setTimeout(async () => {
-        debounceTimers.delete(filename);
-        try {
-          const jsx = readFileSync(filePath, "utf-8");
-          const result = await compileJsx(jsx, {
-            projectRoot: session.projectRoot,
-            tempDir: options.tempDir,
-            ...(options.components ? { components: options.components } : {}),
-          });
-          if (result.ok) {
-            sessionManager.saveCompiled(sessionId, filename, result.js, rev);
-            broadcast(sessionId);
-          }
-        } catch {}
-      }, 200));
-    });
+			debounceTimers.set(
+				filename,
+				setTimeout(async () => {
+					debounceTimers.delete(filename)
+					try {
+						const jsx = readFileSync(filePath, 'utf-8')
+						const result = await compileJsx(jsx, {
+							projectRoot: session.projectRoot,
+							tempDir: options.tempDir,
+							...(options.components ? { components: options.components } : {}),
+						})
+						if (result.ok) {
+							sessionManager.saveCompiled(sessionId, filename, result.js, rev)
+							broadcast(sessionId)
+						}
+					} catch {}
+				}, 200),
+			)
+		})
 
-    fileWatchers.push(watcher);
-  }
+		fileWatchers.push(watcher)
+	}
 
-  watchers.set(sessionId, fileWatchers);
+	watchers.set(sessionId, fileWatchers)
 }
 
 export function unwatchSession(sessionId: string) {
-  const sessionWatchers = watchers.get(sessionId);
-  if (sessionWatchers) {
-    for (const w of sessionWatchers) w.close();
-    watchers.delete(sessionId);
-  }
+	const sessionWatchers = watchers.get(sessionId)
+	if (sessionWatchers) {
+		for (const w of sessionWatchers) w.close()
+		watchers.delete(sessionId)
+	}
 }
 
 export function unwatchAll() {
-  for (const [, sessionWatchers] of watchers) {
-    for (const w of sessionWatchers) w.close();
-  }
-  watchers.clear();
+	for (const [, sessionWatchers] of watchers) {
+		for (const w of sessionWatchers) w.close()
+	}
+	watchers.clear()
 }

package/src/engine/websocket.ts

@@ -4,156 +4,158 @@
  * so a delivery closes it.
  */
 
-import { browserFrame, createNotificationChannel, type ChannelSocket, type TopicChannel } from "./channel";
-import type { SessionManager, RemoteFeedbackEntry } from "./session";
+import { browserFrame, type ChannelSocket, createNotificationChannel, type TopicChannel } from '@fabrika/daemon-kit'
+import type { RemoteFeedbackEntry, SessionManager } from './session'
 
-export type WSData = { type: "browser" | "wait"; sessionId: string };
+export type WSData = { type: 'browser' | 'wait'; sessionId: string }
 
 export interface CanvasSocket extends ChannelSocket {
-  data: WSData;
+	data: WSData
 }
 
 interface CanvasRenderError {
-  revision: number;
-  filename: string;
-  message: string;
-  stack?: string;
-  componentStack?: string;
+	revision: number
+	filename: string
+	message: string
+	stack?: string
+	componentStack?: string
 }
 
 interface SubmitFrame {
-  type: "submit";
-  feedback: string;
+	type: 'submit'
+	feedback: string
 }
 
 interface RenderErrorFrame {
-  type: "render-error";
-  error: CanvasRenderError;
+	type: 'render-error'
+	error: CanvasRenderError
 }
 
 function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+	return typeof value === 'object' && value !== null && !Array.isArray(value)
 }
 
 function isCanvasRenderError(value: unknown): value is CanvasRenderError {
-  return typeof value === "object" && value !== null
-    && "revision" in value && Number.isInteger(value.revision)
-    && "filename" in value && typeof value.filename === "string"
-    && "message" in value && typeof value.message === "string"
-    && (!("stack" in value) || value.stack === undefined || typeof value.stack === "string")
-    && (!("componentStack" in value) || value.componentStack === undefined || typeof value.componentStack === "string");
+	return typeof value === 'object' && value !== null
+		&& 'revision' in value && Number.isInteger(value.revision)
+		&& 'filename' in value && typeof value.filename === 'string'
+		&& 'message' in value && typeof value.message === 'string'
+		&& (!('stack' in value) || value.stack === undefined || typeof value.stack === 'string')
+		&& (!('componentStack' in value) || value.componentStack === undefined || typeof value.componentStack === 'string')
 }
 
 function isSubmitFrame(value: unknown): value is SubmitFrame {
-  return isRecord(value) && value.type === "submit" && typeof value.feedback === "string";
+	return isRecord(value) && value['type'] === 'submit' && typeof value['feedback'] === 'string'
 }
 
 function isRenderErrorFrame(value: unknown): value is RenderErrorFrame {
-  return isRecord(value) && value.type === "render-error" && isCanvasRenderError(value.error);
+	return isRecord(value) && value['type'] === 'render-error' && isCanvasRenderError(value['error'])
 }
 
 export interface WebSocketManagerOptions {
-  /**
-   * Who marks feedback consumed once a waiting client has been handed it.
-   *
-   * `"on-delivery"` (default) clears it in the same step, so the same feedback
-   * can never be delivered twice — right when the waiting client *is* the
-   * consumer. `"external"` leaves it pending for a separate gate to claim
-   * through the consume endpoint, for hosts where delivery and consumption are
-   * different steps.
-   */
-  feedbackConsumption?: "on-delivery" | "external";
+	/**
+	 * Who marks feedback consumed once a waiting client has been handed it.
+	 *
+	 * `"on-delivery"` (default) clears it in the same step, so the same feedback
+	 * can never be delivered twice — right when the waiting client *is* the
+	 * consumer. `"external"` leaves it pending for a separate gate to claim
+	 * through the consume endpoint, for hosts where delivery and consumption are
+	 * different steps.
+	 */
+	feedbackConsumption?: 'on-delivery' | 'external'
 }
 
 export function createWebSocketManager(
-  sessionManager: SessionManager,
-  options: WebSocketManagerOptions = {},
+	sessionManager: SessionManager,
+	options: WebSocketManagerOptions = {},
 ) {
-  const consumeOnDelivery = (options.feedbackConsumption ?? "on-delivery") === "on-delivery";
-  const pendingRenderErrors = new Map<string, CanvasRenderError>();
-
-  /** Hands a held error to the waiters, if any showed up; the caller announces the departure. */
-  function deliverPendingRenderError(sessionId: string): boolean {
-    const error = pendingRenderErrors.get(sessionId);
-    if (!error) return false;
-    if (!channel.relayToWaiters(sessionId, { type: "render-error", error })) return false;
-    pendingRenderErrors.delete(sessionId);
-    return true;
-  }
-
-  function submit(frame: SubmitFrame, topic: TopicChannel) {
-    const sessionId = topic.topic;
-    const session = sessionManager.get(sessionId);
-    if (!session) return;
-
-    sessionManager.saveFeedback(sessionId, session.currentRevision, frame.feedback);
-    broadcastRevisionUpdate(sessionId);
-    if (!topic.hasWaiter()) return;
-
-    if (consumeOnDelivery) {
-      sessionManager.consumeFeedback(sessionId, session.currentRevision);
-      broadcastRevisionUpdate(sessionId);
-    }
-    topic.relayToWaiters({ type: "submit", feedback: frame.feedback });
-  }
-
-  function renderError(frame: RenderErrorFrame, topic: TopicChannel) {
-    const sessionId = topic.topic;
-    const session = sessionManager.get(sessionId);
-    if (!session) return;
-    if (frame.error.revision !== session.currentRevision) return;
-    if (!session.canvasFiles.includes(frame.error.filename)) return;
-
-    pendingRenderErrors.set(sessionId, frame.error);
-    if (deliverPendingRenderError(sessionId)) topic.broadcastPresence();
-  }
-
-  const channel = createNotificationChannel<CanvasSocket>({
-    roleOf: (socket) => socket.data.type,
-    topicOf: (socket) => socket.data.sessionId,
-    waiterPolicy: "close-on-delivery",
-    presenceFrame: (watching) => ({ type: "watcher-status", watching }),
-    // A render error raised before the CLI watcher connected is held for it.
-    onWaiterOpen: (topic) => { deliverPendingRenderError(topic.topic); },
-    frames: [
-      browserFrame(isSubmitFrame, submit),
-      browserFrame(isRenderErrorFrame, renderError),
-    ],
-  });
-
-  function broadcastPlanUpdate(sessionId: string) {
-    pendingRenderErrors.delete(sessionId);
-    const session = sessionManager.get(sessionId);
-    if (!session) return;
-    channel.broadcast(sessionId, {
-      type: "plan-updated",
-      currentRevision: session.currentRevision,
-      revisions: session.revisions,
-    });
-  }
-
-  function broadcastRevisionUpdate(sessionId: string) {
-    const session = sessionManager.get(sessionId);
-    if (!session) return;
-    channel.broadcast(sessionId, {
-      type: "revision-updated",
-      revisions: session.revisions,
-    });
-  }
-
-  function broadcastRemoteFeedback(sessionId: string, revision: number, entries: RemoteFeedbackEntry[]) {
-    channel.broadcast(sessionId, { type: "remote-feedback", revision, entries });
-  }
-
-  function broadcastWatcherStatus(sessionId: string) {
-    channel.broadcastPresence(sessionId);
-  }
-
-  return {
-    handlers: channel.handlers,
-    broadcastPlanUpdate,
-    broadcastRevisionUpdate,
-    broadcastWatcherStatus,
-    broadcastRemoteFeedback,
-  };
+	const consumeOnDelivery = (options.feedbackConsumption ?? 'on-delivery') === 'on-delivery'
+	const pendingRenderErrors = new Map<string, CanvasRenderError>()
+
+	/** Hands a held error to the waiters, if any showed up; the caller announces the departure. */
+	function deliverPendingRenderError(sessionId: string): boolean {
+		const error = pendingRenderErrors.get(sessionId)
+		if (!error) return false
+		if (!channel.relayToWaiters(sessionId, { type: 'render-error', error })) return false
+		pendingRenderErrors.delete(sessionId)
+		return true
+	}
+
+	function submit(frame: SubmitFrame, topic: TopicChannel) {
+		const sessionId = topic.topic
+		const session = sessionManager.get(sessionId)
+		if (!session) return
+
+		sessionManager.saveFeedback(sessionId, session.currentRevision, frame.feedback)
+		broadcastRevisionUpdate(sessionId)
+		if (!topic.hasWaiter()) return
+
+		if (consumeOnDelivery) {
+			sessionManager.consumeFeedback(sessionId, session.currentRevision)
+			broadcastRevisionUpdate(sessionId)
+		}
+		topic.relayToWaiters({ type: 'submit', feedback: frame.feedback })
+	}
+
+	function renderError(frame: RenderErrorFrame, topic: TopicChannel) {
+		const sessionId = topic.topic
+		const session = sessionManager.get(sessionId)
+		if (!session) return
+		if (frame.error.revision !== session.currentRevision) return
+		if (!session.canvasFiles.includes(frame.error.filename)) return
+
+		pendingRenderErrors.set(sessionId, frame.error)
+		if (deliverPendingRenderError(sessionId)) topic.broadcastPresence()
+	}
+
+	const channel = createNotificationChannel<CanvasSocket>({
+		roleOf: (socket) => socket.data.type,
+		topicOf: (socket) => socket.data.sessionId,
+		waiterPolicy: 'close-on-delivery',
+		presenceFrame: (watching) => ({ type: 'watcher-status', watching }),
+		// A render error raised before the CLI watcher connected is held for it.
+		onWaiterOpen: (topic) => {
+			deliverPendingRenderError(topic.topic)
+		},
+		frames: [
+			browserFrame(isSubmitFrame, submit),
+			browserFrame(isRenderErrorFrame, renderError),
+		],
+	})
+
+	function broadcastPlanUpdate(sessionId: string) {
+		pendingRenderErrors.delete(sessionId)
+		const session = sessionManager.get(sessionId)
+		if (!session) return
+		channel.broadcast(sessionId, {
+			type: 'plan-updated',
+			currentRevision: session.currentRevision,
+			revisions: session.revisions,
+		})
+	}
+
+	function broadcastRevisionUpdate(sessionId: string) {
+		const session = sessionManager.get(sessionId)
+		if (!session) return
+		channel.broadcast(sessionId, {
+			type: 'revision-updated',
+			revisions: session.revisions,
+		})
+	}
+
+	function broadcastRemoteFeedback(sessionId: string, revision: number, entries: RemoteFeedbackEntry[]) {
+		channel.broadcast(sessionId, { type: 'remote-feedback', revision, entries })
+	}
+
+	function broadcastWatcherStatus(sessionId: string) {
+		channel.broadcastPresence(sessionId)
+	}
+
+	return {
+		handlers: channel.handlers,
+		broadcastPlanUpdate,
+		broadcastRevisionUpdate,
+		broadcastWatcherStatus,
+		broadcastRemoteFeedback,
+	}
 }

package/annotate.ts

@@ -1,94 +0,0 @@
-// @fabrika/canvas-kernel/annotate — the annotation surface.
-//
-// Ring 2: collecting a reader's notes on something, and getting them back out
-// as markdown an agent can act on. What a note points at is a locator strategy
-// (text, block, image region), so a host annotates its own kind of thing by
-// writing one target; the list, the editor, the draft and the markdown do not
-// change. Grouping, headings and navigation stay with the host — this ring has
-// no taxonomy of its own.
-//
-// Not yet a severed dependency: `AnnotationProvider` still imports the canvas
-// response-pruning from `generateMarkdown`, so a bundle built off this entry
-// carries that along. The export list is the API statement; the import graph
-// has one edge left to cut.
-
-// --- Annotation state ------------------------------------------------------
-export { AnnotationProvider } from "./src/client/AnnotationProvider";
-export type { PersistedState } from "./src/client/AnnotationProvider";
-export { useAnnotations, AnnotationCtx, SessionContext } from "./src/client/runtime";
-export type {
-  Annotation,
-  AnnotationAttachment,
-  AnnotationAuthor,
-  AnnotationContext,
-  AnnotationContextValue,
-} from "./src/client/runtime";
-export {
-  annotationDraftKey,
-  carryUnsubmittedDraft,
-  clearPersistedDraft,
-} from "./src/client/annotationDraft";
-export type { AnnotationDraftPhase } from "./src/client/annotationDraft";
-
-// --- Surface ---------------------------------------------------------------
-export { AnnotationList } from "./src/client/AnnotationList";
-export type { AnnotationListProps } from "./src/client/AnnotationList";
-export { AnnotationDraftFooter } from "./src/client/AnnotationDraftFooter";
-export type { AnnotationDraftFooterProps } from "./src/client/AnnotationDraftFooter";
-export { AnnotationEditor, imageToUrl } from "./src/client/AnnotationEditor";
-export { Popover, AnnotationPopover, AnnotationCreatePopover, AnnotationEditPopover } from "./src/client/Popover";
-
-// --- Drawing ---------------------------------------------------------------
-export { useTextAnnotation } from "./src/client/useTextAnnotation";
-export { useRegionAnnotation } from "./src/client/useRegionAnnotation";
-
-// --- Locator strategies ----------------------------------------------------
-export { sealTarget } from "./src/client/annotationTarget";
-export type { AnnotationTarget, SealedAnnotationTarget, TargetAnnotation } from "./src/client/annotationTarget";
-export { blockTarget } from "./src/client/blockTarget";
-export type { BlockLocator } from "./src/client/blockTarget";
-export { textTarget } from "./src/client/textTarget";
-export type { TextLocator } from "./src/client/textTarget";
-export {
-  createRegionOverlay,
-  describeRegion,
-  findRegionHost,
-  isDrawableRegion,
-  regionBetween,
-  regionPointIn,
-  regionStyle,
-  regionTarget,
-  REGION_HOST_ATTR,
-  REGION_UNITS,
-} from "./src/client/regionTarget";
-export type { RegionBox, RegionLocator, RegionPoint, RegionShape } from "./src/client/regionTarget";
-export {
-  ANNOTATION_TARGETS,
-  ANNOTATABLE_SELECTOR,
-  BLOCK_SELECTOR,
-  describeSnippet,
-  findAnnotationElement,
-  findSnippetElement,
-  getBlockSnippet,
-  restoreAnnotationTargets,
-} from "./src/client/annotationDom";
-
-// --- Marks -----------------------------------------------------------------
-export {
-  restoreMarks,
-  renameMarkId,
-  setMarkActive,
-  unwrapMarks,
-  updateAllMarkStates,
-  wrapRangeWithMark,
-} from "./src/client/highlightRange";
-
-// --- Feedback out ----------------------------------------------------------
-export { renderAnnotation } from "./src/client/annotationMarkdown";
-export type { RenderableAnnotation } from "./src/client/annotationMarkdown";
-export { extractContext, formatSnippetInContext } from "./src/client/annotationContext";
-
-// --- Host-provided context -------------------------------------------------
-export { CanvasHostContext, localCanvasHost, useCanvasHost } from "./src/client/hostContext";
-export type { CanvasHost } from "./src/client/hostContext";
-export { autoResizeTextarea, fileAnnotationPath, generateAnnotationId, hostAcceptsUploads } from "./src/client/utils";

package/daemon.ts

@@ -1,46 +0,0 @@
-// @fabrika/canvas-kernel/daemon — the host-agnostic daemon runtime.
-//
-// Ring 1: everything a local daemon needs that knows nothing about canvases —
-// the WebSocket notification channel, the CLI waiter, process lifecycle, route
-// dispatch, and the on-disk layout. A host whose domain is not canvases (Figma
-// screens, say) takes this entry and none of the canvas engine behind `/server`.
-
-// --- WebSocket notification channel ----------------------------------------
-export { createNotificationChannel, browserFrame } from "./src/engine/channel";
-export type {
-  ChannelRole,
-  ChannelSocket,
-  TopicChannel,
-  RelayOptions,
-  BrowserFrameHandler,
-  NotificationChannel,
-  NotificationChannelOptions,
-} from "./src/engine/channel";
-
-// --- CLI waiter ------------------------------------------------------------
-export { waitForEvent, WaitError } from "./src/engine/waiter";
-export type { WaiterSocket, WaitVerdict, WaitOptions, WaitMessages, WaitFailure } from "./src/engine/waiter";
-
-// --- Daemon process lifecycle ----------------------------------------------
-export { createDaemonLifecycle, DaemonStartError } from "./src/engine/lifecycle";
-export type {
-  DaemonLifecycle,
-  DaemonLifecycleConfig,
-  DaemonHealth,
-  DaemonHealthUp,
-  DaemonHealthDown,
-  DaemonPid,
-  DaemonStopResult,
-  DaemonStopReason,
-  DaemonEvent,
-  DaemonTimeouts,
-} from "./src/engine/lifecycle";
-
-// --- Router / HTTP ---------------------------------------------------------
-export { dispatch } from "./src/engine/router";
-export type { Route, RouteHandler } from "./src/engine/router";
-export { jsonResponse, corsHeaders } from "./src/engine/http-utils";
-
-// --- On-disk layout --------------------------------------------------------
-export { createCanvasPaths } from "./src/engine/paths";
-export type { CanvasPaths, CanvasPathsConfig } from "./src/engine/paths";

package/src/client/AnnotationDraftFooter.tsx

@@ -1,76 +0,0 @@
-import type React from "react";
-import { useAnnotations } from "./AnnotationProvider";
-import { autoResizeTextarea } from "./utils";
-
-/**
- * The foot of a draft: the note that belongs to no one annotation, and the
- * action that sends the draft off.
- *
- * What counts as content, and what the payload looks like, is the host's —
- * hence `hasContent` and a bare `onSubmit`. The two slots are where a host
- * hangs whatever else its submit step needs (a preview button, a validation
- * notice) without this component learning about it.
- */
-export interface AnnotationDraftFooterProps {
-  /** Whether the draft says anything. Hosts count more than annotations and
-   *  the general note, so they decide. */
-  hasContent: boolean;
-  onSubmit: () => void;
-  /** Submitting an empty draft — an explicit "nothing to say", not a no-op. */
-  onSubmitEmpty: () => void;
-  /** Sits between the note and the actions: validation, status, a warning. */
-  notice?: React.ReactNode;
-  /** Sits left of the submit button, sharing the row. */
-  secondaryAction?: React.ReactNode;
-  placeholder?: string;
-  submitLabel?: string;
-  emptyLabel?: string;
-}
-
-export function AnnotationDraftFooter({
-  hasContent, onSubmit, onSubmitEmpty, notice, secondaryAction,
-  placeholder = "General notes...",
-  submitLabel = "Submit",
-  emptyLabel = "Submit without feedback",
-}: AnnotationDraftFooterProps) {
-  const { generalNote, setGeneralNote } = useAnnotations();
-
-  return (
-    <>
-      {/* General note — seamless */}
-      <div className="border-t border-border-subtle px-4 py-3 flex-shrink-0">
-        <textarea
-          value={generalNote}
-          onChange={(e) => setGeneralNote(e.currentTarget.value)}
-          className="w-full bg-transparent text-[13px] font-body text-text-primary resize-none leading-relaxed p-0 border-none ring-0 shadow-none outline-none focus:outline-none focus:ring-0 focus:border-none placeholder:text-text-disabled min-h-[40px]"
-          placeholder={placeholder}
-          onInput={(e) => autoResizeTextarea(e.currentTarget, 40)}
-          ref={(el) => { if (el) autoResizeTextarea(el, 40); }}
-        />
-      </div>
-
-      {notice}
-
-      <div className="px-4 py-3 border-t border-border-subtle flex-shrink-0">
-        {hasContent ? (
-          <div className="flex gap-2">
-            {secondaryAction}
-            <button
-              onClick={onSubmit}
-              className="flex-1 py-2 rounded-lg font-body text-[13px] font-medium transition-all bg-btn-primary text-btn-primary-text hover:opacity-90 hover:-translate-y-px shadow-sm"
-            >
-              {submitLabel}
-            </button>
-          </div>
-        ) : (
-          <button
-            onClick={onSubmitEmpty}
-            className="w-full py-2 rounded-lg font-body text-[13px] font-medium border border-border-medium text-text-secondary hover:text-text-primary hover:border-border-hover hover:bg-bg-input transition-all"
-          >
-            {emptyLabel}
-          </button>
-        )}
-      </div>
-    </>
-  );
-}