Merge branch 'main' into claude/serene-dewdney-4c1527

Follow the yaak-web to yaak-wasm rename
Rebased onto main after #572 merged. The wasm crate moved to crates/yaak-wasm and crates-server/yaak-web is now the server, so the render_template export, the regenerated pkg/ and the proxy/server wording move with them.
2026-09-01 08:07:34 +02:00 · 2026-08-20 09:06:44 -07:00 · 2026-08-18 15:26:10 -07:00 · 2026-08-18 15:23:10 -07:00 · 2026-08-18 15:22:49 -07:00 · 2026-08-18 15:22:49 -07:00
123 changed files with 3629 additions and 5177 deletions
@@ -11225,7 +11225,6 @@ dependencies = [
 "base64 0.22.1",
 "log 0.4.29",
 "md5 0.8.0",
- "rusqlite",
 "serde_json",
 "tempfile",
 "thiserror 2.0.17",
@@ -11724,10 +11723,7 @@ name = "yaak-system-appearance"
 version = "0.1.0"
 dependencies = [
 "dark-light",
- "dispatch2",
 "log 0.4.29",
- "objc2-app-kit",
- "objc2-foundation 0.3.1",
 "tauri",
 ]

@@ -11779,6 +11775,7 @@ dependencies = [
 "console_error_panic_hook",
 "js-sys",
 "log 0.4.29",
+ "md5 0.7.0",
 "serde",
 "serde-wasm-bindgen",
 "serde_json",
@@ -67,14 +67,7 @@ export const EnvironmentActionsDropdown = memo(function EnvironmentActionsDropdo
        )}
        // If no environments, the button simply opens the dialog.
        // NOTE: We don't create a new button because we want to reuse the hotkey from the menu items
-        onClick={
-          subEnvironments.length === 0
-            ? (event) => {
-                event.preventDefault();
-                editEnvironment(null);
-              }
-            : undefined
-        }
+        onClick={subEnvironments.length === 0 ? () => editEnvironment(null) : undefined}
        {...buttonProps}
      >
        <EnvironmentColorIndicator environment={activeEnvironment ?? null} />
@@ -1,8 +1,9 @@
 import { linter } from "@codemirror/lint";
 import type { EditorView } from "@codemirror/view";
 import { jsoncLanguage } from "@shopify/lang-jsonc";
-import { type GrpcRequest, patchModel } from "@yaakapp-internal/models";
-import { Banner, FormattedError, Icon, InlineCode, VStack } from "@yaakapp-internal/ui";
+import type { GrpcRequest } from "@yaakapp-internal/models";
+import { FormattedError, InlineCode, VStack } from "@yaakapp-internal/ui";
+import classNames from "classnames";
 import {
  handleRefresh,
  jsonCompletion,
@@ -10,20 +11,12 @@ import {
  stateExtensions,
  updateSchema,
 } from "codemirror-json-schema";
-import type { JSONSchema7 } from "json-schema";
-import type { ReactNode } from "react";
 import { useCallback, useEffect, useMemo, useState } from "react";
 import type { ReflectResponseService } from "../hooks/useGrpc";
-import { wasUpdatedExternally } from "../hooks/useRequestUpdateKey";
 import { showAlert } from "../lib/alert";
-import { showConfirm } from "../lib/confirm";
 import { showDialog } from "../lib/dialog";
-import type { JsonSchema } from "../lib/jsonSchemaExample";
-import { buildExampleFromSchema } from "../lib/jsonSchemaExample";
 import { pluralizeCount } from "../lib/pluralize";
-import { queryClient } from "../lib/queryClient";
 import { Button } from "./core/Button";
-import { Dropdown } from "./core/Dropdown";
 import type { EditorProps } from "./core/Editor/Editor";
 import { Editor } from "./core/Editor/LazyEditor";
 import { GrpcProtoSelectionDialog } from "./GrpcProtoSelectionDialog";
@@ -36,11 +29,6 @@ type Props = Pick<EditorProps, "heightMode" | "onChange" | "className" | "forceU
  protoFiles: string[];
 };

-type MethodSchema =
-  | { type: "none" }
-  | { type: "schema"; schema: JsonSchema }
-  | { type: "error"; id: string; title: string; body: ReactNode; log: unknown[] };
-
 export function GrpcEditor({
  services,
  reflectionError,
@@ -54,16 +42,21 @@ export function GrpcEditor({
    setEditorView(h);
  }, []);

-  // Find the schema for the selected service and method
-  const methodSchema = useMemo<MethodSchema>(() => {
-    if (services === null || request.service === null || request.method === null) {
-      return { type: "none" };
+  // Find the schema for the selected service and method and update the editor
+  useEffect(() => {
+    if (
+      editorView == null ||
+      services === null ||
+      request.service === null ||
+      request.method === null
+    ) {
+      return;
    }

    const s = services.find((s) => s.name === request.service);
    if (s == null) {
-      return {
-        type: "error",
+      console.log("Failed to find service", { service: request.service, services });
+      showAlert({
        id: "grpc-find-service-error",
        title: "Couldn't Find Service",
        body: (
@@ -71,14 +64,14 @@ export function GrpcEditor({
            Failed to find service <InlineCode>{request.service}</InlineCode> in schema
          </>
        ),
-        log: ["Failed to find service", { service: request.service, services }],
-      };
+      });
+      return;
    }

    const schema = s.methods.find((m) => m.name === request.method)?.schema;
-    if (schema == null) {
-      return {
-        type: "error",
+    if (request.method != null && schema == null) {
+      console.log("Failed to find method", { method: request.method, methods: s?.methods });
+      showAlert({
        id: "grpc-find-schema-error",
        title: "Couldn't Find Method",
        body: (
@@ -87,15 +80,18 @@ export function GrpcEditor({
            <InlineCode>{request.service}</InlineCode> in schema
          </>
        ),
-        log: ["Failed to find method", { method: request.method, methods: s.methods }],
-      };
+      });
+      return;
+    }
+
+    if (schema == null) {
+      return;
    }

    try {
-      return { type: "schema", schema: JSON.parse(schema) as JsonSchema };
+      updateSchema(editorView, JSON.parse(schema));
    } catch (err) {
-      return {
-        type: "error",
+      showAlert({
        id: "grpc-parse-schema-error",
        title: "Failed to Parse Schema",
        body: (
@@ -107,22 +103,9 @@ export function GrpcEditor({
            <FormattedError>{String(err)}</FormattedError>
          </VStack>
        ),
-        log: ["Failed to parse schema", err],
-      };
+      });
    }
-  }, [services, request.method, request.service]);
-
-  useEffect(() => {
-    if (methodSchema.type !== "error") return;
-    console.log(...methodSchema.log);
-    showAlert({ id: methodSchema.id, title: methodSchema.title, body: methodSchema.body });
-  }, [methodSchema]);
-
-  // Update the editor whenever the schema changes
-  useEffect(() => {
-    if (editorView == null || methodSchema.type !== "schema") return;
-    updateSchema(editorView, methodSchema.schema as JSONSchema7);
-  }, [editorView, methodSchema]);
+  }, [editorView, services, request.method, request.service]);

  const extraExtensions = useMemo(
    () => [
@@ -141,145 +124,45 @@ export function GrpcEditor({
  const reflectionUnavailable = reflectionError?.match(/unimplemented/i);
  reflectionError = reflectionUnavailable ? undefined : reflectionError;

-  const handleGenerateExample = useCallback(async () => {
-    if (methodSchema.type !== "schema") return;
-
-    if (request.message.trim() !== "") {
-      const confirmed = await showConfirm({
-        id: "grpc-generate-example",
-        title: "Generate Example",
-        description: "The current message will be replaced with an example.",
-        confirmText: "Generate",
-      });
-      if (!confirmed) return;
-    }
-
-    const message = JSON.stringify(buildExampleFromSchema(methodSchema.schema), null, 2);
-    await patchModel(request, { message });
-
-    // Force the editor to pick up the new message
-    wasUpdatedExternally(request.id);
-  }, [methodSchema, request]);
-
-  // The reflect query is keyed by request, url and proto files, so a prefix invalidate
-  // reaches it without threading a refetch down from the connection layout.
-  const handleReloadSchema = useCallback(
-    () => queryClient.invalidateQueries({ queryKey: ["grpc_reflect", request.id] }),
-    [request.id],
-  );
-
-  const handleShowReflectionError = useCallback(() => {
-    showDialog({
-      id: "grpc-reflection-error",
-      title: "Reflection Failed",
-      size: "sm",
-      render: ({ hide }) => (
-        <>
-          <FormattedError>{reflectionError ?? "unknown"}</FormattedError>
-          <div className="w-full my-4">
-            <Button
-              className="ml-auto"
-              color="primary"
-              size="sm"
-              onClick={async () => {
-                hide();
-                await handleReloadSchema();
-              }}
-            >
-              Retry
-            </Button>
-          </div>
-        </>
-      ),
-    });
-  }, [handleReloadSchema, reflectionError]);
-
  const actions = useMemo(
    () => [
-      // Matches the GraphQL editor: one always-visible control labelled by schema state,
-      // with everything schema-related behind it.
-      <div key="schema" className="opacity-100!">
-        <Dropdown
-          items={[
-            {
-              // Hidden for servers without reflection, which isn't an error
-              hidden: !reflectionError,
-              type: "content",
-              label: (
-                <Banner color="danger">
-                  <p className="mb-1">Reflection failed</p>
-                  <Button
-                    size="xs"
-                    color="danger"
-                    variant="border"
-                    onClick={handleShowReflectionError}
-                  >
-                    View Error
-                  </Button>
-                </Banner>
-              ),
-            },
-            {
-              label: "Generate Example Message",
-              leftSlot: <Icon icon="magic_wand" />,
-              disabled: methodSchema.type !== "schema",
-              onSelect: handleGenerateExample,
-            },
-            { type: "separator" },
-            {
-              label: "Reload Schema",
-              leftSlot: <Icon icon="refresh" spin={reflectionLoading} />,
-              keepOpenOnSelect: true,
-              onSelect: handleReloadSchema,
-            },
-            {
-              label: protoFiles.length > 0 ? "Select Proto Files\u2026" : "Configure Schema\u2026",
-              leftSlot: <Icon icon="settings" />,
-              onSelect: () => {
-                showDialog({
-                  title: "Configure Schema",
-                  size: "md",
-                  id: "grpc-configure-schema",
-                  render: ({ hide }) => <GrpcProtoSelectionDialog onDone={hide} />,
-                });
-              },
-            },
-          ]}
-        >
-          <Button
-            size="sm"
-            variant="border"
-            title="Schema"
-            forDropdown
-            isLoading={reflectionLoading}
-            color={reflectionUnavailable ? "info" : reflectionError ? "danger" : "default"}
-          >
-            {reflectionLoading
-              ? "Inspecting Schema"
+      <div key="reflection" className={classNames(services == null && "opacity-100!")}>
+        <Button
+          size="xs"
+          color={
+            reflectionLoading
+              ? "secondary"
              : reflectionUnavailable
-                ? "Select Proto Files"
+                ? "info"
                : reflectionError
-                  ? "Server Error"
-                  : protoFiles.length > 0
-                    ? pluralizeCount("File", protoFiles.length)
-                    : services != null
-                      ? "Schema Detected"
-                      : "Select Schema"}
-          </Button>
-        </Dropdown>
+                  ? "danger"
+                  : "secondary"
+          }
+          isLoading={reflectionLoading}
+          onClick={() => {
+            showDialog({
+              title: "Configure Schema",
+              size: "md",
+              id: "reflection-failed",
+              render: ({ hide }) => <GrpcProtoSelectionDialog onDone={hide} />,
+            });
+          }}
+        >
+          {reflectionLoading
+            ? "Inspecting Schema"
+            : reflectionUnavailable
+              ? "Select Proto Files"
+              : reflectionError
+                ? "Server Error"
+                : protoFiles.length > 0
+                  ? pluralizeCount("File", protoFiles.length)
+                  : services != null && protoFiles.length === 0
+                    ? "Schema Detected"
+                    : "Select Schema"}
+        </Button>
      </div>,
    ],
-    [
-      handleGenerateExample,
-      handleReloadSchema,
-      handleShowReflectionError,
-      methodSchema.type,
-      protoFiles.length,
-      reflectionError,
-      reflectionLoading,
-      reflectionUnavailable,
-      services,
-    ],
+    [protoFiles.length, reflectionError, reflectionLoading, reflectionUnavailable, services],
  );

  return (
@@ -1,37 +1,17 @@
-import {
-  type Folder,
-  type ImportDestination,
-  type ImportPlan,
-  modelTypeLabel,
-  type Workspace,
-} from "@yaakapp-internal/models";
-import { HStack, Icon, VStack } from "@yaakapp-internal/ui";
 import { platform } from "@yaakapp-internal/platform";
+import { Icon, VStack } from "@yaakapp-internal/ui";
 import classNames from "classnames";
 import { useEffect, useRef, useState } from "react";
 import { useLocalStorage } from "react-use";
-import { pluralizeCount } from "../lib/pluralize";
 import { CommercialUseBanner } from "./CommercialUseBanner";
 import { Button } from "./core/Button";
-import { Checkbox } from "./core/Checkbox";
 import { PlainInput } from "./core/PlainInput";
-import { Select } from "./core/Select";

 interface Props {
-  currentWorkspace: Workspace | null;
-  workspaces: Workspace[];
-  selectedFolder: Folder | null;
-  planFile: (filePath: string, destination: ImportDestination) => Promise<ImportPlan>;
-  planUrl: (url: string, destination: ImportDestination) => Promise<ImportPlan>;
-  commit: (plan: ImportPlan) => Promise<void>;
-  cancel: () => void;
-  onError: (err: unknown) => void;
+  importFile: (filePath: string) => Promise<void>;
+  importUrl: (url: string) => Promise<void>;
 }

-/** Sentinel for the "create a new workspace" option. Workspace IDs are prefixed `wk_`, so this
- * can never collide with a real one. */
-const NEW_WORKSPACE = "new_workspace";
-
 /**
 * An absolute or relative path is unambiguously a file. Everything else is treated as a URL, so a
 * bare host like `example.com/openapi.json` still works (the backend defaults it to https).
@@ -51,20 +31,8 @@ function fileName(path: string): string {
  return path.split(/[/\\]/).at(-1) || path;
 }

-export function ImportDataDialog({
-  currentWorkspace,
-  workspaces,
-  selectedFolder,
-  planFile,
-  planUrl,
-  commit,
-  cancel,
-  onError,
-}: Props) {
+export function ImportDataDialog({ importFile, importUrl }: Props) {
  const [isLoading, setIsLoading] = useState<boolean>(false);
-  const [plan, setPlan] = useState<ImportPlan | null>(null);
-  const [destinationId, setDestinationId] = useState<string>(NEW_WORKSPACE);
-  const [targetSelectedFolder, setTargetSelectedFolder] = useState(selectedFolder != null);
  // A file path or a URL. Both inputs write here, so there is only ever one thing to import
  const [source, setSource] = useLocalStorage<string | null>("importPathOrUrl", null);
  const [forceUpdateKey, setForceUpdateKey] = useState<number>(0);
@@ -103,117 +71,19 @@ export function ImportDataDialog({
    selectSource(selected);
  };

-  // The selected folder belongs to the workspace being viewed, so it is only offerable when that
-  // is also the destination.
-  const canTargetSelectedFolder =
-    selectedFolder != null && destinationId === currentWorkspace?.id;
-
-  const destination = (): ImportDestination => {
-    if (destinationId === NEW_WORKSPACE) {
-      return { type: "new_workspace" };
-    }
-    return {
-      type: "existing_workspace",
-      workspaceId: destinationId,
-      folderId: canTargetSelectedFolder && targetSelectedFolder ? selectedFolder.id : undefined,
-    };
-  };
-
-  const handlePreview = async () => {
+  const handleImport = async () => {
    setIsLoading(true);
    try {
-      const nextPlan =
-        filePath != null
-          ? await planFile(filePath, destination())
-          : await planUrl(trimmedSource, destination());
-      setPlan(nextPlan);
-    } catch (err) {
-      onError(err);
+      if (filePath != null) {
+        await importFile(filePath);
+      } else {
+        await importUrl(trimmedSource);
+      }
    } finally {
      setIsLoading(false);
    }
  };

-  const handleCommit = async () => {
-    if (plan == null) return;
-    setIsLoading(true);
-    try {
-      await commit(plan);
-    } catch (err) {
-      onError(err);
-    } finally {
-      setIsLoading(false);
-    }
-  };
-
-  if (plan != null) {
-    const counts = [
-      [plan.resources.workspaces[0], plan.resources.workspaces.length],
-      [plan.resources.environments[0], plan.resources.environments.length],
-      [plan.resources.folders[0], plan.resources.folders.length],
-      [plan.resources.httpRequests[0], plan.resources.httpRequests.length],
-      [plan.resources.grpcRequests[0], plan.resources.grpcRequests.length],
-      [plan.resources.websocketRequests[0], plan.resources.websocketRequests.length],
-    ] as const;
-    const destinationLabel = (() => {
-      if (plan.destination.type === "new_workspace") return "New workspace";
-      const { workspaceId, folderId } = plan.destination;
-      const name = workspaces.find((w) => w.id === workspaceId)?.name ?? "Unknown workspace";
-      return folderId != null && folderId === selectedFolder?.id
-        ? `${name} / ${selectedFolder.name}`
-        : name;
-    })();
-
-    return (
-      <VStack space={4} className="pb-4">
-        <div className="rounded-lg border border-border-subtle divide-y divide-border-subtle">
-          <PreviewRow label="Detected format" value={plan.importer} />
-          <PreviewRow label="Destination" value={destinationLabel} />
-        </div>
-
-        <div>
-          <div className="text-sm font-semibold mb-1">Resources</div>
-          <ul className="list-disc pl-6 text-sm text-text-subtle">
-            {counts.map(([model, count]) =>
-              model == null ? null : (
-                <li key={model.model}>{pluralizeCount(modelTypeLabel(model), count)}</li>
-              ),
-            )}
-          </ul>
-        </div>
-
-        {plan.warnings.length > 0 && (
-          <div>
-            <div className="text-sm font-semibold mb-1">Import details</div>
-            <div className="rounded-lg border border-border-subtle divide-y divide-border-subtle">
-              {plan.warnings.map((warning) => (
-                <div
-                  key={`${warning.title}:${warning.detail}`}
-                  className="flex items-start gap-2.5 px-3 py-2.5"
-                >
-                  <Icon icon="info" color="info" size="sm" className="mt-0.5" />
-                  <div className="min-w-0">
-                    <div className="text-sm font-medium">{warning.title}</div>
-                    <div className="text-xs text-text-subtle mt-0.5">{warning.detail}</div>
-                  </div>
-                </div>
-              ))}
-            </div>
-          </div>
-        )}
-
-        <HStack space={2} justifyContent="end">
-          <Button color="secondary" variant="border" disabled={isLoading} onClick={cancel}>
-            Cancel
-          </Button>
-          <Button color="primary" isLoading={isLoading} onClick={handleCommit}>
-            {isLoading ? "Importing" : "Confirm Import"}
-          </Button>
-        </HStack>
-      </VStack>
-    );
-  }
-
  return (
    <VStack ref={ref} space={4} className="pb-4">
      <CommercialUseBanner source="data-import" title="Importing work data?" />
@@ -245,66 +115,25 @@ export function ImportDataDialog({
        </div>
      </button>

-      <PlainInput
-        label="Or enter a file path or URL"
-        size="sm"
-        placeholder="https://example.com/openapi.json"
-        defaultValue={source ?? ""}
-        forceUpdateKey={String(forceUpdateKey)}
-        onChange={setSource}
-      />
-
      <VStack space={2}>
-        <Select
-          name="import-destination"
-          label="Import location"
+        <PlainInput
+          label="Or enter a file path or URL"
          size="sm"
-          value={destinationId}
-          onChange={setDestinationId}
-          // The native macOS select drops separators
-          filterable
-          options={[
-            { value: NEW_WORKSPACE, label: "New Workspace" },
-            ...(workspaces.length > 0
-              ? [{ type: "separator" as const, label: "Existing Workspaces" }]
-              : []),
-            ...workspaces.map((w) => ({
-              value: w.id,
-              label: w.id === currentWorkspace?.id ? `${w.name} (current workspace)` : w.name,
-            })),
-          ]}
+          placeholder="https://example.com/openapi.json"
+          defaultValue={source ?? ""}
+          forceUpdateKey={String(forceUpdateKey)}
+          onChange={setSource}
        />
-        {canTargetSelectedFolder && (
-          <Checkbox
-            checked={targetSelectedFolder}
-            title={`Place root resources in selected folder “${selectedFolder.name}”`}
-            onChange={setTargetSelectedFolder}
-          />
-        )}
-      </VStack>
-
-      <HStack space={2} justifyContent="end">
-        <Button color="secondary" variant="border" disabled={isLoading} onClick={cancel}>
-          Cancel
-        </Button>
        <Button
          color="primary"
          disabled={trimmedSource === "" || isLoading}
          isLoading={isLoading}
-          onClick={handlePreview}
+          size="sm"
+          onClick={handleImport}
        >
-          {isLoading ? "Analyzing" : "Preview Import"}
+          {isLoading ? "Importing" : "Import"}
        </Button>
-      </HStack>
+      </VStack>
    </VStack>
  );
 }
-
-function PreviewRow({ label, value }: { label: string; value: string }) {
-  return (
-    <div className="flex items-start justify-between gap-4 px-3 py-2 text-sm">
-      <span className="text-text-subtle">{label}</span>
-      <span className="text-right font-medium">{value}</span>
-    </div>
-  );
-}
@@ -2,9 +2,7 @@ import type {
  Folder,
  GrpcRequest,
  HttpRequest,
-  HttpVersion,
  InheritedBoolSetting,
-  InheritedHttpVersionSetting,
  InheritedIntSetting,
  WebsocketRequest,
  Workspace,
@@ -15,7 +13,6 @@ import {
  modelSupportsSetting,
  type RequestSettingDefinition,
  SETTING_FOLLOW_REDIRECTS,
-  SETTING_HTTP_VERSION,
  SETTING_REQUEST_MESSAGE_SIZE,
  SETTING_REQUEST_TIMEOUT,
  SETTING_SEND_COOKIES,
@@ -24,7 +21,6 @@ import {
 } from "../lib/requestSettings";
 import { Checkbox } from "./core/Checkbox";
 import { PlainInput } from "./core/PlainInput";
-import { Select } from "./core/Select";
 import {
  SettingOverrideRow,
  SettingRow,
@@ -42,21 +38,37 @@ interface Props {
  model: ModelWithSettings;
 }

-type ModelWithSettings = Workspace | Folder | HttpRequest | WebsocketRequest | GrpcRequest;
+type ModelWithSettings =
+  | Workspace
+  | Folder
+  | HttpRequest
+  | WebsocketRequest
+  | GrpcRequest;
 type ModelWithHttpSettings = Workspace | Folder | HttpRequest;
-type ModelWithTlsSettings = Workspace | Folder | HttpRequest | WebsocketRequest | GrpcRequest;
-type ModelWithCookieSettings = Workspace | Folder | HttpRequest | WebsocketRequest;
-type ModelWithMessageSizeSettings = Workspace | Folder | WebsocketRequest | GrpcRequest;
+type ModelWithTlsSettings =
+  | Workspace
+  | Folder
+  | HttpRequest
+  | WebsocketRequest
+  | GrpcRequest;
+type ModelWithCookieSettings =
+  | Workspace
+  | Folder
+  | HttpRequest
+  | WebsocketRequest;
+type ModelWithMessageSizeSettings =
+  | Workspace
+  | Folder
+  | WebsocketRequest
+  | GrpcRequest;
 type BooleanSetting = boolean | InheritedBoolSetting;
 type IntegerSetting = number | InheritedIntSetting;
-type HttpVersionSetting = HttpVersion | InheritedHttpVersionSetting;
 type CookieSettingsPatch = {
  settingSendCookies?: ModelWithCookieSettings["settingSendCookies"];
  settingStoreCookies?: ModelWithCookieSettings["settingStoreCookies"];
 };
 type HttpSettingsPatch = {
  settingFollowRedirects?: ModelWithHttpSettings["settingFollowRedirects"];
-  settingHttpVersion?: ModelWithHttpSettings["settingHttpVersion"];
  settingRequestTimeout?: ModelWithHttpSettings["settingRequestTimeout"];
 };
 type TlsSettingsPatch = {
@@ -66,7 +78,10 @@ type MessageSizeSettingsPatch = {
  settingRequestMessageSize?: ModelWithMessageSizeSettings["settingRequestMessageSize"];
 };

-export function ModelSettingsEditor({ model, showSectionTitles = false }: Props) {
+export function ModelSettingsEditor({
+  model,
+  showSectionTitles = false,
+}: Props) {
  const ancestors = useModelAncestors(model);
  const supportsHttpSettings = modelSupportsHttpSettings(model);
  const supportsCookieSettings = modelSupportsCookieSettings(model);
@@ -139,26 +154,12 @@ export function ModelSettingsEditor({ model, showSectionTitles = false }: Props)
              }
            />
          )}
-          {supportsHttpSettings && (
-            <HttpVersionSettingRow
-              settingDefinition={SETTING_HTTP_VERSION}
-              setting={model.settingHttpVersion}
-              inheritedValue={resolveInheritedValue(
-                ancestors,
-                SETTING_HTTP_VERSION.modelKey,
-                model.settingHttpVersion,
-              )}
-              onChange={(settingHttpVersion) =>
-                patchHttpSettings(model, {
-                  settingHttpVersion,
-                })
-              }
-            />
-          )}
        </SettingsSection>
      )}
      {supportsCookieSettings && (
-        <SettingsSection title={supportsTlsSettings || showSectionTitles ? "Cookies" : null}>
+        <SettingsSection
+          title={supportsTlsSettings || showSectionTitles ? "Cookies" : null}
+        >
          <BooleanSettingRow
            settingDefinition={SETTING_SEND_COOKIES}
            setting={model.settingSendCookies}
@@ -194,7 +195,7 @@ export function ModelSettingsEditor({ model, showSectionTitles = false }: Props)
 }

 export function countOverriddenSettings(model: ModelWithSettings) {
-  const settings: (BooleanSetting | IntegerSetting | HttpVersionSetting)[] = [];
+  const settings: (BooleanSetting | IntegerSetting)[] = [];

  if (modelSupportsCookieSettings(model)) {
    settings.push(model.settingSendCookies, model.settingStoreCookies);
@@ -203,22 +204,22 @@ export function countOverriddenSettings(model: ModelWithSettings) {
  settings.push(model.settingValidateCertificates);

  if (modelSupportsHttpSettings(model)) {
-    settings.push(
-      model.settingFollowRedirects,
-      model.settingRequestTimeout,
-      model.settingHttpVersion,
-    );
+    settings.push(model.settingFollowRedirects, model.settingRequestTimeout);
  }

  if (modelSupportsMessageSizeSettings(model)) {
    settings.push(model.settingRequestMessageSize);
  }

-  return settings.filter((setting) => isInheritedSetting(setting) && setting.enabled === true)
-    .length;
+  return settings.filter(
+    (setting) => isInheritedSetting(setting) && setting.enabled === true,
+  ).length;
 }

-function patchCookieSettings(model: ModelWithCookieSettings, patch: Partial<CookieSettingsPatch>) {
+function patchCookieSettings(
+  model: ModelWithCookieSettings,
+  patch: Partial<CookieSettingsPatch>,
+) {
  switch (model.model) {
    case "workspace":
      return patchModel(model, patch as Partial<Workspace>);
@@ -231,7 +232,10 @@ function patchCookieSettings(model: ModelWithCookieSettings, patch: Partial<Cook
  }
 }

-function patchHttpSettings(model: ModelWithHttpSettings, patch: Partial<HttpSettingsPatch>) {
+function patchHttpSettings(
+  model: ModelWithHttpSettings,
+  patch: Partial<HttpSettingsPatch>,
+) {
  switch (model.model) {
    case "workspace":
      return patchModel(model, patch as Partial<Workspace>);
@@ -242,7 +246,10 @@ function patchHttpSettings(model: ModelWithHttpSettings, patch: Partial<HttpSett
  }
 }

-function patchTlsSettings(model: ModelWithTlsSettings, patch: Partial<TlsSettingsPatch>) {
+function patchTlsSettings(
+  model: ModelWithTlsSettings,
+  patch: Partial<TlsSettingsPatch>,
+) {
  switch (model.model) {
    case "workspace":
      return patchModel(model, patch as Partial<Workspace>);
@@ -273,15 +280,21 @@ function patchMessageSizeSettings(
  }
 }

-function modelSupportsHttpSettings(model: ModelWithSettings): model is ModelWithHttpSettings {
+function modelSupportsHttpSettings(
+  model: ModelWithSettings,
+): model is ModelWithHttpSettings {
  return modelSupportsSetting(model, SETTING_REQUEST_TIMEOUT);
 }

-function modelSupportsCookieSettings(model: ModelWithSettings): model is ModelWithCookieSettings {
+function modelSupportsCookieSettings(
+  model: ModelWithSettings,
+): model is ModelWithCookieSettings {
  return modelSupportsSetting(model, SETTING_SEND_COOKIES);
 }

-function modelSupportsTlsSettings(model: ModelWithSettings): model is ModelWithTlsSettings {
+function modelSupportsTlsSettings(
+  model: ModelWithSettings,
+): model is ModelWithTlsSettings {
  return modelSupportsSetting(model, SETTING_VALIDATE_CERTIFICATES);
 }

@@ -304,7 +317,11 @@ function BooleanSettingRow({
 }) {
  const inherited = isInheritedSetting(setting);
  const overridden = inherited ? setting.enabled === true : false;
-  const value = inherited ? (overridden ? setting.value : inheritedValue) : setting;
+  const value = inherited
+    ? overridden
+      ? setting.value
+      : inheritedValue
+    : setting;

  if (!inherited) {
    return (
@@ -335,63 +352,6 @@ function BooleanSettingRow({
  );
 }

-const HTTP_VERSION_OPTIONS: { label: string; value: HttpVersion }[] = [
-  { label: "Automatic", value: "auto" },
-  { label: "HTTP/1.1", value: "http1" },
-  { label: "HTTP/2", value: "http2" },
-];
-
-function HttpVersionSettingRow({
-  inheritedValue,
-  setting,
-  settingDefinition,
-  onChange,
-}: {
-  inheritedValue: HttpVersion;
-  setting: HttpVersionSetting;
-  settingDefinition: RequestSettingDefinition<"settingHttpVersion">;
-  onChange: (setting: HttpVersionSetting) => void;
-}) {
-  const inherited = isInheritedSetting(setting);
-  const overridden = inherited ? setting.enabled === true : false;
-  const value = inherited ? (overridden ? setting.value : inheritedValue) : setting;
-
-  if (!inherited) {
-    return (
-      <SettingRow title={settingDefinition.title} description={settingDefinition.description}>
-        <Select
-          hideLabel
-          name={settingDefinition.modelKey}
-          label={settingDefinition.title}
-          size="sm"
-          value={value}
-          options={HTTP_VERSION_OPTIONS}
-          onChange={(value) => onChange(value)}
-        />
-      </SettingRow>
-    );
-  }
-
-  return (
-    <SettingOverrideRow
-      title={settingDefinition.title}
-      description={settingDefinition.description}
-      overridden={overridden}
-      onResetOverride={() => onChange({ ...setting, enabled: false })}
-    >
-      <Select
-        hideLabel
-        name={settingDefinition.modelKey}
-        label={settingDefinition.title}
-        size="sm"
-        value={value}
-        options={HTTP_VERSION_OPTIONS}
-        onChange={(value) => onChange({ ...setting, enabled: true, value })}
-      />
-    </SettingOverrideRow>
-  );
-}
-
 function IntegerSettingRow({
  inheritedValue,
  setting,
@@ -405,11 +365,18 @@ function IntegerSettingRow({
 }) {
  const inherited = isInheritedSetting(setting);
  const overridden = inherited ? setting.enabled === true : false;
-  const value = inherited ? (overridden ? setting.value : inheritedValue) : setting;
+  const value = inherited
+    ? overridden
+      ? setting.value
+      : inheritedValue
+    : setting;

  if (!inherited) {
    return (
-      <SettingRow title={settingDefinition.title} description={settingDefinition.description}>
+      <SettingRow
+        title={settingDefinition.title}
+        description={settingDefinition.description}
+      >
        <NumberUnitInput
          name={settingDefinition.modelKey}
          label={settingDefinition.title}
@@ -462,13 +429,20 @@ function MessageSizeSettingRow({
 }) {
  const inherited = isInheritedSetting(setting);
  const overridden = inherited ? setting.enabled === true : false;
-  const value = inherited ? (overridden ? setting.value : inheritedValue) : setting;
+  const value = inherited
+    ? overridden
+      ? setting.value
+      : inheritedValue
+    : setting;
  const displayValue = formatMegabytes(value);
  const placeholder = "0";

  if (!inherited) {
    return (
-      <SettingRow title={settingDefinition.title} description={settingDefinition.description}>
+      <SettingRow
+        title={settingDefinition.title}
+        description={settingDefinition.description}
+      >
        <MessageSizeInput
          name={settingDefinition.modelKey}
          label={settingDefinition.title}
@@ -593,18 +567,13 @@ function resolveInheritedValue(
  key: BooleanWorkspaceSettingKey,
  fallback: BooleanSetting,
 ): boolean;
-function resolveInheritedValue(
-  ancestors: (Folder | Workspace)[],
-  key: "settingHttpVersion",
-  fallback: HttpVersionSetting,
-): HttpVersion;
 function resolveInheritedValue(
  ancestors: (Folder | Workspace)[],
  key: keyof WorkspaceSettings,
-  fallback: BooleanSetting | IntegerSetting | HttpVersionSetting,
+  fallback: BooleanSetting | IntegerSetting,
 ) {
  for (const ancestor of ancestors) {
-    const setting = ancestor[key] as BooleanSetting | IntegerSetting | HttpVersionSetting;
+    const setting = ancestor[key] as BooleanSetting | IntegerSetting;
    if (isInheritedSetting(setting)) {
      if (setting.enabled === true) {
        return setting.value;
@@ -620,7 +589,6 @@ function resolveInheritedValue(
 type WorkspaceSettings = Pick<
  Workspace,
  | "settingFollowRedirects"
-  | "settingHttpVersion"
  | "settingRequestMessageSize"
  | "settingRequestTimeout"
  | "settingSendCookies"
@@ -630,12 +598,14 @@ type WorkspaceSettings = Pick<

 type BooleanWorkspaceSettingKey = Exclude<
  keyof WorkspaceSettings,
-  "settingRequestTimeout" | "settingRequestMessageSize" | "settingHttpVersion"
+  "settingRequestTimeout" | "settingRequestMessageSize"
 >;

 function formatMegabytes(bytes: number) {
  const megabytes = bytes / BYTES_PER_MB;
-  return Number.isInteger(megabytes) ? `${megabytes}` : megabytes.toFixed(3).replace(/\.?0+$/, "");
+  return Number.isInteger(megabytes)
+    ? `${megabytes}`
+    : megabytes.toFixed(3).replace(/\.?0+$/, "");
 }

 function parseMegabytes(value: string) {
@@ -656,5 +626,9 @@ function isValidInteger(value: string) {
 function isValidMegabytes(value: string) {
  if (value === "") return true;
  const megabytes = Number(value);
-  return Number.isFinite(megabytes) && megabytes >= 0 && megabytes <= MAX_MESSAGE_SIZE_MB;
+  return (
+    Number.isFinite(megabytes) &&
+    megabytes >= 0 &&
+    megabytes <= MAX_MESSAGE_SIZE_MB
+  );
 }
@@ -10,13 +10,11 @@ export interface DialogProps {
  children: ReactNode;
  open: boolean;
  onClose?: () => void;
-  /** Block dismissal from the backdrop, Escape key, and built-in close button. */
-  disableClose?: boolean;
+  disableBackdropClose?: boolean;
  title?: ReactNode;
  description?: ReactNode;
  className?: string;
  size?: DialogSize;
-  /** Hide the built-in close button without changing backdrop or Escape behavior. */
  hideX?: boolean;
  noPadding?: boolean;
  noScroll?: boolean;
@@ -29,7 +27,7 @@ export function Dialog({
  size = "full",
  open,
  onClose,
-  disableClose,
+  disableBackdropClose,
  title,
  description,
  hideX,
@@ -44,7 +42,7 @@ export function Dialog({
  );

  return (
-    <Overlay open={open} onClose={disableClose ? undefined : onClose} portalName="dialog">
+    <Overlay open={open} onClose={disableBackdropClose ? undefined : onClose} portalName="dialog">
      <div
        role="dialog"
        className={classNames(
@@ -60,7 +58,7 @@ export function Dialog({
          // NOTE: We handle Escape on the element itself so that it doesn't close multiple
          //   dialogs and can be intercepted by children if needed.
          if (e.key === "Escape") {
-            if (!disableClose) onClose?.();
+            onClose?.();
            e.stopPropagation();
            e.preventDefault();
          }
@@ -112,7 +110,7 @@ export function Dialog({
          </div>

          {/*Put close at the end so that it's the last thing to be tabbed to*/}
-          {!disableClose && !hideX && (
+          {!hideX && (
            <div className="ml-auto absolute right-1 top-1">
              <IconButton
                className="opacity-70 hover:opacity-100"
@@ -1,202 +0,0 @@
-import { SearchQuery } from "@codemirror/search";
-import { EditorState } from "@codemirror/state";
-import { describe, expect, test } from "vite-plus/test";
-import {
-  currentMatch,
-  literalSearch,
-  MAX_COUNT,
-  MatchCounter,
-  normalizeDoc,
-  normalizeSearch,
-  scanNormalized,
-  scanQuery,
-} from "./searchMatchCount";
-
-type QueryConfig = ConstructorParameters<typeof SearchQuery>[0];
-
-const stateOf = (doc: string) => EditorState.create({ doc });
-
-/**
- * The matches the counter finds, having checked them against the search panel's own cursor.
- *
- * The cursor decides which ranges the editor highlights and which one `find next` lands on, so
- * a count that doesn't agree with it is a wrong count, however fast it was to produce.
- */
-function matchesOf(doc: string, config: QueryConfig) {
-  const state = stateOf(doc);
-  const query = new SearchQuery(config);
-  const matches = new MatchCounter().matches(state, query);
-  expect(matches).toEqual(scanQuery(state, query));
-  return matches;
-}
-
-const countOf = (doc: string, config: QueryConfig) => matchesOf(doc, config).length;
-
-describe("counting", () => {
-  test("counts every match, whatever the case", () => {
-    expect(countOf("one Two three two", { search: "two" })).toBe(2);
-    expect(countOf("one Two three two", { search: "two", caseSensitive: true })).toBe(1);
-  });
-
-  test("skips matches overlapping an earlier one", () => {
-    expect(countOf("aaaaa", { search: "aa" })).toBe(2);
-    expect(countOf("ababa", { search: "aba" })).toBe(1);
-  });
-
-  test("treats a query as text, not as a pattern", () => {
-    expect(countOf("a.b axb", { search: "a.b" })).toBe(1);
-  });
-
-  test("unquotes escapes unless the query is literal", () => {
-    expect(countOf("one\ntwo\nthree", { search: "\\n" })).toBe(2);
-    expect(countOf("one\\ntwo", { search: "\\n", literal: true })).toBe(1);
-  });
-
-  test("counts regexp and whole word queries through the cursor", () => {
-    expect(literalSearch(new SearchQuery({ search: "a", regexp: true }))).toBe(null);
-    expect(literalSearch(new SearchQuery({ search: "a", wholeWord: true }))).toBe(null);
-    expect(countOf("a1 b2 c3", { search: "[a-z]\\d", regexp: true })).toBe(3);
-    expect(countOf("cat cats cat", { search: "cat", wholeWord: true })).toBe(2);
-  });
-
-  test("stops counting at the cap", () => {
-    expect(countOf("x".repeat(MAX_COUNT + 100), { search: "x" })).toBe(MAX_COUNT + 1);
-  });
-
-  test("reports where the matches are", () => {
-    expect(matchesOf("ab..ab", { search: "ab" })).toEqual([
-      { from: 0, to: 2 },
-      { from: 4, to: 6 },
-    ]);
-  });
-
-  test("finds nothing to match with an empty needle", () => {
-    expect(scanNormalized(normalizeDoc("abc", false), "")).toEqual([]);
-  });
-});
-
-describe("normalization", () => {
-  test("finds what a character decomposes into", () => {
-    // The é is one character holding an `e`, and the match covers the whole of it
-    expect(matchesOf("café", { search: "e" })).toEqual([{ from: 3, to: 4 }]);
-    expect(matchesOf("ﬁle", { search: "fi" })).toEqual([{ from: 0, to: 1 }]);
-    expect(matchesOf("a…b", { search: "..." })).toEqual([{ from: 1, to: 2 }]);
-    expect(countOf("one two", { search: "one two" })).toBe(1);
-    expect(countOf("ｆｕｌｌ width", { search: "full" })).toBe(1);
-  });
-
-  test("matches a decomposed query against composed text, and the reverse", () => {
-    expect(countOf("café", { search: "café" })).toBe(1);
-    expect(countOf("café", { search: "café" })).toBe(1);
-    expect(countOf("café", { search: "café" })).toBe(1);
-  });
-
-  test("keeps offsets straight after an expansion", () => {
-    expect(matchesOf("é.é.end", { search: "end" })).toEqual([{ from: 4, to: 7 }]);
-    expect(matchesOf("ﬁﬁﬁ stop", { search: "stop" })).toEqual([{ from: 4, to: 8 }]);
-  });
-
-  test("normalizes the query whole, the document by character", () => {
-    expect(normalizeSearch("CAFÉ", false)).toBe("café");
-    expect(normalizeSearch("CAFÉ", true)).toBe("CAFÉ");
-    // Whole-string NFKD would fold this to a final sigma, which the cursor never does
-    expect(normalizeDoc("ΟΔΟΣ", false).text).toBe("οδοσ");
-  });
-
-  test("leaves a document that normalizes to itself untouched", () => {
-    const { text, expansions } = normalizeDoc("plain 日本 🎉 text", false);
-    expect(text).toBe("plain 日本 🎉 text");
-    expect(expansions).toEqual([]);
-  });
-});
-
-describe("current match", () => {
-  const matches = [
-    { from: 0, to: 2 },
-    { from: 4, to: 6 },
-    { from: 8, to: 10 },
-  ];
-
-  test("counts from one, and reports 0 off a match", () => {
-    expect(currentMatch(matches, { from: 4, to: 6 })).toBe(2);
-    expect(currentMatch(matches, { from: 8, to: 10 })).toBe(3);
-    expect(currentMatch(matches, { from: 5, to: 5 })).toBe(2);
-    expect(currentMatch(matches, { from: 2, to: 3 })).toBe(0);
-    expect(currentMatch(matches, { from: 4, to: 7 })).toBe(0);
-    expect(currentMatch([], { from: 0, to: 0 })).toBe(0);
-  });
-
-  test("moving the selection doesn't scan again", () => {
-    const state = stateOf("a1 b2 c3");
-    const query = new SearchQuery({ search: "\\d", regexp: true });
-    const counter = new MatchCounter();
-    const found = counter.matches(state, query);
-
-    // The document a selection-only transaction leaves behind is the one already scanned
-    const moved = state.update({ selection: { anchor: 4, head: 5 } }).state;
-    expect(counter.matches(moved, query)).toBe(found);
-    expect(currentMatch(found, moved.selection.main)).toBe(2);
-  });
-});
-
-/**
- * The mapping from normalized offsets back to document offsets is the part of this that can go
- * quietly wrong, and only on input nobody thinks to write a case for. So generate the input.
- */
-describe("against the cursor, on awkward text", () => {
-  const ALPHABET = [
-    ..."abcABC .\\\n".split(""),
-    "é",
-    "é",
-    "ﬁ",
-    "…",
-    " ",
-    "İ",
-    "Σ",
-    "ς",
-    "日",
-    "🎉",
-    "Ⅻ",
-    "ｆ",
-    "①",
-    "́",
-  ];
-
-  /** Seeded, so a failure is the same failure next run */
-  function random(seed: number) {
-    let state = seed;
-    return () => {
-      state = (state * 1664525 + 1013904223) >>> 0;
-      return state / 2 ** 32;
-    };
-  }
-
-  for (const caseSensitive of [false, true]) {
-    test(`agrees on every generated document (caseSensitive: ${caseSensitive})`, () => {
-      const next = random(caseSensitive ? 20260831 : 7);
-
-      for (let round = 0; round < 400; round++) {
-        const doc = Array.from(
-          { length: 2 + Math.floor(next() * 60) },
-          () => ALPHABET[Math.floor(next() * ALPHABET.length)]!,
-        ).join("");
-
-        // Half the queries are lifted out of the document, so matches are actually found
-        const start = Math.floor(next() * doc.length);
-        const search =
-          next() < 0.5
-            ? doc.slice(start, start + 1 + Math.floor(next() * 3))
-            : Array.from(
-                { length: 1 + Math.floor(next() * 2) },
-                () => ALPHABET[Math.floor(next() * ALPHABET.length)]!,
-              ).join("");
-        if (search === "") continue;
-
-        const state = stateOf(doc);
-        const query = new SearchQuery({ search, caseSensitive });
-        const where = `doc=${JSON.stringify(doc)} search=${JSON.stringify(search)}`;
-        expect(new MatchCounter().matches(state, query), where).toEqual(scanQuery(state, query));
-      }
-    });
-  }
-});
@@ -1,232 +1,7 @@
-import { getSearchQuery, type SearchQuery, searchPanelOpen } from "@codemirror/search";
-import type { EditorState, Extension, Text } from "@codemirror/state";
+import { getSearchQuery, searchPanelOpen } from "@codemirror/search";
+import type { Extension } from "@codemirror/state";
 import { type EditorView, ViewPlugin, type ViewUpdate } from "@codemirror/view";

-/** Matches are counted no further than this, since an exact total stops being useful long before */
-export const MAX_COUNT = 9999;
-
-/** What normalizing rewrites: anything outside ASCII, plus the case it folds */
-const REWRITTEN = /\P{ASCII}|[A-Z]+/gu;
-const REWRITTEN_CASE_SENSITIVE = /\P{ASCII}/gu;
-
-export interface Match {
-  from: number;
-  to: number;
-}
-
-/** A character whose normalized form is a different length, shifting every offset past it */
-interface Expansion {
-  normFrom: number;
-  normTo: number;
-  docFrom: number;
-  docTo: number;
-}
-
-/** A document as SearchCursor compares it, with what's needed to get back to real offsets */
-export interface NormalizedDoc {
-  text: string;
-  expansions: Expansion[];
-}
-
-/**
- * Rewrites a document the way SearchCursor does — NFKD, then a case fold unless the search is
- * case-sensitive — in a single pass rather than one call per code point.
- *
- * The cursor spends 90% of its time asking ICU about one character at a time, which is what
- * makes counting matches in a large response slow. Doing it a character at a time still matters
- * for the result, since it keeps NFKD from reordering marks across characters, so the
- * granularity stays and only the repeated work goes: each distinct character is normalized once
- * and the answer reused, and ASCII runs never reach ICU at all.
- */
-export function normalizeDoc(text: string, caseSensitive: boolean): NormalizedDoc {
-  const rewritten = new Map<string, string>();
-  const expansions: Expansion[] = [];
-  let shift = 0;
-
-  const normalized = text.replace(
-    caseSensitive ? REWRITTEN_CASE_SENSITIVE : REWRITTEN,
-    (chunk: string, at: number) => {
-      // An ASCII run only ever folds case, which can't change its length
-      if (chunk.charCodeAt(0) < 0x80) return chunk.toLowerCase();
-
-      let out = rewritten.get(chunk);
-      if (out === undefined) {
-        out = chunk.normalize("NFKD");
-        if (!caseSensitive) out = out.toLowerCase();
-        rewritten.set(chunk, out);
-      }
-
-      if (out.length !== chunk.length) {
-        expansions.push({
-          normFrom: at + shift,
-          normTo: at + shift + out.length,
-          docFrom: at,
-          docTo: at + chunk.length,
-        });
-        shift += out.length - chunk.length;
-      }
-
-      return out;
-    },
-  );
-
-  return { text: normalized, expansions };
-}
-
-/** The query as SearchCursor compares it, which it normalizes whole rather than by character */
-export function normalizeSearch(search: string, caseSensitive: boolean): string {
-  const normalized = search.normalize("NFKD");
-  return caseSensitive ? normalized : normalized.toLowerCase();
-}
-
-/** Every occurrence of `needle`, skipping matches that overlap an earlier one */
-export function scanNormalized(doc: NormalizedDoc, needle: string): Match[] {
-  const matches: Match[] = [];
-  if (needle === "") return matches;
-
-  const { text } = doc;
-  let pos = text.indexOf(needle);
-  while (pos >= 0) {
-    let end = pos + needle.length;
-    // However the query was cut, a match ends on a whole code point, as the cursor's do
-    if (isLowSurrogate(text.charCodeAt(end))) end++;
-
-    matches.push({ from: docStart(doc, pos), to: docEnd(doc, end) });
-    if (matches.length > MAX_COUNT) break;
-
-    pos = text.indexOf(needle, resumeAfter(doc, end));
-  }
-
-  return matches;
-}
-
-/** The same through the query's own cursor, which handles regexps and whole words */
-export function scanQuery(state: EditorState, query: SearchQuery): Match[] {
-  const matches: Match[] = [];
-  const cursor = query.getCursor(state);
-
-  for (let result = cursor.next(); !result.done; result = cursor.next()) {
-    matches.push({ from: result.value.from, to: result.value.to });
-    if (matches.length > MAX_COUNT) break;
-  }
-
-  return matches;
-}
-
-const isLowSurrogate = (code: number) => code >= 0xdc00 && code <= 0xdfff;
-
-/** The last character expansion beginning at or before `offset`, if there is one */
-function expansionAt({ expansions }: NormalizedDoc, offset: number): Expansion | null {
-  let low = 0;
-  let high = expansions.length - 1;
-  let found: Expansion | null = null;
-
-  while (low <= high) {
-    const mid = (low + high) >> 1;
-    if (expansions[mid]!.normFrom <= offset) {
-      found = expansions[mid]!;
-      low = mid + 1;
-    } else {
-      high = mid - 1;
-    }
-  }
-
-  return found;
-}
-
-function docStart(doc: NormalizedDoc, offset: number): number {
-  const expansion = expansionAt(doc, offset);
-  if (expansion == null) return offset;
-  // A match starting inside a character's expansion starts at the character
-  return offset < expansion.normTo
-    ? expansion.docFrom
-    : offset - (expansion.normTo - expansion.docTo);
-}
-
-/**
- * Where scanning picks up after a match ending at `offset`.
- *
- * The cursor moves through the document a character at a time, so once a match ends inside a
- * character's expansion the rest of that expansion is behind it — "…" holds three dots but only
- * ever counts as one match of ".".
- */
-function resumeAfter(doc: NormalizedDoc, offset: number): number {
-  const expansion = expansionAt(doc, offset);
-  return expansion != null && offset > expansion.normFrom && offset < expansion.normTo
-    ? expansion.normTo
-    : offset;
-}
-
-function docEnd(doc: NormalizedDoc, offset: number): number {
-  const expansion = expansionAt(doc, offset);
-  if (expansion == null) return offset;
-  if (offset <= expansion.normFrom) return expansion.docFrom;
-  // A match ending inside a character's expansion covers the whole character
-  return offset < expansion.normTo
-    ? expansion.docTo
-    : offset - (expansion.normTo - expansion.docTo);
-}
-
-/** Position of the match holding the selection, counting from one, or 0 when it isn't on one */
-export function currentMatch(matches: Match[], selection: { from: number; to: number }): number {
-  let index = 0;
-  for (const match of matches) {
-    index++;
-    if (match.from <= selection.from && match.to >= selection.to) return index;
-  }
-  return 0;
-}
-
-/** The text a plain query looks for, or null when only the cursor can answer it */
-export function literalSearch(query: SearchQuery): string | null {
-  if (query.regexp || query.wholeWord || query.test != null) return null;
-  // Mirrors SearchQuery's own unquoting, which the published type doesn't expose
-  return query.literal
-    ? query.search
-    : query.search.replace(/\\([nrt\\])/g, (_, ch) =>
-        ch === "n" ? "\n" : ch === "r" ? "\r" : ch === "t" ? "\t" : "\\",
-      );
-}
-
-/**
- * Finds the matches for the search panel, keeping the normalized document and the matches it
- * last found, so neither moving the selection nor typing another character starts over.
- */
-export class MatchCounter {
-  private doc: { doc: Text; caseSensitive: boolean; normalized: NormalizedDoc } | null = null;
-  private last: { doc: Text; query: SearchQuery; matches: Match[] } | null = null;
-
-  matches(state: EditorState, query: SearchQuery): Match[] {
-    const last = this.last;
-    if (last != null && last.doc === state.doc && last.query.eq(query)) {
-      return last.matches;
-    }
-
-    const matches = this.scan(state, query);
-    this.last = { doc: state.doc, query, matches };
-    return matches;
-  }
-
-  private scan(state: EditorState, query: SearchQuery): Match[] {
-    const search = literalSearch(query);
-    if (search == null) return scanQuery(state, query);
-
-    const doc = this.normalizedDoc(state.doc, query.caseSensitive);
-    return scanNormalized(doc, normalizeSearch(search, query.caseSensitive));
-  }
-
-  private normalizedDoc(doc: Text, caseSensitive: boolean): NormalizedDoc {
-    const cached = this.doc;
-    if (cached != null && cached.doc === doc && cached.caseSensitive === caseSensitive) {
-      return cached.normalized;
-    }
-
-    const normalized = normalizeDoc(doc.toString(), caseSensitive);
-    this.doc = { doc, caseSensitive, normalized };
-    return normalized;
-  }
-}
-
 /**
 * A CodeMirror extension that displays the total number of search matches
 * inside the built-in search panel.
@@ -235,7 +10,6 @@ export function searchMatchCount(): Extension {
  return ViewPlugin.fromClass(
    class {
      private countEl: HTMLElement | null = null;
-      private counter = new MatchCounter();

      constructor(private view: EditorView) {
        this.updateCount();
@@ -264,21 +38,38 @@ export function searchMatchCount(): Extension {
        }

        this.ensureCountEl();
-        if (this.countEl == null) return;

        if (!query.search) {
-          this.countEl.textContent = "0/0";
+          if (this.countEl) {
+            this.countEl.textContent = "0/0";
+          }
          return;
        }

-        const matches = this.counter.matches(state, query);
-        if (matches.length > MAX_COUNT) {
-          this.countEl.textContent = `${MAX_COUNT}+`;
-        } else if (matches.length === 0) {
-          this.countEl.textContent = "0/0";
-        } else {
-          const current = currentMatch(matches, state.selection.main);
-          this.countEl.textContent = `${current}/${matches.length}`;
+        const selection = state.selection.main;
+        let count = 0;
+        let currentIndex = 0;
+        const MAX_COUNT = 9999;
+        const cursor = query.getCursor(state);
+        for (let result = cursor.next(); !result.done; result = cursor.next()) {
+          count++;
+          const match = result.value;
+          if (match.from <= selection.from && match.to >= selection.to) {
+            currentIndex = count;
+          }
+          if (count > MAX_COUNT) break;
+        }
+
+        if (this.countEl) {
+          if (count > MAX_COUNT) {
+            this.countEl.textContent = `${MAX_COUNT}+`;
+          } else if (count === 0) {
+            this.countEl.textContent = "0/0";
+          } else if (currentIndex > 0) {
+            this.countEl.textContent = `${currentIndex}/${count}`;
+          } else {
+            this.countEl.textContent = `0/${count}`;
+          }
        }
      }

@@ -119,13 +119,9 @@ export function Select<T extends string>({
          )}
        >
          <Button
-            className={classNames(
-              "w-full text-sm font-mono",
-              disabled && "border-dotted",
-              isInvalidSelection && "border-danger",
-            )}
+            className="w-full text-sm font-mono"
            justify="start"
-            variant="input"
+            variant="border"
            size={size}
            leftSlot={leftSlot}
            disabled={disabled}
@@ -86,8 +86,10 @@ export async function promptDivergedStrategy({
    showDialog({
      id: "git-diverged",
      title: "Branches Diverged",
+      hideX: true,
      size: "sm",
-      disableClose: true,
+      disableBackdropClose: true,
+      onClose: () => resolve("cancel"),
      render: ({ hide }) =>
        DivergedDialog({
          remote,
@@ -14,8 +14,9 @@ export function showAlert({ id, title, body, size = "sm" }: AlertArgs) {
  showDialog({
    id,
    title,
+    hideX: true,
    size,
-    disableClose: true,
+    disableBackdropClose: true, // Prevent accidental dismisses
    render: ({ hide }) => Alert({ onHide: hide, body }),
  });
 }
@@ -18,8 +18,9 @@ export async function showConfirm({
  return new Promise((onResult: ConfirmProps["onResult"]) => {
    showDialog({
      ...extraProps,
+      hideX: true,
      size,
-      disableClose: true,
+      disableBackdropClose: true, // Prevent accidental dismisses
      render: ({ hide }) => Confirm({ onHide: hide, color, onResult, confirmText, requireTyping }),
    });
  });
@@ -1,18 +1,10 @@
-import {
-  type BatchUpsertResult,
-  type ImportDestination,
-  type ImportPlan,
-  workspacesAtom,
-} from "@yaakapp-internal/models";
+import type { BatchUpsertResult } from "@yaakapp-internal/models";
 import { FormattedError, VStack } from "@yaakapp-internal/ui";
 import { Button } from "../components/core/Button";
 import { ImportDataDialog } from "../components/ImportDataDialog";
-import { activeFolderAtom } from "../hooks/useActiveFolder";
-import { activeWorkspaceAtom } from "../hooks/useActiveWorkspace";
 import { createFastMutation } from "../hooks/useFastMutation";
 import { showAlert } from "./alert";
 import { showDialog } from "./dialog";
-import { jotaiStore } from "./jotai";
 import { pluralizeCount } from "./pluralize";
 import { router } from "./router";
 import { rpc } from "./rpc";
@@ -29,43 +21,29 @@ export const importData = createFastMutation({
  },
  mutationFn: async () => {
    return new Promise<void>((resolve, reject) => {
-      const currentWorkspace = jotaiStore.get(activeWorkspaceAtom);
-      const workspaces = jotaiStore.get(workspacesAtom);
-      const selectedFolder = jotaiStore.get(activeFolderAtom);
      showDialog({
        id: "import",
        title: "Import Data",
        size: "sm",
-        disableClose: true,
        render: ({ hide }) => {
-          const cancel = () => {
-            hide();
-            resolve();
-          };
-          const fail = (err: unknown) => {
-            hide();
-            reject(err);
-          };
-          const commit = async (plan: ImportPlan) => {
-            const imported = await rpc<BatchUpsertResult>("cmd_commit_import", { plan });
-            hide();
-            await finishImport(imported);
-            resolve();
+          const importAndHide = async (runImport: () => Promise<BatchUpsertResult>) => {
+            try {
+              await finishImport(await runImport());
+              resolve();
+            } catch (err) {
+              reject(err);
+            } finally {
+              hide();
+            }
          };
          return (
            <ImportDataDialog
-              currentWorkspace={currentWorkspace}
-              workspaces={workspaces}
-              selectedFolder={selectedFolder}
-              planFile={(filePath: string, destination: ImportDestination) =>
-                rpc<ImportPlan>("cmd_import_data", { filePath, destination })
+              importFile={(filePath) =>
+                importAndHide(() => rpc<BatchUpsertResult>("cmd_import_data", { filePath }))
              }
-              planUrl={(url: string, destination: ImportDestination) =>
-                rpc<ImportPlan>("cmd_import_url", { url, destination })
+              importUrl={(url) =>
+                importAndHide(() => rpc<BatchUpsertResult>("cmd_import_url", { url }))
              }
-              commit={commit}
-              cancel={cancel}
-              onError={fail}
            />
          );
        },
@@ -12,7 +12,7 @@ import type {
  UpdateResponse,
  YaakNotification,
 } from "@yaakapp-internal/tauri-client";
-import { HStack, Icon, InlineCode, VStack } from "@yaakapp-internal/ui";
+import { HStack, Icon, VStack } from "@yaakapp-internal/ui";
 import { openSettings } from "../commands/openSettings";
 import { Button } from "../components/core/Button";
 import { ButtonInfiniteLoading } from "../components/core/ButtonInfiniteLoading";
@@ -180,65 +180,9 @@ function showUpdateInstalledToast(version: string) {

 async function showUpdateAvailableToast(updateInfo: UpdateInfo) {
  const UPDATE_TOAST_ID = "update-info";
-  const { version, replyEventId, downloaded, install } = updateInfo;
+  const { version, replyEventId, downloaded } = updateInfo;

-  jotaiStore.set(updateAvailableAtom, { version, downloaded, install });
-
-  const whatsNewButton = (
-    <Button
-      size="xs"
-      color="info"
-      variant="border"
-      rightSlot={<Icon icon="external_link" />}
-      onClick={async () => {
-        await platform.openUrl(`https://yaak.app/changelog/${version}`);
-      }}
-    >
-      What&apos;s New
-    </Button>
-  );
-
-  if (install !== "integrated") {
-    // Nothing to reply to here; the backend only told us so we can say how to update
-    const flatpak = install === "flatpak";
-    showToast({
-      id: UPDATE_TOAST_ID,
-      color: "info",
-      timeout: null,
-      message: (
-        <VStack>
-          <h2 className="font-semibold">Yaak {version} is available</h2>
-          <p className="text-text-subtle text-sm">
-            {flatpak ? (
-              <>
-                Update with <InlineCode>flatpak update</InlineCode> or your software center.
-              </>
-            ) : (
-              "Download the new version to upgrade."
-            )}
-          </p>
-        </VStack>
-      ),
-      action: () => (
-        <HStack space={1.5}>
-          {!flatpak && (
-            <Button
-              size="xs"
-              color="info"
-              rightSlot={<Icon icon="external_link" />}
-              onClick={async () => {
-                await platform.openUrl("https://yaak.app/download");
-              }}
-            >
-              Download
-            </Button>
-          )}
-          {whatsNewButton}
-        </HStack>
-      ),
-    });
-    return;
-  }
+  jotaiStore.set(updateAvailableAtom, { version, downloaded });

  // Acknowledge the event, so we don't time out and try the fallback update logic
  await platform.emit(replyEventId, { type: "ack" } satisfies UpdateResponse);
@@ -271,7 +215,17 @@ async function showUpdateAvailableToast(updateInfo: UpdateInfo) {
        >
          {downloaded ? "Install Now" : "Download and Install"}
        </ButtonInfiniteLoading>
-        {whatsNewButton}
+        <Button
+          size="xs"
+          color="info"
+          variant="border"
+          rightSlot={<Icon icon="external_link" />}
+          onClick={async () => {
+            await platform.openUrl(`https://yaak.app/changelog/${version}`);
+          }}
+        >
+          What&apos;s New
+        </Button>
      </HStack>
    ),
  });
@@ -1,251 +0,0 @@
-import { describe, expect, test } from "vite-plus/test";
-import type { JsonSchema } from "./jsonSchemaExample";
-import { buildExampleFromSchema } from "./jsonSchemaExample";
-
-describe("buildExampleFromSchema", () => {
-  test("fills scalar fields with placeholders", () => {
-    const schema: JsonSchema = {
-      type: "object",
-      properties: {
-        name: { type: "string" },
-        age: { type: "number", format: "int32" },
-        active: { type: "boolean" },
-        data: { type: "string", format: "byte" },
-      },
-    };
-
-    expect(buildExampleFromSchema(schema)).toEqual({
-      name: "",
-      age: 0,
-      active: false,
-      data: "",
-    });
-  });
-
-  test("encodes 64-bit integers as strings", () => {
-    const schema: JsonSchema = {
-      type: "object",
-      properties: {
-        id: { type: "string", format: "int64" },
-        count: { type: "string", format: "uint64" },
-        offset: { type: "string", format: "sfixed64" },
-      },
-    };
-
-    expect(buildExampleFromSchema(schema)).toEqual({ id: "0", count: "0", offset: "0" });
-  });
-
-  test("fills date-time with a parseable timestamp", () => {
-    const schema: JsonSchema = {
-      type: "object",
-      properties: { createdAt: { type: "string", format: "date-time" } },
-    };
-
-    const example = buildExampleFromSchema(schema) as { createdAt: string };
-    expect(Number.isNaN(Date.parse(example.createdAt))).toBe(false);
-  });
-
-  test("fills a duration with a value that parses", () => {
-    const schema: JsonSchema = {
-      type: "object",
-      properties: { timeout: { type: "string", format: "duration" } },
-    };
-
-    // An empty string fails protobuf's Duration parsing, so the message wouldn't send
-    expect(buildExampleFromSchema(schema)).toEqual({ timeout: "0s" });
-  });
-
-  test("expands nested messages through $defs", () => {
-    const schema: JsonSchema = {
-      type: "object",
-      properties: { user: { $ref: "#/$defs/example.User" } },
-      $defs: {
-        "example.User": {
-          type: "object",
-          properties: {
-            name: { type: "string" },
-            address: { $ref: "#/$defs/example.Address" },
-          },
-        },
-        "example.Address": {
-          type: "object",
-          properties: { city: { type: "string" } },
-        },
-      },
-    };
-
-    expect(buildExampleFromSchema(schema)).toEqual({
-      user: { name: "", address: { city: "" } },
-    });
-  });
-
-  test("gives repeated fields a single placeholder item", () => {
-    const schema: JsonSchema = {
-      type: "object",
-      properties: {
-        tags: { type: "array", items: { type: "string" } },
-        users: { type: "array", items: { $ref: "#/$defs/example.User" } },
-        unknown: { type: "array" },
-      },
-      $defs: {
-        "example.User": { type: "object", properties: { name: { type: "string" } } },
-      },
-    };
-
-    expect(buildExampleFromSchema(schema)).toEqual({
-      tags: [""],
-      users: [{ name: "" }],
-      unknown: [],
-    });
-  });
-
-  test("uses the first value of an enum", () => {
-    const schema: JsonSchema = {
-      type: "object",
-      properties: {
-        status: { type: "string", enum: ["STATUS_UNSPECIFIED", "STATUS_ACTIVE"] },
-        empty: { type: "string", enum: [] },
-      },
-    };
-
-    expect(buildExampleFromSchema(schema)).toEqual({ status: "STATUS_UNSPECIFIED", empty: "" });
-  });
-
-  test("gives maps a single placeholder entry", () => {
-    const schema: JsonSchema = {
-      type: "object",
-      properties: {
-        labels: { type: "object", additionalProperties: { type: "string" } },
-        users: { type: "object", additionalProperties: { $ref: "#/$defs/example.User" } },
-      },
-      $defs: {
-        "example.User": { type: "object", properties: { name: { type: "string" } } },
-      },
-    };
-
-    expect(buildExampleFromSchema(schema)).toEqual({
-      labels: { key: "" },
-      users: { key: { name: "" } },
-    });
-  });
-
-  test("stops at the root self-reference", () => {
-    const schema: JsonSchema = {
-      type: "object",
-      properties: {
-        value: { type: "string" },
-        children: { type: "array", items: { $ref: "#" } },
-      },
-    };
-
-    expect(buildExampleFromSchema(schema)).toEqual({ value: "", children: [{}] });
-  });
-
-  test("stops at a cycle between messages", () => {
-    const schema: JsonSchema = {
-      type: "object",
-      properties: { node: { $ref: "#/$defs/example.Node" } },
-      $defs: {
-        "example.Node": {
-          type: "object",
-          properties: {
-            name: { type: "string" },
-            parent: { $ref: "#/$defs/example.Node" },
-            leaf: { $ref: "#/$defs/example.Leaf" },
-          },
-        },
-        "example.Leaf": {
-          type: "object",
-          properties: { node: { $ref: "#/$defs/example.Node" } },
-        },
-      },
-    };
-
-    expect(buildExampleFromSchema(schema)).toEqual({
-      node: { name: "", parent: {}, leaf: { node: {} } },
-    });
-  });
-
-  test("expands the same message twice when it is not on the same path", () => {
-    const schema: JsonSchema = {
-      type: "object",
-      properties: {
-        from: { $ref: "#/$defs/example.User" },
-        to: { $ref: "#/$defs/example.User" },
-      },
-      $defs: {
-        "example.User": { type: "object", properties: { name: { type: "string" } } },
-      },
-    };
-
-    expect(buildExampleFromSchema(schema)).toEqual({ from: { name: "" }, to: { name: "" } });
-  });
-
-  test("fills every branch of a flattened oneof", () => {
-    const schema: JsonSchema = {
-      type: "object",
-      properties: {
-        id: { type: "string" },
-        text: { type: "string" },
-        image: { $ref: "#/$defs/example.Image" },
-      },
-      $defs: {
-        "example.Image": { type: "object", properties: { url: { type: "string" } } },
-      },
-    };
-
-    expect(buildExampleFromSchema(schema)).toEqual({
-      id: "",
-      text: "",
-      image: { url: "" },
-    });
-  });
-
-  test("stops expanding once the node budget runs out", () => {
-    // Every level references the next one twice, so an unbounded walk would build 2^depth
-    // nodes without ever repeating a ref on the same path.
-    const depth = 16;
-    const $defs: Record<string, JsonSchema> = { [`d${depth}`]: { type: "string" } };
-    for (let i = 0; i < depth; i++) {
-      $defs[`d${i}`] = {
-        type: "object",
-        properties: {
-          a: { $ref: `#/$defs/d${i + 1}` },
-          b: { $ref: `#/$defs/d${i + 1}` },
-        },
-      };
-    }
-
-    const example = buildExampleFromSchema({
-      type: "object",
-      properties: { root: { $ref: "#/$defs/d0" } },
-      $defs,
-    });
-
-    // 2 ** 16 nodes unbounded; the budget holds it to a couple of thousand
-    expect(countNodes(example)).toBeLessThan(10_000);
-  });
-
-  test("handles messages without a known type", () => {
-    const schema: JsonSchema = {
-      type: "object",
-      properties: {
-        empty: {},
-        struct: { type: "object" },
-        missing: { $ref: "#/$defs/example.Nope" },
-      },
-    };
-
-    expect(buildExampleFromSchema(schema)).toEqual({ empty: null, struct: {}, missing: {} });
-  });
-});
-
-function countNodes(value: unknown): number {
-  if (Array.isArray(value)) {
-    return 1 + value.reduce((total: number, v) => total + countNodes(v), 0);
-  }
-  if (value !== null && typeof value === "object") {
-    return 1 + Object.values(value).reduce((total: number, v) => total + countNodes(v), 0);
-  }
-  return 1;
-}
@@ -1,121 +0,0 @@
-/**
- * Subset of JSON Schema emitted by the gRPC reflection layer for a method's
- * input message. See `message_to_json_schema` in the `yaak-grpc` crate.
- */
-export type JsonSchema = {
-  type?: string;
-  format?: string;
-  properties?: Record<string, JsonSchema>;
-  items?: JsonSchema;
-  additionalProperties?: JsonSchema;
-  enum?: unknown[];
-  $defs?: Record<string, JsonSchema>;
-  $ref?: string;
-};
-
-const DEFS_PREFIX = "#/$defs/";
-const ROOT_REF = "#";
-
-// Protobuf 64-bit integers are encoded as strings in the JSON mapping
-const STRING_NUMBER_FORMATS = ["int64", "uint64", "sint64", "fixed64", "sfixed64"];
-
-// Refs on sibling branches each expand their own subtree, so a schema that references the
-// same messages repeatedly can produce exponentially many nodes without ever cycling.
-const MAX_NODES = 5000;
-
-type Budget = { remaining: number };
-
-/** Build a sample message with placeholder values for every field in the schema */
-export function buildExampleFromSchema(schema: JsonSchema): unknown {
-  // The root is already being built, so a `#` ref anywhere below it is a cycle
-  return buildValue(schema, schema, new Set([ROOT_REF]), { remaining: MAX_NODES });
-}
-
-function buildValue(
-  schema: JsonSchema,
-  root: JsonSchema,
-  refPath: Set<string>,
-  budget: Budget,
-): unknown {
-  if (schema == null || typeof schema !== "object" || budget.remaining <= 0) {
-    return null;
-  }
-
-  budget.remaining -= 1;
-
-  if (typeof schema.$ref === "string") {
-    if (refPath.has(schema.$ref)) {
-      return {};
-    }
-    const resolved = resolveRef(schema.$ref, root);
-    if (resolved == null) {
-      return {};
-    }
-    return buildValue(resolved, root, new Set(refPath).add(schema.$ref), budget);
-  }
-
-  if (Array.isArray(schema.enum)) {
-    return schema.enum[0] ?? "";
-  }
-
-  switch (schema.type) {
-    case "object":
-      return buildObject(schema, root, refPath, budget);
-    case "array":
-      return schema.items == null ? [] : [buildValue(schema.items, root, refPath, budget)];
-    case "string":
-      return buildString(schema.format);
-    case "number":
-      return 0;
-    case "boolean":
-      return false;
-    default:
-      return null;
-  }
-}
-
-function buildObject(
-  schema: JsonSchema,
-  root: JsonSchema,
-  refPath: Set<string>,
-  budget: Budget,
-): unknown {
-  if (schema.properties != null && typeof schema.properties === "object") {
-    const example: Record<string, unknown> = {};
-    for (const [name, propertySchema] of Object.entries(schema.properties)) {
-      example[name] = buildValue(propertySchema, root, refPath, budget);
-    }
-    return example;
-  }
-
-  // Maps have no properties, only a value schema
-  if (schema.additionalProperties != null) {
-    return { key: buildValue(schema.additionalProperties, root, refPath, budget) };
-  }
-
-  return {};
-}
-
-function buildString(format: string | undefined): string {
-  if (format === "date-time") {
-    return new Date().toISOString();
-  }
-  // Duration JSON is a decimal string with an `s` suffix, and an empty one fails to parse
-  if (format === "duration") {
-    return "0s";
-  }
-  if (format != null && STRING_NUMBER_FORMATS.includes(format)) {
-    return "0";
-  }
-  return "";
-}
-
-function resolveRef(ref: string, root: JsonSchema): JsonSchema | null {
-  if (ref === ROOT_REF) {
-    return root;
-  }
-  if (!ref.startsWith(DEFS_PREFIX)) {
-    return null;
-  }
-  return root.$defs?.[ref.slice(DEFS_PREFIX.length)] ?? null;
-}
@@ -25,8 +25,13 @@ export async function showPromptForm({
      id,
      title,
      description,
+      hideX: true,
      size: size ?? "sm",
-      disableClose: true,
+      disableBackdropClose: true, // Prevent accidental dismisses
+      onClose: () => {
+        // Click backdrop, close, or escape
+        resolve(null);
+      },
      render: ({ hide }) =>
        Prompt({
          onCancel: () => {
@@ -5,7 +5,6 @@ type ModelType = AnyModel["model"];
 type WorkspaceRequestSettings = Pick<
  Workspace,
  | "settingFollowRedirects"
-  | "settingHttpVersion"
  | "settingRequestMessageSize"
  | "settingRequestTimeout"
  | "settingSendCookies"
@@ -19,7 +18,9 @@ type ModelTypeWithSetting<K extends RequestSettingKey> = {
  [M in ModelType]: K extends keyof ModelForType<M> ? M : never;
 }[ModelType];

-export type RequestSettingDefinition<K extends RequestSettingKey = RequestSettingKey> = {
+export type RequestSettingDefinition<
+  K extends RequestSettingKey = RequestSettingKey,
+> = {
  defaultValue: WorkspaceRequestSettings[K];
  description: string;
  modelKey: K;
@@ -45,7 +46,8 @@ export const SETTING_REQUEST_TIMEOUT = defineRequestSetting({

 export const SETTING_REQUEST_MESSAGE_SIZE = defineRequestSetting({
  defaultValue: 64 * 1024 * 1024,
-  description: "Maximum gRPC or WebSocket message size in MB. Set to 0 to disable.",
+  description:
+    "Maximum gRPC or WebSocket message size in MB. Set to 0 to disable.",
  modelKey: "settingRequestMessageSize",
  models: ["workspace", "folder", "websocket_request", "grpc_request"],
  title: "Message Size Limit",
@@ -55,7 +57,13 @@ export const SETTING_VALIDATE_CERTIFICATES = defineRequestSetting({
  defaultValue: true,
  description: "When disabled, skip validation of server certificates.",
  modelKey: "settingValidateCertificates",
-  models: ["workspace", "folder", "http_request", "websocket_request", "grpc_request"],
+  models: [
+    "workspace",
+    "folder",
+    "http_request",
+    "websocket_request",
+    "grpc_request",
+  ],
  title: "Validate TLS certificates",
 });

@@ -67,17 +75,10 @@ export const SETTING_FOLLOW_REDIRECTS = defineRequestSetting({
  title: "Follow redirects",
 });

-export const SETTING_HTTP_VERSION = defineRequestSetting({
-  defaultValue: "auto",
-  description: "Force HTTP/1.1 or HTTP/2 for servers that don't negotiate the version correctly.",
-  modelKey: "settingHttpVersion",
-  models: ["workspace", "folder", "http_request"],
-  title: "HTTP version",
-});
-
 export const SETTING_SEND_COOKIES = defineRequestSetting({
  defaultValue: true,
-  description: "Attach matching cookies from the active cookie jar to outgoing requests.",
+  description:
+    "Attach matching cookies from the active cookie jar to outgoing requests.",
  modelKey: "settingSendCookies",
  models: ["workspace", "folder", "http_request", "websocket_request"],
  title: "Automatically send cookies",
@@ -85,7 +86,8 @@ export const SETTING_SEND_COOKIES = defineRequestSetting({

 export const SETTING_STORE_COOKIES = defineRequestSetting({
  defaultValue: true,
-  description: "Save cookies from Set-Cookie response headers to the active cookie jar.",
+  description:
+    "Save cookies from Set-Cookie response headers to the active cookie jar.",
  modelKey: "settingStoreCookies",
  models: ["workspace", "folder", "http_request", "websocket_request"],
  title: "Automatically store cookies",
@@ -5,7 +5,8 @@ use std::fs;
 use std::io::ErrorKind;
 use yaak::export::{self, ExportDataParams};
 use yaak::import;
-use yaak_models::util::{BatchUpsertResult, ImportDestination};
+use yaak_core::WorkspaceContext;
+use yaak_models::util::BatchUpsertResult;
 use yaak_plugins::events::{ImportResources, PluginContext};

 type CommandResult<T = ()> = std::result::Result<T, String>;
@@ -50,7 +51,6 @@ async fn import(ctx: &CliContext, args: ImportArgs) -> CommandResult<BatchUpsert
        .import_data(&plugin_context, &file_contents)
        .await
        .map_err(|e| format!("Failed to import data: {e}"))?;
-    let importer = import_result.importer;
    let resources = import_result.resources;
    let workspace_id = args.workspace_id;
    if workspace_id.is_none() && resources_need_current_workspace(&resources) {
@@ -59,19 +59,13 @@ async fn import(ctx: &CliContext, args: ImportArgs) -> CommandResult<BatchUpsert
                .to_string(),
        );
    }
-    let destination = match workspace_id {
-        Some(workspace_id) => ImportDestination::ExistingWorkspace { workspace_id, folder_id: None },
-        None => ImportDestination::NewWorkspace,
+    let workspace_context = WorkspaceContext {
+        workspace_id,
+        environment_id: None,
+        cookie_jar_id: None,
+        request_id: None,
    };
-    let plan = import::plan_import_resources(
-        ctx.query_manager(),
-        importer,
-        destination,
-        resources,
-        import_result.source_keys,
-    )
-    .map_err(|e| format!("Failed to plan import: {e}"))?;
-    let imported = import::commit_import_plan(ctx.query_manager(), plan)
+    let imported = import::import_resources(ctx.query_manager(), workspace_context, resources)
        .map_err(|e| format!("Failed to import data: {e}"))?;
    Ok(imported)
 }
@@ -81,21 +81,14 @@ fn import_reads_yaak_workspace_file() {

    let query_manager = query_manager(data_dir);
    let db = query_manager.connect();
-    let workspaces = db.list_workspaces().expect("list imported workspaces");
-    let workspace = workspaces
-        .iter()
-        .find(|workspace| workspace.name == "Imported Workspace")
-        .expect("workspace imported");
-    assert_ne!(workspace.id, "wrk_import");
-
-    let requests = db.list_http_requests(&workspace.id).expect("list imported requests");
-    let request = requests
-        .iter()
-        .find(|request| request.name == "Imported Request")
-        .expect("request imported");
-    assert_ne!(request.id, "req_import");
-    assert_eq!(request.workspace_id, workspace.id);
-    assert_eq!(request.url, "https://example.com");
+    assert_eq!(
+        db.get_workspace("wrk_import").expect("workspace imported").name,
+        "Imported Workspace"
+    );
+    assert_eq!(
+        db.get_http_request("req_import").expect("request imported").url,
+        "https://example.com"
+    );
 }

 fn write_postman_environment_fixture(path: &std::path::Path) {
@@ -1,135 +1,48 @@
 // This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.

-export type Cookie = {
-  name: string;
-  value: string;
-  domain: CookieDomain;
-  expires: CookieExpires;
-  path: string;
-  secure: boolean;
-  httpOnly: boolean;
-  sameSite: CookieSameSite | null;
-};
+export type Cookie = { name: string, value: string, domain: CookieDomain, expires: CookieExpires, path: string, secure: boolean, httpOnly: boolean, sameSite: CookieSameSite | null, };

-export type CookieDomain = { HostOnly: string } | { Suffix: string } | "NotPresent" | "Empty";
+export type CookieDomain = { "HostOnly": string } | { "Suffix": string } | "NotPresent" | "Empty";

-export type CookieExpires = { AtUtc: string } | "SessionEnd";
+export type CookieExpires = { "AtUtc": string } | "SessionEnd";

 export type CookieSameSite = "Strict" | "Lax" | "None";

-export type HttpRequest = {
-  model: "http_request";
-  id: string;
-  createdAt: string;
-  updatedAt: string;
-  workspaceId: string;
-  folderId: string | null;
-  authentication: Record<string, any>;
-  authenticationType: string | null;
-  body: Record<string, any>;
-  bodyType: string | null;
-  description: string;
-  headers: Array<HttpRequestHeader>;
-  method: string;
-  name: string;
-  sortPriority: number;
-  url: string;
-  /**
-   * URL parameters used for both path placeholders (`:id`) and query string entries.
-   */
-  urlParameters: Array<HttpUrlParameter>;
-  settingSendCookies: InheritedBoolSetting;
-  settingStoreCookies: InheritedBoolSetting;
-  settingValidateCertificates: InheritedBoolSetting;
-  settingFollowRedirects: InheritedBoolSetting;
-  settingRequestTimeout: InheritedIntSetting;
-  settingHttpVersion: InheritedHttpVersionSetting;
-};
+export type HttpRequest = { model: "http_request", id: string, createdAt: string, updatedAt: string, workspaceId: string, folderId: string | null, authentication: Record<string, any>, authenticationType: string | null, body: Record<string, any>, bodyType: string | null, description: string, headers: Array<HttpRequestHeader>, method: string, name: string, sortPriority: number, url: string, 
+/**
+ * URL parameters used for both path placeholders (`:id`) and query string entries.
+ */
+urlParameters: Array<HttpUrlParameter>, settingSendCookies: InheritedBoolSetting, settingStoreCookies: InheritedBoolSetting, settingValidateCertificates: InheritedBoolSetting, settingFollowRedirects: InheritedBoolSetting, settingRequestTimeout: InheritedIntSetting, };

-export type HttpRequestHeader = { enabled?: boolean; name: string; value: string; id?: string };
+export type HttpRequestHeader = { enabled?: boolean, name: string, value: string, id?: string, };

 /**
 * Serializable representation of HTTP response events for DB storage.
 * This mirrors `yaak_http::sender::HttpResponseEvent` but with serde support.
 * The `From` impl is in yaak-http to avoid circular dependencies.
 */
-export type HttpResponseEventData =
-  | {
-      type: "setting";
-      name: string;
-      value: string;
-      source_model?: string;
-      source_id?: string;
-      source_name?: string;
-    }
-  | { type: "info"; message: string }
-  | {
-      type: "redirect";
-      url: string;
-      status: number;
-      behavior: string;
-      dropped_body: boolean;
-      dropped_headers: Array<string>;
-    }
-  | {
-      type: "send_url";
-      method: string;
-      scheme: string;
-      username: string;
-      password: string;
-      host: string;
-      port: number;
-      path: string;
-      query: string;
-      fragment: string;
-    }
-  | { type: "receive_url"; version: string; status: string }
-  | { type: "header_up"; name: string; value: string }
-  | { type: "header_down"; name: string; value: string }
-  | { type: "chunk_sent"; bytes: number }
-  | { type: "chunk_received"; bytes: number }
-  | {
-      type: "dns_resolved";
-      hostname: string;
-      addresses: Array<string>;
-      duration: bigint;
-      overridden: boolean;
-    };
+export type HttpResponseEventData = { "type": "setting", name: string, value: string, source_model?: string, source_id?: string, source_name?: string, } | { "type": "info", message: string, } | { "type": "redirect", url: string, status: number, behavior: string, dropped_body: boolean, dropped_headers: Array<string>, } | { "type": "send_url", method: string, scheme: string, username: string, password: string, host: string, port: number, path: string, query: string, fragment: string, } | { "type": "receive_url", version: string, status: string, } | { "type": "header_up", name: string, value: string, } | { "type": "header_down", name: string, value: string, } | { "type": "chunk_sent", bytes: number, } | { "type": "chunk_received", bytes: number, } | { "type": "dns_resolved", hostname: string, addresses: Array<string>, duration: bigint, overridden: boolean, };

-export type HttpResponseHeader = { name: string; value: string };
+export type HttpResponseHeader = { name: string, value: string, };

 /**
 * The resolved send settings, values only: what an executor has to obey, with the sources
 * (which model each came from) left behind in [`ResolvedHttpRequestSettings`]. This is what
 * crosses from a tab to the Yaak server, and what the server reads.
 */
-export type HttpSendSettings = {
-  validateCertificates: boolean;
-  followRedirects: boolean;
-  /**
-   * Milliseconds. Zero or negative means no timeout.
-   */
-  timeoutMs: number;
-  sendCookies: boolean;
-  storeCookies: boolean;
-  httpVersion: HttpVersion;
-};
+export type HttpSendSettings = { validateCertificates: boolean, followRedirects: boolean, 
+/**
+ * Milliseconds. Zero or negative means no timeout.
+ */
+timeoutMs: number, sendCookies: boolean, storeCookies: boolean, };

-export type HttpUrlParameter = {
-  enabled?: boolean;
-  /**
-   * Colon-prefixed parameters are treated as path parameters if they match, like `/users/:id`
-   * Other entries are appended as query parameters
-   */
-  name: string;
-  value: string;
-  id?: string;
-};
+export type HttpUrlParameter = { enabled?: boolean, 
+/**
+ * Colon-prefixed parameters are treated as path parameters if they match, like `/users/:id`
+ * Other entries are appended as query parameters
+ */
+name: string, value: string, id?: string, };

-export type HttpVersion = "auto" | "http1" | "http2";
+export type InheritedBoolSetting = { enabled?: boolean, value: boolean, };

-export type InheritedBoolSetting = { enabled?: boolean; value: boolean };
-
-export type InheritedHttpVersionSetting = { enabled?: boolean; value: HttpVersion };
-
-export type InheritedIntSetting = { enabled?: boolean; value: number };
+export type InheritedIntSetting = { enabled?: boolean, value: number, };
@@ -157,7 +157,6 @@ impl PreparedSend {
        let (client, resolver) = HttpConnectionOptions {
            id: uuid::Uuid::new_v4().to_string(),
            validate_certificates: self.settings.validate_certificates,
-            http_version: self.settings.http_version,
            // The proxy connects directly. Going through a system proxy would move DNS, and
            // therefore the address check, somewhere this process can't see.
            proxy: HttpConnectionProxySetting::Disabled,
@@ -1,37 +1,15 @@
 // This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.

-export type PluginUpdateInfo = { name: string; currentVersion: string; latestVersion: string };
+export type PluginUpdateInfo = { name: string, currentVersion: string, latestVersion: string, };

-export type PluginUpdateNotification = { updateCount: number; plugins: Array<PluginUpdateInfo> };
+export type PluginUpdateNotification = { updateCount: number, plugins: Array<PluginUpdateInfo>, };

-export type UpdateInfo = {
-  replyEventId: string;
-  version: string;
-  downloaded: boolean;
-  /**
-   * How this update gets applied. Anything but `Integrated` means the app can't do it
-   * itself and the user is told how to update instead.
-   */
-  install: UpdateInstall;
-};
+export type UpdateInfo = { replyEventId: string, version: string, downloaded: boolean, };

-/**
- * How an update can be applied to this install.
- */
-export type UpdateInstall = "integrated" | "flatpak" | "manual";
-
-export type UpdateResponse = { type: "ack" } | { type: "action"; action: UpdateResponseAction };
+export type UpdateResponse = { "type": "ack" } | { "type": "action", action: UpdateResponseAction, };

 export type UpdateResponseAction = "install" | "skip";

-export type YaakNotification = {
-  timestamp: string;
-  timeout: number | null;
-  id: string;
-  title: string | null;
-  message: string;
-  color: string | null;
-  action: YaakNotificationAction | null;
-};
+export type YaakNotification = { timestamp: string, timeout: number | null, id: string, title: string | null, message: string, color: string | null, action: YaakNotificationAction | null, };

-export type YaakNotificationAction = { label: string; url: string };
+export type YaakNotificationAction = { label: string, url: string, };
@@ -4,63 +4,53 @@ use crate::models_ext::QueryManagerExt;
 use std::fs::read_to_string;
 use std::io::ErrorKind;
 use tauri::{Manager, Runtime, WebviewWindow};
-use yaak::import::{self, PlanImportDataParams};
+use yaak::import::{self, ImportDataParams};
 use yaak_api::{ApiClientKind, yaak_api_client};
-use yaak_models::util::{BatchUpsertResult, ImportDestination, ImportPlan};
+use yaak_core::WorkspaceContext;
+use yaak_models::util::BatchUpsertResult;
 use yaak_plugins::manager::PluginManager;
+use yaak_tauri_utils::window::WorkspaceWindowTrait;

 pub(crate) async fn import_data<R: Runtime>(
    window: &WebviewWindow<R>,
    file_path: &str,
 ) -> Result<BatchUpsertResult> {
-    let plan = plan_import_data(window, file_path, ImportDestination::NewWorkspace).await?;
-    commit_import(window, plan)
-}
-
-pub(crate) async fn plan_import_data<R: Runtime>(
-    window: &WebviewWindow<R>,
-    file_path: &str,
-    destination: ImportDestination,
-) -> Result<ImportPlan> {
    let contents = read_import_file(file_path)?;
-    plan_import_contents(window, &contents, destination).await
+    import_contents(window, &contents).await
 }

-pub(crate) async fn plan_import_url<R: Runtime>(
+pub(crate) async fn import_url<R: Runtime>(
    window: &WebviewWindow<R>,
    url: &str,
-    destination: ImportDestination,
-) -> Result<ImportPlan> {
+) -> Result<BatchUpsertResult> {
    let contents = fetch_import_url(window, url).await?;
-    plan_import_contents(window, &contents, destination).await
+    import_contents(window, &contents).await
 }

-async fn plan_import_contents<R: Runtime>(
+async fn import_contents<R: Runtime>(
    window: &WebviewWindow<R>,
    contents: &str,
-    destination: ImportDestination,
-) -> Result<ImportPlan> {
+) -> Result<BatchUpsertResult> {
    let plugin_manager = window.state::<PluginManager>();
    let query_manager = window.db_manager();
    let plugin_context = window.plugin_context();
+    let workspace_context = WorkspaceContext {
+        workspace_id: window.workspace_id(),
+        environment_id: window.environment_id(),
+        cookie_jar_id: window.cookie_jar_id(),
+        request_id: None,
+    };

-    Ok(import::plan_import_data(PlanImportDataParams {
+    Ok(import::import_data(ImportDataParams {
        query_manager: &query_manager,
        plugin_manager: &plugin_manager,
        plugin_context: &plugin_context,
-        destination,
+        workspace_context,
        contents,
    })
    .await?)
 }

-pub(crate) fn commit_import<R: Runtime>(
-    window: &WebviewWindow<R>,
-    plan: ImportPlan,
-) -> Result<BatchUpsertResult> {
-    Ok(import::commit_import_plan(&window.db_manager(), plan)?)
-}
-
 /// Download an importable document (OpenAPI, Postman, Insomnia, …) so it can be fed to the same
 /// pipeline as a file on disk.
 ///
@@ -4,7 +4,7 @@ use crate::error::Error::GenericError;
 use crate::error::Result;
 use crate::grpc::{build_metadata, metadata_to_map};
 use crate::http_request::send_http_request;
-use crate::import::{commit_import, plan_import_data, plan_import_url};
+use crate::import::{import_data, import_url};
 use crate::models_ext::{BlobManagerExt, QueryManagerExt};
 use crate::notifications::YaakNotifier;
 use crate::render::{render_grpc_request, render_template};
@@ -40,7 +40,7 @@ use yaak_models::models::{
    CookieJar, Environment, GrpcConnection, GrpcConnectionState, GrpcEvent,
    GrpcEventType, HttpRequest, HttpResponse, HttpResponseState, Workspace,
 };
-use yaak_models::util::{BatchUpsertResult, ImportDestination, ImportPlan, UpdateSource};
+use yaak_models::util::{BatchUpsertResult, UpdateSource};
 use yaak_plugins::events::{
    Color, ErrorResponse, FilterResponse, InternalEvent, InternalEventPayload, PluginContext,
    RenderPurpose, ShowToastRequest,
@@ -1014,24 +1014,15 @@ async fn cmd_get_sse_events<R: Runtime>(
 async fn cmd_import_data<R: Runtime>(
    window: WebviewWindow<R>,
    file_path: &str,
-    destination: ImportDestination,
-) -> YaakResult<ImportPlan> {
-    plan_import_data(&window, file_path, destination).await
+) -> YaakResult<BatchUpsertResult> {
+    import_data(&window, file_path).await
 }

 async fn cmd_import_url<R: Runtime>(
    window: WebviewWindow<R>,
    url: &str,
-    destination: ImportDestination,
-) -> YaakResult<ImportPlan> {
-    plan_import_url(&window, url, destination).await
-}
-
-async fn cmd_commit_import<R: Runtime>(
-    window: WebviewWindow<R>,
-    plan: ImportPlan,
 ) -> YaakResult<BatchUpsertResult> {
-    commit_import(&window, plan)
+    import_url(&window, url).await
 }


@@ -1376,16 +1367,6 @@ pub fn run() {
                        debug!("Launched Yaak {:?}", info);
                    });
                }
-                RunEvent::WindowEvent { event: WindowEvent::ThemeChanged(_), .. } => {
-                    // On macOS this is how OS appearance changes arrive: tao observes
-                    // AppleInterfaceThemeChangedNotification and emits it for every window
-                    #[cfg(any(target_os = "linux", target_os = "macos"))]
-                    if let Some(state) =
-                        app_handle.try_state::<yaak_system_appearance::SystemAppearanceState>()
-                    {
-                        yaak_system_appearance::emit_change(app_handle, &state);
-                    }
-                }
                RunEvent::WindowEvent { event: WindowEvent::Focused(true), label, .. } => {
                    #[cfg(any(target_os = "linux", target_os = "macos"))]
                    if let Some(state) =
@@ -40,7 +40,7 @@ use yaak_models::models::{
    HttpResponseEvent, Plugin, Settings, WebsocketConnection, WebsocketEvent, WorkspaceMeta,
 };
 use yaak_models::query_manager::QueryManager;
-use yaak_models::util::{BatchUpsertResult, ImportPlan};
+use yaak_models::util::BatchUpsertResult;
 use yaak_plugins::events::{
    CallFolderActionRequest, CallGrpcRequestActionRequest, CallHttpRequestActionRequest,
    CallWebsocketRequestActionRequest, CallWorkspaceActionRequest, FilterResponse, ImportResponse,
@@ -441,16 +441,12 @@ async fn cmd_get_http_response_events<R: Runtime>(ctx: ClientCtx<R>, req: CmdGet
    Ok(yaak_commands::responses::cmd_get_http_response_events(ctx, req).await?)
 }

-async fn cmd_import_data<R: Runtime>(ctx: ClientCtx<R>, req: CmdImportDataReq) -> Result<ImportPlan> {
-    Ok(crate::cmd_import_data(ctx.window.clone(), &req.file_path, req.destination).await?)
+async fn cmd_import_data<R: Runtime>(ctx: ClientCtx<R>, req: CmdImportDataReq) -> Result<BatchUpsertResult> {
+    Ok(crate::cmd_import_data(ctx.window.clone(), &req.file_path).await?)
 }

-async fn cmd_import_url<R: Runtime>(ctx: ClientCtx<R>, req: CmdImportUrlReq) -> Result<ImportPlan> {
-    Ok(crate::cmd_import_url(ctx.window.clone(), &req.url, req.destination).await?)
-}
-
-async fn cmd_commit_import<R: Runtime>(ctx: ClientCtx<R>, req: CmdCommitImportReq) -> Result<BatchUpsertResult> {
-    Ok(crate::cmd_commit_import(ctx.window.clone(), req.plan).await?)
+async fn cmd_import_url<R: Runtime>(ctx: ClientCtx<R>, req: CmdImportUrlReq) -> Result<BatchUpsertResult> {
+    Ok(crate::cmd_import_url(ctx.window.clone(), &req.url).await?)
 }

 async fn cmd_http_request_actions<R: Runtime>(ctx: ClientCtx<R>, req: CmdHttpRequestActionsReq) -> Result<Vec<GetHttpRequestActionsResponse>> {
@@ -847,3 +843,4 @@ async fn cmd_plugins_updates<R: Runtime>(ctx: ClientCtx<R>, _req: CmdPluginsUpda
 async fn cmd_plugins_update_all<R: Runtime>(ctx: ClientCtx<R>, _req: CmdPluginsUpdateAllReq) -> Result<Vec<PluginNameVersion>> {
    Ok(crate::plugins_ext::cmd_plugins_update_all(ctx.window.clone()).await?)
 }
+
@@ -76,6 +76,14 @@ impl YaakUpdater {
        auto_download: bool,
        update_trigger: UpdateTrigger,
    ) -> Result<bool> {
+        // Only AppImage supports updates on Linux, so skip if it's not
+        #[cfg(target_os = "linux")]
+        {
+            if std::env::var("APPIMAGE").is_err() {
+                return Ok(false);
+            }
+        }
+
        let settings = window.db().get_settings();
        let update_key = format!("{:x}", md5::compute(settings.id));
        self.last_check = Some(Instant::now());
@@ -122,18 +130,6 @@ impl YaakUpdater {
            Some(update) => {
                let w = window.clone();
                tauri::async_runtime::spawn(async move {
-                    // Only hand the artifact to the updater plugin when this install can
-                    // apply it itself; otherwise tell the user how to update instead
-                    let install = update_install_method(&update);
-                    if install != UpdateInstall::Integrated {
-                        info!(
-                            "{} available, but this install updates via {install:?}",
-                            update.version
-                        );
-                        notify_external_update(&w, &update, install);
-                        return;
-                    }
-
                    // Force native updater if specified (useful if a release broke the UI)
                    let native_install_mode =
                        update.raw_json.get("install_mode").map(|v| v.as_str()).unwrap_or_default()
@@ -211,23 +207,6 @@ struct UpdateInfo {
    reply_event_id: String,
    version: String,
    downloaded: bool,
-    /// How this update gets applied. Anything but `Integrated` means the app can't do it
-    /// itself and the user is told how to update instead.
-    install: UpdateInstall,
-}
-
-/// How an update can be applied to this install.
-#[derive(Debug, Clone, Copy, PartialEq, Serialize, Default, TS)]
-#[serde(rename_all = "snake_case")]
-#[ts(export, export_to = "index.ts")]
-enum UpdateInstall {
-    /// The app downloads and installs it itself
-    #[default]
-    Integrated,
-    /// Flatpak install: updated by `flatpak update` from its remote (e.g. FlatPark)
-    Flatpak,
-    /// Nothing can install it in-app (distro package, Nix, unknown); download by hand
-    Manual,
 }

 #[derive(Debug, Clone, PartialEq, Deserialize, TS)]
@@ -293,12 +272,8 @@ async fn start_integrated_update<R: Runtime>(
    let _guard = Unlisten { win: window, id: event_id };

    // 2) Emit the event now that listener is in place
-    let info = UpdateInfo {
-        version: update.version.to_string(),
-        downloaded,
-        install: UpdateInstall::Integrated,
-        reply_event_id: reply_id,
-    };
+    let info =
+        UpdateInfo { version: update.version.to_string(), downloaded, reply_event_id: reply_id };
    window
        .emit_to(window.label(), "update_available", &info)
        .map_err(|e| GenericError(format!("Failed to emit update_available: {e}")))?;
@@ -331,24 +306,6 @@ async fn start_integrated_update<R: Runtime>(
    }
 }

-/// Tell the frontend about an update this install can't apply itself, so the user can be
-/// told how to get it. Unlike the integrated flow, there is nothing to reply to.
-fn notify_external_update<R: Runtime>(
-    window: &WebviewWindow<R>,
-    update: &Update,
-    install: UpdateInstall,
-) {
-    let info = UpdateInfo {
-        version: update.version.to_string(),
-        downloaded: false,
-        install,
-        reply_event_id: generate_id(),
-    };
-    if let Err(e) = window.emit_to(window.label(), "update_available", &info) {
-        warn!("Failed to emit update_available: {e}");
-    }
-}
-
 async fn start_native_update<R: Runtime>(window: &WebviewWindow<R>, update: &Update) {
    // If the frontend doesn't respond, fallback to native dialogs
    let confirmed = window
@@ -419,137 +376,7 @@ fn detect_install_mode() -> Option<&'static str> {
        return Some("nsis");
    }
    #[allow(unreachable_code)]
-    if !cfg!(target_os = "linux") {
-        None
-    } else if is_flatpak() {
-        Some("flatpak")
-    } else {
-        linux_installer()
-    }
-}
-
-/// Flatpak installs (e.g. FlatPark) are updated by flatpak from their remote; the in-app
-/// updater can't write inside the sandbox and must not try.
-fn is_flatpak() -> bool {
-    std::env::var_os("FLATPAK_ID").is_some()
-}
-
-/// How Yaak was installed on Linux, as far as the updater plugin can install into it.
-///
-/// The bundle type is stamped into the binary by the bundler, but that only says how the
-/// binary was *packaged*: third-party packages (AUR, Nix, ...) repackage the .deb, and
-/// letting dpkg/rpm replace those would stomp on another package manager's files. So a
-/// deb/rpm install also has to be one the package manager actually owns. The AppImage
-/// updater needs `$APPIMAGE` since that's the file it replaces.
-fn linux_installer() -> Option<&'static str> {
-    use tauri::utils::{config::BundleType, platform::bundle_type};
-    match bundle_type() {
-        Some(BundleType::Deb) if package_manager_owns_exe("dpkg", "-S") => Some("deb"),
-        Some(BundleType::Rpm) if package_manager_owns_exe("rpm", "-qf") => Some("rpm"),
-        Some(BundleType::Deb) | Some(BundleType::Rpm) => None,
-        _ if std::env::var_os("APPIMAGE").is_some() => Some("appimage"),
-        _ => None,
-    }
-}
-
-/// Whether `cmd query_arg <current exe>` succeeds, i.e. that package manager knows the
-/// running executable as one of its files. False when the tool isn't installed at all.
-fn package_manager_owns_exe(cmd: &str, query_arg: &str) -> bool {
-    let Ok(exe) = std::env::current_exe() else {
-        return false;
-    };
-    std::process::Command::new(cmd)
-        .arg(query_arg)
-        .arg(&exe)
-        .stdin(std::process::Stdio::null())
-        .stdout(std::process::Stdio::null())
-        .stderr(std::process::Stdio::null())
-        .status()
-        .map(|status| status.success())
-        .unwrap_or(false)
-}
-
-/// How the artifact the server returned can be applied to this install. On Linux the
-/// server may hand back a different package format than the one installed, Flatpak can't
-/// be written from inside the sandbox, and unknown install methods (distro packages,
-/// Nix, ...) can't be updated in-app at all.
-fn update_install_method(update: &Update) -> UpdateInstall {
-    // Dev-only override to preview the non-integrated flows on any OS:
-    //   YAAK_SIMULATE_INSTALL=flatpak|manual
-    if is_dev() {
-        match std::env::var("YAAK_SIMULATE_INSTALL").as_deref() {
-            Ok("flatpak") => return UpdateInstall::Flatpak,
-            Ok("manual") => return UpdateInstall::Manual,
-            _ => {}
-        }
-    }
-
-    if !cfg!(target_os = "linux") {
-        return UpdateInstall::Integrated;
-    }
-    if is_flatpak() {
-        return UpdateInstall::Flatpak;
-    }
-    if artifact_matches_installer(linux_installer(), update.download_url.path()) {
-        UpdateInstall::Integrated
-    } else {
-        UpdateInstall::Manual
-    }
-}
-
-/// Whether the artifact at `url_path` is in the package format `installer` can install.
-fn artifact_matches_installer(installer: Option<&str>, url_path: &str) -> bool {
-    let path = url_path.to_ascii_lowercase();
-    match installer {
-        Some("deb") => path.ends_with(".deb"),
-        Some("rpm") => path.ends_with(".rpm"),
-        Some("appimage") => path.ends_with(".appimage") || path.ends_with(".appimage.tar.gz"),
-        _ => false,
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::artifact_matches_installer;
-
-    const BASE: &str = "/mountain-loop/yaak/releases/download/v2026.6.0/";
-
-    #[test]
-    fn matching_package_format_is_installable() {
-        let cases = [
-            ("deb", "yaak_2026.6.0_amd64.deb"),
-            ("deb", "yaak_2026.6.0_arm64.deb"),
-            ("rpm", "yaak-2026.6.0-1.x86_64.rpm"),
-            ("rpm", "yaak-2026.6.0-1.aarch64.rpm"),
-            ("appimage", "yaak_2026.6.0_amd64.AppImage"),
-            ("appimage", "yaak_2026.6.0_amd64.AppImage.tar.gz"),
-        ];
-        for (installer, asset) in cases {
-            assert!(
-                artifact_matches_installer(Some(installer), &format!("{BASE}{asset}")),
-                "{installer} should install {asset}"
-            );
-        }
-    }
-
-    #[test]
-    fn mismatched_package_format_is_not_installable() {
-        // What the server returns for every Linux install today
-        let appimage = format!("{BASE}yaak_2026.6.0_amd64.AppImage");
-        assert!(!artifact_matches_installer(Some("deb"), &appimage));
-        assert!(!artifact_matches_installer(Some("rpm"), &appimage));
-
-        let deb = format!("{BASE}yaak_2026.6.0_amd64.deb");
-        assert!(!artifact_matches_installer(Some("rpm"), &deb));
-        assert!(!artifact_matches_installer(Some("appimage"), &deb));
-    }
-
-    #[test]
-    fn unknown_installer_is_never_installable() {
-        for asset in ["yaak_2026.6.0_amd64.deb", "yaak_2026.6.0_amd64.AppImage"] {
-            assert!(!artifact_matches_installer(None, &format!("{BASE}{asset}")));
-        }
-    }
+    None
 }

 pub async fn install_update_maybe_download<R: Runtime>(
@@ -4,14 +4,9 @@ version = "0.1.0"
 edition = "2024"
 publish = false

-[target.'cfg(target_os = "linux")'.dependencies]
+[target.'cfg(any(target_os = "linux", target_os = "macos"))'.dependencies]
 dark-light = "2.0.0"

-[target.'cfg(target_os = "macos")'.dependencies]
-dispatch2 = "0.3.0"
-objc2-app-kit = { version = "0.3.1", features = ["NSAppearance", "NSApplication", "NSResponder"] }
-objc2-foundation = { version = "0.3.1", features = ["NSArray", "NSString", "NSUserDefaults"] }
-
 [dependencies]
 log = { workspace = true }
 tauri = { workspace = true }
@@ -1,5 +1,5 @@
 use std::sync::{Arc, Mutex};
-#[cfg(target_os = "linux")]
+#[cfg(any(target_os = "linux", target_os = "macos"))]
 use std::time::Duration;

 #[cfg(any(target_os = "linux", target_os = "macos"))]
@@ -11,7 +11,7 @@ use tauri::{AppHandle, Runtime};
 pub const INITIAL_APPEARANCE_GLOBAL: &str = "__YAAK_INITIAL_APPEARANCE__";
 pub const SYSTEM_APPEARANCE_CHANGE_EVENT: &str = "system_appearance_change";

-#[cfg(target_os = "linux")]
+#[cfg(any(target_os = "linux", target_os = "macos"))]
 const SYSTEM_APPEARANCE_POLL_INTERVAL: Duration = Duration::from_secs(1);

 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
@@ -47,12 +47,14 @@ pub fn initialization_script(appearance: Appearance) -> String {

 /// Detect the appearance the OS prefers, independent of any appearance that has
 /// been forced onto app windows (which is what the webview itself reports).
-#[cfg(target_os = "linux")]
+#[cfg(any(target_os = "linux", target_os = "macos"))]
 pub fn system_appearance() -> Option<Appearance> {
+    #[cfg(target_os = "linux")]
    if let Some(appearance) = gsettings_system_appearance() {
        return Some(appearance);
    }

+    // On macOS this reads AppleInterfaceStyle from the global user defaults
    match dark_light::detect() {
        Ok(dark_light::Mode::Dark) => Some(Appearance::Dark),
        Ok(dark_light::Mode::Light) => Some(Appearance::Light),
@@ -64,69 +66,11 @@ pub fn system_appearance() -> Option<Appearance> {
    }
 }

-/// Detect the appearance the OS prefers, independent of any appearance that has
-/// been forced onto app windows (which is what the webview itself reports).
-///
-/// This asks AppKit for the application's effective appearance, the same source tauri
-/// uses for `window.theme()`, instead of reading `AppleInterfaceStyle` from the user
-/// defaults: macOS 27 no longer reliably writes that key when dark mode is on, so anything
-/// reading it sees light mode. Appearances forced per window (yaak-mac-window) don't reach
-/// `NSApp`, so this is the OS preference.
-#[cfg(target_os = "macos")]
-pub fn system_appearance() -> Option<Appearance> {
-    use objc2_app_kit::{NSAppearanceNameAqua, NSAppearanceNameDarkAqua, NSApplication};
-    use objc2_foundation::NSArray;
-
-    // AppKit is main-thread only. Every caller runs there today; this keeps it correct if
-    // one ever doesn't.
-    dispatch2::run_on_main(|mtm| {
-        let app = NSApplication::sharedApplication(mtm);
-
-        // An appearance forced on the whole app (tauri's `set_theme` does this) would make
-        // the effective appearance report the override instead of the OS preference. Nothing
-        // in Yaak does that, but fall back to the user defaults if something ever does.
-        //
-        // SAFETY: Called on the main thread with the shared application
-        if unsafe { app.appearance() }.is_some() {
-            return defaults_appearance();
-        }
-
-        // SAFETY: The appearance names are AppKit constants that live for the whole process
-        let (dark, light) = unsafe { (NSAppearanceNameDarkAqua, NSAppearanceNameAqua) };
-        let names = NSArray::from_slice(&[dark, light]);
-        let best = app.effectiveAppearance().bestMatchFromAppearancesWithNames(&names)?;
-
-        // SAFETY: Both are valid strings
-        let is_dark = unsafe { best.isEqualToString(dark) };
-        Some(if is_dark { Appearance::Dark } else { Appearance::Light })
-    })
-}
-
-/// The appearance macOS persists to the global user defaults. Absent means light, except
-/// on macOS 27, which stopped reliably writing the key. Only used when the effective
-/// appearance is forced and can't be trusted.
-#[cfg(target_os = "macos")]
-fn defaults_appearance() -> Option<Appearance> {
-    use objc2_foundation::{NSUserDefaults, ns_string};
-
-    // SAFETY: The standard defaults are a process-wide singleton and the key is a valid string
-    let style = unsafe {
-        NSUserDefaults::standardUserDefaults().stringForKey(ns_string!("AppleInterfaceStyle"))
-    };
-
-    // SAFETY: Both are valid strings
-    let is_dark = style.is_some_and(|style| unsafe { style.isEqualToString(ns_string!("Dark")) });
-    Some(if is_dark { Appearance::Dark } else { Appearance::Light })
-}
-
 #[cfg(not(any(target_os = "linux", target_os = "macos")))]
 pub fn system_appearance() -> Option<Appearance> {
    None
 }

-/// Start tracking the OS appearance. Linux polls for changes. macOS gets them from tauri's
-/// `WindowEvent::ThemeChanged` (tao observes `AppleInterfaceThemeChangedNotification`), which
-/// the app forwards to [`emit_change`], so no thread is needed there.
 #[cfg(any(target_os = "linux", target_os = "macos"))]
 pub fn watch<R: Runtime>(app_handle: AppHandle<R>) -> Option<SystemAppearanceState> {
    let last_appearance = system_appearance();
@@ -136,19 +80,13 @@ pub fn watch<R: Runtime>(app_handle: AppHandle<R>) -> Option<SystemAppearanceSta
    }

    let state = SystemAppearanceState { last_appearance: Arc::new(Mutex::new(last_appearance)) };
-
-    #[cfg(target_os = "linux")]
-    {
-        let thread_state = state.clone();
-        let _ = std::thread::spawn(move || {
-            loop {
-                std::thread::sleep(SYSTEM_APPEARANCE_POLL_INTERVAL);
-                emit_change(&app_handle, &thread_state);
-            }
-        });
-    }
-    #[cfg(target_os = "macos")]
-    let _ = app_handle;
+    let thread_state = state.clone();
+    let _ = std::thread::spawn(move || {
+        loop {
+            std::thread::sleep(SYSTEM_APPEARANCE_POLL_INTERVAL);
+            emit_change(&app_handle, &thread_state);
+        }
+    });

    Some(state)
 }
@@ -1,509 +1,127 @@
 // This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.

-export type AnyModel =
-  | CookieJar
-  | Environment
-  | Folder
-  | GraphQlIntrospection
-  | GrpcConnection
-  | GrpcEvent
-  | GrpcRequest
-  | HttpRequest
-  | HttpResponse
-  | HttpResponseEvent
-  | KeyValue
-  | Plugin
-  | Settings
-  | SyncState
-  | WebsocketConnection
-  | WebsocketEvent
-  | WebsocketRequest
-  | Workspace
-  | WorkspaceMeta;
+export type AnyModel = CookieJar | Environment | Folder | GraphQlIntrospection | GrpcConnection | GrpcEvent | GrpcRequest | HttpRequest | HttpResponse | HttpResponseEvent | KeyValue | Plugin | Settings | SyncState | WebsocketConnection | WebsocketEvent | WebsocketRequest | Workspace | WorkspaceMeta;

-export type ClientCertificate = {
-  host: string;
-  port: number | null;
-  crtFile: string | null;
-  keyFile: string | null;
-  pfxFile: string | null;
-  passphrase: string | null;
-  enabled?: boolean;
-};
+export type ClientCertificate = { host: string, port: number | null, crtFile: string | null, keyFile: string | null, pfxFile: string | null, passphrase: string | null, enabled?: boolean, };

-export type Cookie = {
-  name: string;
-  value: string;
-  domain: CookieDomain;
-  expires: CookieExpires;
-  path: string;
-  secure: boolean;
-  httpOnly: boolean;
-  sameSite: CookieSameSite | null;
-};
+export type Cookie = { name: string, value: string, domain: CookieDomain, expires: CookieExpires, path: string, secure: boolean, httpOnly: boolean, sameSite: CookieSameSite | null, };

-export type CookieDomain = { HostOnly: string } | { Suffix: string } | "NotPresent" | "Empty";
+export type CookieDomain = { "HostOnly": string } | { "Suffix": string } | "NotPresent" | "Empty";

-export type CookieExpires = { AtUtc: string } | "SessionEnd";
+export type CookieExpires = { "AtUtc": string } | "SessionEnd";

-export type CookieJar = {
-  model: "cookie_jar";
-  id: string;
-  createdAt: string;
-  updatedAt: string;
-  workspaceId: string;
-  cookies: Array<Cookie>;
-  name: string;
-};
+export type CookieJar = { model: "cookie_jar", id: string, createdAt: string, updatedAt: string, workspaceId: string, cookies: Array<Cookie>, name: string, };

 export type CookieSameSite = "Strict" | "Lax" | "None";

-export type DnsOverride = {
-  hostname: string;
-  ipv4: Array<string>;
-  ipv6: Array<string>;
-  enabled?: boolean;
-};
+export type DnsOverride = { hostname: string, ipv4: Array<string>, ipv6: Array<string>, enabled?: boolean, };

 export type EditorKeymap = "default" | "vim" | "vscode" | "emacs";

-export type EncryptedKey = { encryptedKey: string };
+export type EncryptedKey = { encryptedKey: string, };

-export type Environment = {
-  model: "environment";
-  id: string;
-  workspaceId: string;
-  createdAt: string;
-  updatedAt: string;
-  name: string;
-  public: boolean;
-  parentModel: string;
-  parentId: string | null;
-  /**
-   * Variables defined in this environment scope.
-   * Child environments override parent variables by name.
-   */
-  variables: Array<EnvironmentVariable>;
-  color: string | null;
-  sortPriority: number;
-};
+export type Environment = { model: "environment", id: string, workspaceId: string, createdAt: string, updatedAt: string, name: string, public: boolean, parentModel: string, parentId: string | null, 
+/**
+ * Variables defined in this environment scope.
+ * Child environments override parent variables by name.
+ */
+variables: Array<EnvironmentVariable>, color: string | null, sortPriority: number, };

-export type EnvironmentVariable = { enabled?: boolean; name: string; value: string; id?: string };
+export type EnvironmentVariable = { enabled?: boolean, name: string, value: string, id?: string, };

-export type Folder = {
-  model: "folder";
-  id: string;
-  createdAt: string;
-  updatedAt: string;
-  workspaceId: string;
-  folderId: string | null;
-  authentication: Record<string, any>;
-  authenticationType: string | null;
-  description: string;
-  headers: Array<HttpRequestHeader>;
-  name: string;
-  sortPriority: number;
-  settingSendCookies: InheritedBoolSetting;
-  settingStoreCookies: InheritedBoolSetting;
-  settingValidateCertificates: InheritedBoolSetting;
-  settingFollowRedirects: InheritedBoolSetting;
-  settingRequestTimeout: InheritedIntSetting;
-  settingRequestMessageSize: InheritedIntSetting;
-  settingHttpVersion: InheritedHttpVersionSetting;
-};
+export type Folder = { model: "folder", id: string, createdAt: string, updatedAt: string, workspaceId: string, folderId: string | null, authentication: Record<string, any>, authenticationType: string | null, description: string, headers: Array<HttpRequestHeader>, name: string, sortPriority: number, settingSendCookies: InheritedBoolSetting, settingStoreCookies: InheritedBoolSetting, settingValidateCertificates: InheritedBoolSetting, settingFollowRedirects: InheritedBoolSetting, settingRequestTimeout: InheritedIntSetting, settingRequestMessageSize: InheritedIntSetting, };

-export type GraphQlIntrospection = {
-  model: "graphql_introspection";
-  id: string;
-  createdAt: string;
-  updatedAt: string;
-  workspaceId: string;
-  requestId: string;
-  content: string | null;
-};
+export type GraphQlIntrospection = { model: "graphql_introspection", id: string, createdAt: string, updatedAt: string, workspaceId: string, requestId: string, content: string | null, };

-export type GrpcConnection = {
-  model: "grpc_connection";
-  id: string;
-  createdAt: string;
-  updatedAt: string;
-  workspaceId: string;
-  requestId: string;
-  elapsed: number;
-  error: string | null;
-  method: string;
-  service: string;
-  status: number;
-  state: GrpcConnectionState;
-  trailers: { [key in string]?: string };
-  url: string;
-};
+export type GrpcConnection = { model: "grpc_connection", id: string, createdAt: string, updatedAt: string, workspaceId: string, requestId: string, elapsed: number, error: string | null, method: string, service: string, status: number, state: GrpcConnectionState, trailers: { [key in string]?: string }, url: string, };

 export type GrpcConnectionState = "initialized" | "connected" | "closed";

-export type GrpcEvent = {
-  model: "grpc_event";
-  id: string;
-  createdAt: string;
-  updatedAt: string;
-  workspaceId: string;
-  requestId: string;
-  connectionId: string;
-  content: string;
-  error: string | null;
-  eventType: GrpcEventType;
-  metadata: { [key in string]?: string };
-  status: number | null;
-};
+export type GrpcEvent = { model: "grpc_event", id: string, createdAt: string, updatedAt: string, workspaceId: string, requestId: string, connectionId: string, content: string, error: string | null, eventType: GrpcEventType, metadata: { [key in string]?: string }, status: number | null, };

-export type GrpcEventType =
-  | "info"
-  | "error"
-  | "client_message"
-  | "server_message"
-  | "connection_start"
-  | "connection_end";
+export type GrpcEventType = "info" | "error" | "client_message" | "server_message" | "connection_start" | "connection_end";

-export type GrpcRequest = {
-  model: "grpc_request";
-  id: string;
-  createdAt: string;
-  updatedAt: string;
-  workspaceId: string;
-  folderId: string | null;
-  authenticationType: string | null;
-  authentication: Record<string, any>;
-  description: string;
-  message: string;
-  metadata: Array<HttpRequestHeader>;
-  method: string | null;
-  name: string;
-  service: string | null;
-  sortPriority: number;
-  /**
-   * Server URL (http for plaintext or https for secure)
-   */
-  url: string;
-  settingValidateCertificates: InheritedBoolSetting;
-  settingRequestMessageSize: InheritedIntSetting;
-};
+export type GrpcRequest = { model: "grpc_request", id: string, createdAt: string, updatedAt: string, workspaceId: string, folderId: string | null, authenticationType: string | null, authentication: Record<string, any>, description: string, message: string, metadata: Array<HttpRequestHeader>, method: string | null, name: string, service: string | null, sortPriority: number, 
+/**
+ * Server URL (http for plaintext or https for secure)
+ */
+url: string, settingValidateCertificates: InheritedBoolSetting, settingRequestMessageSize: InheritedIntSetting, };

-export type HttpRequest = {
-  model: "http_request";
-  id: string;
-  createdAt: string;
-  updatedAt: string;
-  workspaceId: string;
-  folderId: string | null;
-  authentication: Record<string, any>;
-  authenticationType: string | null;
-  body: Record<string, any>;
-  bodyType: string | null;
-  description: string;
-  headers: Array<HttpRequestHeader>;
-  method: string;
-  name: string;
-  sortPriority: number;
-  url: string;
-  /**
-   * URL parameters used for both path placeholders (`:id`) and query string entries.
-   */
-  urlParameters: Array<HttpUrlParameter>;
-  settingSendCookies: InheritedBoolSetting;
-  settingStoreCookies: InheritedBoolSetting;
-  settingValidateCertificates: InheritedBoolSetting;
-  settingFollowRedirects: InheritedBoolSetting;
-  settingRequestTimeout: InheritedIntSetting;
-  settingHttpVersion: InheritedHttpVersionSetting;
-};
+export type HttpRequest = { model: "http_request", id: string, createdAt: string, updatedAt: string, workspaceId: string, folderId: string | null, authentication: Record<string, any>, authenticationType: string | null, body: Record<string, any>, bodyType: string | null, description: string, headers: Array<HttpRequestHeader>, method: string, name: string, sortPriority: number, url: string, 
+/**
+ * URL parameters used for both path placeholders (`:id`) and query string entries.
+ */
+urlParameters: Array<HttpUrlParameter>, settingSendCookies: InheritedBoolSetting, settingStoreCookies: InheritedBoolSetting, settingValidateCertificates: InheritedBoolSetting, settingFollowRedirects: InheritedBoolSetting, settingRequestTimeout: InheritedIntSetting, };

-export type HttpRequestHeader = { enabled?: boolean; name: string; value: string; id?: string };
+export type HttpRequestHeader = { enabled?: boolean, name: string, value: string, id?: string, };

-export type HttpResponse = {
-  model: "http_response";
-  id: string;
-  createdAt: string;
-  updatedAt: string;
-  workspaceId: string;
-  requestId: string;
-  contentLength: number | null;
-  contentLengthCompressed: number | null;
-  elapsed: number;
-  elapsedHeaders: number;
-  elapsedDns: number;
-  error: string | null;
-  headers: Array<HttpResponseHeader>;
-  remoteAddr: string | null;
-  requestContentLength: number | null;
-  requestHeaders: Array<HttpResponseHeader>;
-  status: number;
-  statusReason: string | null;
-  state: HttpResponseState;
-  url: string;
-  version: string | null;
-};
+export type HttpResponse = { model: "http_response", id: string, createdAt: string, updatedAt: string, workspaceId: string, requestId: string, contentLength: number | null, contentLengthCompressed: number | null, elapsed: number, elapsedHeaders: number, elapsedDns: number, error: string | null, headers: Array<HttpResponseHeader>, remoteAddr: string | null, requestContentLength: number | null, requestHeaders: Array<HttpResponseHeader>, status: number, statusReason: string | null, state: HttpResponseState, url: string, version: string | null, };

-export type HttpResponseEvent = {
-  model: "http_response_event";
-  id: string;
-  createdAt: string;
-  updatedAt: string;
-  workspaceId: string;
-  responseId: string;
-  event: HttpResponseEventData;
-};
+export type HttpResponseEvent = { model: "http_response_event", id: string, createdAt: string, updatedAt: string, workspaceId: string, responseId: string, event: HttpResponseEventData, };

 /**
 * Serializable representation of HTTP response events for DB storage.
 * This mirrors `yaak_http::sender::HttpResponseEvent` but with serde support.
 * The `From` impl is in yaak-http to avoid circular dependencies.
 */
-export type HttpResponseEventData =
-  | {
-      type: "setting";
-      name: string;
-      value: string;
-      source_model?: string;
-      source_id?: string;
-      source_name?: string;
-    }
-  | { type: "info"; message: string }
-  | {
-      type: "redirect";
-      url: string;
-      status: number;
-      behavior: string;
-      dropped_body: boolean;
-      dropped_headers: Array<string>;
-    }
-  | {
-      type: "send_url";
-      method: string;
-      scheme: string;
-      username: string;
-      password: string;
-      host: string;
-      port: number;
-      path: string;
-      query: string;
-      fragment: string;
-    }
-  | { type: "receive_url"; version: string; status: string }
-  | { type: "header_up"; name: string; value: string }
-  | { type: "header_down"; name: string; value: string }
-  | { type: "chunk_sent"; bytes: number }
-  | { type: "chunk_received"; bytes: number }
-  | {
-      type: "dns_resolved";
-      hostname: string;
-      addresses: Array<string>;
-      duration: bigint;
-      overridden: boolean;
-    };
+export type HttpResponseEventData = { "type": "setting", name: string, value: string, source_model?: string, source_id?: string, source_name?: string, } | { "type": "info", message: string, } | { "type": "redirect", url: string, status: number, behavior: string, dropped_body: boolean, dropped_headers: Array<string>, } | { "type": "send_url", method: string, scheme: string, username: string, password: string, host: string, port: number, path: string, query: string, fragment: string, } | { "type": "receive_url", version: string, status: string, } | { "type": "header_up", name: string, value: string, } | { "type": "header_down", name: string, value: string, } | { "type": "chunk_sent", bytes: number, } | { "type": "chunk_received", bytes: number, } | { "type": "dns_resolved", hostname: string, addresses: Array<string>, duration: bigint, overridden: boolean, };

-export type HttpResponseHeader = { name: string; value: string };
+export type HttpResponseHeader = { name: string, value: string, };

 export type HttpResponseState = "initialized" | "connected" | "closed";

-export type HttpUrlParameter = {
-  enabled?: boolean;
-  /**
-   * Colon-prefixed parameters are treated as path parameters if they match, like `/users/:id`
-   * Other entries are appended as query parameters
-   */
-  name: string;
-  value: string;
-  id?: string;
-};
+/**
+ * The resolved send settings, values only: what an executor has to obey, with the sources
+ * (which model each came from) left behind in [`ResolvedHttpRequestSettings`]. This is what
+ * crosses from a tab to the Yaak server, and what the server reads.
+ */
+export type HttpSendSettings = { validateCertificates: boolean, followRedirects: boolean, 
+/**
+ * Milliseconds. Zero or negative means no timeout.
+ */
+timeoutMs: number, sendCookies: boolean, storeCookies: boolean, };

-export type HttpVersion = "auto" | "http1" | "http2";
+export type HttpUrlParameter = { enabled?: boolean, 
+/**
+ * Colon-prefixed parameters are treated as path parameters if they match, like `/users/:id`
+ * Other entries are appended as query parameters
+ */
+name: string, value: string, id?: string, };

-export type InheritedBoolSetting = { enabled?: boolean; value: boolean };
+export type InheritedBoolSetting = { enabled?: boolean, value: boolean, };

-export type InheritedHttpVersionSetting = { enabled?: boolean; value: HttpVersion };
+export type InheritedIntSetting = { enabled?: boolean, value: number, };

-export type InheritedIntSetting = { enabled?: boolean; value: number };
+export type KeyValue = { model: "key_value", id: string, createdAt: string, updatedAt: string, key: string, namespace: string, value: string, };

-export type KeyValue = {
-  model: "key_value";
-  id: string;
-  createdAt: string;
-  updatedAt: string;
-  key: string;
-  namespace: string;
-  value: string;
-};
-
-export type Plugin = {
-  model: "plugin";
-  id: string;
-  createdAt: string;
-  updatedAt: string;
-  checkedAt: string | null;
-  directory: string;
-  enabled: boolean;
-  url: string | null;
-  source: PluginSource;
-};
+export type Plugin = { model: "plugin", id: string, createdAt: string, updatedAt: string, checkedAt: string | null, directory: string, enabled: boolean, url: string | null, source: PluginSource, };

 export type PluginSource = "bundled" | "filesystem" | "registry";

-export type ProxySetting =
-  | {
-      type: "enabled";
-      http: string;
-      https: string;
-      auth: ProxySettingAuth | null;
-      bypass: string;
-      disabled: boolean;
-    }
-  | { type: "disabled" };
+export type ProxySetting = { "type": "enabled", http: string, https: string, auth: ProxySettingAuth | null, bypass: string, disabled: boolean, } | { "type": "disabled" };

-export type ProxySettingAuth = { user: string; password: string };
+export type ProxySettingAuth = { user: string, password: string, };

-export type Settings = {
-  model: "settings";
-  id: string;
-  createdAt: string;
-  updatedAt: string;
-  appearance: string;
-  clientCertificates: Array<ClientCertificate>;
-  coloredMethods: boolean;
-  editorFont: string | null;
-  editorFontSize: number;
-  editorKeymap: EditorKeymap;
-  editorSoftWrap: boolean;
-  hideWindowControls: boolean;
-  useNativeTitlebar: boolean;
-  interfaceFont: string | null;
-  interfaceFontSize: number;
-  interfaceScale: number;
-  openWorkspaceNewWindow: boolean | null;
-  proxy: ProxySetting | null;
-  themeDark: string;
-  themeLight: string;
-  updateChannel: string;
-  hideLicenseBadge: boolean;
-  promptFeedback: boolean;
-  autoupdate: boolean;
-  autoDownloadUpdates: boolean;
-  checkNotifications: boolean;
-  hotkeys: { [key in string]?: Array<string> };
-};
+export type Settings = { model: "settings", id: string, createdAt: string, updatedAt: string, appearance: string, clientCertificates: Array<ClientCertificate>, coloredMethods: boolean, editorFont: string | null, editorFontSize: number, editorKeymap: EditorKeymap, editorSoftWrap: boolean, hideWindowControls: boolean, useNativeTitlebar: boolean, interfaceFont: string | null, interfaceFontSize: number, interfaceScale: number, openWorkspaceNewWindow: boolean | null, proxy: ProxySetting | null, themeDark: string, themeLight: string, updateChannel: string, hideLicenseBadge: boolean, promptFeedback: boolean, autoupdate: boolean, autoDownloadUpdates: boolean, checkNotifications: boolean, hotkeys: { [key in string]?: Array<string> }, };

-export type SyncModel =
-  | ({ type: "workspace" } & Workspace)
-  | ({ type: "environment" } & Environment)
-  | ({ type: "folder" } & Folder)
-  | ({ type: "http_request" } & HttpRequest)
-  | ({ type: "grpc_request" } & GrpcRequest)
-  | ({ type: "websocket_request" } & WebsocketRequest);
+export type SyncModel = { "type": "workspace" } & Workspace | { "type": "environment" } & Environment | { "type": "folder" } & Folder | { "type": "http_request" } & HttpRequest | { "type": "grpc_request" } & GrpcRequest | { "type": "websocket_request" } & WebsocketRequest;

-export type SyncState = {
-  model: "sync_state";
-  id: string;
-  workspaceId: string;
-  createdAt: string;
-  updatedAt: string;
-  flushedAt: string;
-  modelId: string;
-  checksum: string;
-  relPath: string;
-  syncDir: string;
-};
+export type SyncState = { model: "sync_state", id: string, workspaceId: string, createdAt: string, updatedAt: string, flushedAt: string, modelId: string, checksum: string, relPath: string, syncDir: string, };

-export type WebsocketConnection = {
-  model: "websocket_connection";
-  id: string;
-  createdAt: string;
-  updatedAt: string;
-  workspaceId: string;
-  requestId: string;
-  elapsed: number;
-  error: string | null;
-  headers: Array<HttpResponseHeader>;
-  state: WebsocketConnectionState;
-  status: number;
-  url: string;
-};
+export type WebsocketConnection = { model: "websocket_connection", id: string, createdAt: string, updatedAt: string, workspaceId: string, requestId: string, elapsed: number, error: string | null, headers: Array<HttpResponseHeader>, state: WebsocketConnectionState, status: number, url: string, };

 export type WebsocketConnectionState = "initialized" | "connected" | "closing" | "closed";

-export type WebsocketEvent = {
-  model: "websocket_event";
-  id: string;
-  createdAt: string;
-  updatedAt: string;
-  workspaceId: string;
-  requestId: string;
-  connectionId: string;
-  isServer: boolean;
-  message: Array<number>;
-  messageType: WebsocketEventType;
-};
+export type WebsocketEvent = { model: "websocket_event", id: string, createdAt: string, updatedAt: string, workspaceId: string, requestId: string, connectionId: string, isServer: boolean, message: Array<number>, messageType: WebsocketEventType, };

-export type WebsocketEventType =
-  | "binary"
-  | "close"
-  | "error"
-  | "frame"
-  | "open"
-  | "ping"
-  | "pong"
-  | "text";
+export type WebsocketEventType = "binary" | "close" | "error" | "frame" | "open" | "ping" | "pong" | "text";

-export type WebsocketRequest = {
-  model: "websocket_request";
-  id: string;
-  createdAt: string;
-  updatedAt: string;
-  workspaceId: string;
-  folderId: string | null;
-  authentication: Record<string, any>;
-  authenticationType: string | null;
-  description: string;
-  headers: Array<HttpRequestHeader>;
-  message: string;
-  name: string;
-  sortPriority: number;
-  url: string;
-  /**
-   * URL parameters used for both path placeholders (`:id`) and query string entries.
-   */
-  urlParameters: Array<HttpUrlParameter>;
-  settingSendCookies: InheritedBoolSetting;
-  settingStoreCookies: InheritedBoolSetting;
-  settingValidateCertificates: InheritedBoolSetting;
-  settingRequestMessageSize: InheritedIntSetting;
-};
+export type WebsocketRequest = { model: "websocket_request", id: string, createdAt: string, updatedAt: string, workspaceId: string, folderId: string | null, authentication: Record<string, any>, authenticationType: string | null, description: string, headers: Array<HttpRequestHeader>, message: string, name: string, sortPriority: number, url: string, 
+/**
+ * URL parameters used for both path placeholders (`:id`) and query string entries.
+ */
+urlParameters: Array<HttpUrlParameter>, settingSendCookies: InheritedBoolSetting, settingStoreCookies: InheritedBoolSetting, settingValidateCertificates: InheritedBoolSetting, settingRequestMessageSize: InheritedIntSetting, };

-export type Workspace = {
-  model: "workspace";
-  id: string;
-  createdAt: string;
-  updatedAt: string;
-  authentication: Record<string, any>;
-  authenticationType: string | null;
-  description: string;
-  headers: Array<HttpRequestHeader>;
-  name: string;
-  encryptionKeyChallenge: string | null;
-  settingValidateCertificates: boolean;
-  settingFollowRedirects: boolean;
-  settingRequestTimeout: number;
-  settingRequestMessageSize: number;
-  settingDnsOverrides: Array<DnsOverride>;
-  settingSendCookies: boolean;
-  settingStoreCookies: boolean;
-  settingHttpVersion: HttpVersion;
-};
+export type Workspace = { model: "workspace", id: string, createdAt: string, updatedAt: string, authentication: Record<string, any>, authenticationType: string | null, description: string, headers: Array<HttpRequestHeader>, name: string, encryptionKeyChallenge: string | null, settingValidateCertificates: boolean, settingFollowRedirects: boolean, settingRequestTimeout: number, settingRequestMessageSize: number, settingDnsOverrides: Array<DnsOverride>, settingSendCookies: boolean, settingStoreCookies: boolean, };

-export type WorkspaceMeta = {
-  model: "workspace_meta";
-  id: string;
-  workspaceId: string;
-  createdAt: string;
-  updatedAt: string;
-  encryptionKey: EncryptedKey | null;
-  settingSyncDir: string | null;
-};
+export type WorkspaceMeta = { model: "workspace_meta", id: string, workspaceId: string, createdAt: string, updatedAt: string, encryptionKey: EncryptedKey | null, settingSyncDir: string | null, };
@@ -2,22 +2,3 @@
 import type { Environment, Folder, GrpcRequest, HttpRequest, WebsocketRequest, Workspace } from "./gen_models";

 export type BatchUpsertResult = { workspaces: Array<Workspace>, environments: Array<Environment>, folders: Array<Folder>, httpRequests: Array<HttpRequest>, grpcRequests: Array<GrpcRequest>, websocketRequests: Array<WebsocketRequest>, };
-
-/**
- * Where a staged import will be committed.
- *
- * The destination workspace and optional folder IDs are captured in the plan so the preview describes
- * the exact destination that confirmation will use.
- */
-export type ImportDestination = { "type": "new_workspace" } | { "type": "existing_workspace", workspaceId: string, folderId?: string, };
-
-export type ImportPlan = { importer: string, destination: ImportDestination, resources: BatchUpsertResult, warnings: Array<ImportPlanWarning>, 
-/**
- * Stable source key for every model in `resources`, keyed by its freshly minted ID.
- *
- * Committing the plan can persist these so a later import of the same document recognizes
- * which models it already created, instead of duplicating them.
- */
-sourceKeys: { [key in string]?: string }, };
-
-export type ImportPlanWarning = { title: string, detail: string, };
@@ -23,7 +23,7 @@ use yaak_models::models::{
    AnyModel, GraphQlIntrospection, GrpcEvent, HttpRequest, HttpRequestHeader, HttpResponse,
    HttpResponseEvent, Plugin, Settings, WebsocketConnection, WebsocketEvent, WorkspaceMeta,
 };
-use yaak_models::util::{BatchUpsertResult, ImportDestination, ImportPlan};
+use yaak_models::util::BatchUpsertResult;
 use yaak_plugins::api::{PluginNameVersion, PluginSearchResponse, PluginUpdatesResponse};
 use yaak_plugins::events::{
    CallFolderActionRequest, CallGrpcRequestActionRequest, CallHttpRequestActionRequest,
@@ -229,7 +229,6 @@ pub struct CmdGetHttpResponseEventsReq {
 #[ts(export, export_to = "gen_rpc.ts")]
 pub struct CmdImportDataReq {
    pub file_path: String,
-    pub destination: ImportDestination,
 }

 #[derive(Debug, Deserialize, TS)]
@@ -237,14 +236,6 @@ pub struct CmdImportDataReq {
 #[ts(export, export_to = "gen_rpc.ts")]
 pub struct CmdImportUrlReq {
    pub url: String,
-    pub destination: ImportDestination,
-}
-
-#[derive(Debug, Deserialize, TS)]
-#[serde(rename_all = "camelCase")]
-#[ts(export, export_to = "gen_rpc.ts")]
-pub struct CmdCommitImportReq {
-    pub plan: ImportPlan,
 }

 #[derive(Debug, Deserialize, TS)]
@@ -918,9 +909,8 @@ macro_rules! with_commands {
    cmd_http_request_body(CmdHttpRequestBodyReq) -> Option<Vec<u8>>,
    cmd_get_sse_events(CmdGetSseEventsReq) -> Vec<ServerSentEvent>,
    cmd_get_http_response_events(CmdGetHttpResponseEventsReq) -> Vec<HttpResponseEvent>,
-    cmd_import_data(CmdImportDataReq) -> ImportPlan,
-    cmd_import_url(CmdImportUrlReq) -> ImportPlan,
-    cmd_commit_import(CmdCommitImportReq) -> BatchUpsertResult,
+    cmd_import_data(CmdImportDataReq) -> BatchUpsertResult,
+    cmd_import_url(CmdImportUrlReq) -> BatchUpsertResult,
    cmd_http_request_actions(CmdHttpRequestActionsReq) -> Vec<GetHttpRequestActionsResponse>,
    cmd_websocket_request_actions(CmdWebsocketRequestActionsReq) -> Vec<GetWebsocketRequestActionsResponse>,
    cmd_call_websocket_request_action(CmdCallWebsocketRequestActionReq) -> (),
@@ -6,11 +6,14 @@
 //! own environment chain before a plugin sees them, or an auth plugin receives
 //! `${[ api_key ]}` where it expected a key.

-use crate::error::Result;
+use crate::error::{Error, Result};
 use crate::host::PluginHost;
-use crate::render::render_form_values;
+use crate::render::render_json_value;
+use std::collections::HashMap;
+use yaak_models::models::AnyModel;
 use yaak_plugins::events::{
-    GetHttpAuthenticationConfigResponse, GetHttpAuthenticationSummaryResponse, RenderPurpose,
+    GetHttpAuthenticationConfigResponse, GetHttpAuthenticationSummaryResponse, JsonPrimitive,
+    RenderPurpose,
 };
 use yaak_rpc_schema::*;
 use yaak_templates::RenderOptions;
@@ -28,7 +31,7 @@ pub async fn cmd_get_http_authentication_config<H: PluginHost>(
 ) -> Result<GetHttpAuthenticationConfigResponse> {
    // A config form is being displayed, so a template that cannot resolve
    // should show as blank rather than refuse to open the form.
-    let values = render_form_values(
+    let values = render_auth_values(
        &host,
        &req.model,
        req.environment_id.as_deref(),
@@ -47,7 +50,7 @@ pub async fn cmd_call_http_authentication_action<H: PluginHost>(
 ) -> Result<()> {
    // An action actually uses these values, so an unresolvable template is an
    // error rather than an empty string that would silently authenticate wrong.
-    let values = render_form_values(
+    let values = render_auth_values(
        &host,
        &req.model,
        req.environment_id.as_deref(),
@@ -60,3 +63,40 @@ pub async fn cmd_call_http_authentication_action<H: PluginHost>(
    host.call_http_authentication_action(&req.auth_name, req.action_index, values, req.model.id())
        .await
 }
+
+/// Render the form's values against the environment chain the model sits in.
+///
+/// The chain depends on where the model lives — a request inherits through its
+/// folder, a workspace has only its own — so the model is what decides which
+/// variables are in scope.
+async fn render_auth_values<H: PluginHost>(
+    host: &H,
+    model: &AnyModel,
+    environment_id: Option<&str>,
+    values: HashMap<String, JsonPrimitive>,
+    purpose: RenderPurpose,
+    options: &RenderOptions,
+) -> Result<HashMap<String, JsonPrimitive>> {
+    let (workspace_id, folder_id) = match model {
+        AnyModel::HttpRequest(r) => (r.workspace_id.clone(), r.folder_id.clone()),
+        AnyModel::GrpcRequest(r) => (r.workspace_id.clone(), r.folder_id.clone()),
+        AnyModel::WebsocketRequest(r) => (r.workspace_id.clone(), r.folder_id.clone()),
+        AnyModel::Folder(f) => (f.workspace_id.clone(), f.folder_id.clone()),
+        AnyModel::Workspace(w) => (w.id.clone(), None),
+        other => {
+            return Err(Error::Generic(format!(
+                "Cannot resolve authentication for a {}",
+                other.model()
+            )));
+        }
+    };
+
+    let environment_chain =
+        host.db().resolve_environments(&workspace_id, folder_id.as_deref(), environment_id)?;
+
+    let cb = host.template_callback(purpose);
+    let rendered =
+        render_json_value(serde_json::to_value(&values)?, environment_chain, &cb, options).await?;
+
+    Ok(serde_json::from_value(rendered)?)
+}
@@ -130,7 +130,6 @@ pub trait PluginHost: Host {
    ) -> impl Future<Output = crate::Result<Vec<GetTemplateFunctionSummaryResponse>>>;

    /// The form a template function wants to show for the given values.
-    /// `values` arrive already rendered.
    fn template_function_config(
        &self,
        function_name: &str,
@@ -1,19 +1,12 @@
 //! Rendering a template against an environment chain.
 //!
 //! The variables come from the chain, the functions come from the host's
-//! template callback. `render_template` and `render_json_value` know nothing
-//! about which host they run under — that is the whole point of taking the
-//! callback as a parameter. `render_form_values` sits one level up: resolving
-//! the chain a model sits in is an ordinary database read, so it takes the
-//! host and does that read before rendering.
+//! template callback. Neither of these knows which host it is running under —
+//! that is the whole point of taking the callback as a parameter.

-use crate::error::{Error, Result};
-use crate::host::PluginHost;
 use serde_json::Value;
-use std::collections::HashMap;
-use yaak_models::models::{AnyModel, Environment};
+use yaak_models::models::Environment;
 use yaak_models::render::make_vars_hashmap;
-use yaak_plugins::events::{JsonPrimitive, RenderPurpose};
 use yaak_templates::{RenderOptions, TemplateCallback, parse_and_render, render_json_value_raw};

 pub async fn render_template<T: TemplateCallback>(
@@ -35,40 +28,3 @@ pub async fn render_json_value<T: TemplateCallback>(
    let vars = &make_vars_hashmap(environment_chain);
    render_json_value_raw(value, vars, cb, opt).await
 }
-
-/// Render a config form's values against the environment chain the model sits in.
-///
-/// The chain depends on where the model lives — a request inherits through its
-/// folder, a workspace has only its own — so the model is what decides which
-/// variables are in scope.
-pub(crate) async fn render_form_values<H: PluginHost>(
-    host: &H,
-    model: &AnyModel,
-    environment_id: Option<&str>,
-    values: HashMap<String, JsonPrimitive>,
-    purpose: RenderPurpose,
-    options: &RenderOptions,
-) -> Result<HashMap<String, JsonPrimitive>> {
-    let (workspace_id, folder_id) = match model {
-        AnyModel::HttpRequest(r) => (r.workspace_id.clone(), r.folder_id.clone()),
-        AnyModel::GrpcRequest(r) => (r.workspace_id.clone(), r.folder_id.clone()),
-        AnyModel::WebsocketRequest(r) => (r.workspace_id.clone(), r.folder_id.clone()),
-        AnyModel::Folder(f) => (f.workspace_id.clone(), f.folder_id.clone()),
-        AnyModel::Workspace(w) => (w.id.clone(), None),
-        other => {
-            return Err(Error::Generic(format!(
-                "Cannot resolve environments for a {}",
-                other.model()
-            )));
-        }
-    };
-
-    let environment_chain =
-        host.db().resolve_environments(&workspace_id, folder_id.as_deref(), environment_id)?;
-
-    let cb = host.template_callback(purpose);
-    let rendered =
-        render_json_value(serde_json::to_value(&values)?, environment_chain, &cb, options).await?;
-
-    Ok(serde_json::from_value(rendered)?)
-}
@@ -7,7 +7,7 @@

 use crate::error::Result;
 use crate::host::PluginHost;
-use crate::render::{render_form_values, render_template};
+use crate::render::render_template;
 use yaak_plugins::events::{
    GetTemplateFunctionConfigResponse, GetTemplateFunctionSummaryResponse, GetThemesResponse,
    RenderPurpose,
@@ -56,19 +56,7 @@ pub async fn cmd_template_function_config<H: PluginHost>(
    host: H,
    req: CmdTemplateFunctionConfigReq,
 ) -> Result<GetTemplateFunctionConfigResponse> {
-    // A config form is being displayed, so a template that cannot resolve
-    // should show as blank rather than refuse to open the form.
-    let values = render_form_values(
-        &host,
-        &req.model,
-        req.environment_id.as_deref(),
-        req.values,
-        RenderPurpose::Preview,
-        &RenderOptions::return_empty(),
-    )
-    .await?;
-
-    host.template_function_config(&req.function_name, values, req.model.id()).await
+    host.template_function_config(&req.function_name, req.values, req.model.id()).await
 }

 pub async fn cmd_get_themes<H: PluginHost>(
@@ -18,7 +18,7 @@ use yaak_commands::models::{
    cmd_default_headers, cmd_get_workspace_meta, models_delete, models_upsert,
    models_workspace_models,
 };
-use yaak_commands::templates::{cmd_render_template, cmd_template_function_config};
+use yaak_commands::templates::cmd_render_template;
 use yaak_commands::{Host, PluginHost};
 use yaak_core::WorkspaceContext;
 use yaak_crypto::manager::EncryptionManager;
@@ -172,8 +172,6 @@ struct SingleThreadedHost {
    /// The values the last auth-config call arrived with, so a test can check
    /// they were rendered before the host ever saw them.
    auth_values: Rc<RefCell<Option<HashMap<String, JsonPrimitive>>>>,
-    /// Same, for the last template-function-config call.
-    fn_values: Rc<RefCell<Option<HashMap<String, JsonPrimitive>>>>,
 }

 impl Host for SingleThreadedHost {
@@ -263,10 +261,9 @@ impl PluginHost for SingleThreadedHost {
    async fn template_function_config(
        &self,
        function_name: &str,
-        values: HashMap<String, JsonPrimitive>,
+        _values: HashMap<String, JsonPrimitive>,
        _model_id: &str,
    ) -> yaak_commands::Result<GetTemplateFunctionConfigResponse> {
-        *self.fn_values.borrow_mut() = Some(values);
        Err(yaak_commands::Error::Generic(format!("no plugin provides {function_name}()")))
    }

@@ -379,7 +376,6 @@ async fn a_single_threaded_host_can_implement_the_trait() {
    let host = SingleThreadedHost {
        inner: Rc::new(Arc::into_inner(inner).expect("sole owner")),
        auth_values: Rc::new(RefCell::new(None)),
-        fn_values: Rc::new(RefCell::new(None)),
    };

    let workspace = Workspace { name: "From one thread".to_string(), ..Default::default() };
@@ -452,7 +448,6 @@ async fn auth_values_are_rendered_before_the_host_sees_them() {
    let host = SingleThreadedHost {
        inner: Rc::new(Arc::into_inner(inner).expect("sole owner")),
        auth_values: Rc::new(RefCell::new(None)),
-        fn_values: Rc::new(RefCell::new(None)),
    };

    let workspace = host
@@ -504,65 +499,3 @@ async fn auth_values_are_rendered_before_the_host_sees_them() {
        seen.get("password"),
    );
 }
-
-/// Same contract as auth: template function argument values may contain
-/// templates (the 1Password token argument defaults to `${[1PASSWORD_TOKEN]}`),
-/// and the shared handler renders them before the host is called.
-#[tokio::test]
-async fn template_function_values_are_rendered_before_the_host_sees_them() {
-    let TestHost { inner } = TestHost::new();
-    let host = SingleThreadedHost {
-        inner: Rc::new(Arc::into_inner(inner).expect("sole owner")),
-        auth_values: Rc::new(RefCell::new(None)),
-        fn_values: Rc::new(RefCell::new(None)),
-    };
-
-    let workspace = host
-        .db()
-        .upsert_workspace(
-            &Workspace { name: "Functions".to_string(), ..Default::default() },
-            &host.update_source(),
-        )
-        .expect("workspace");
-    host.db()
-        .upsert_environment(
-            &Environment {
-                workspace_id: workspace.id.clone(),
-                name: "Env".to_string(),
-                variables: vec![EnvironmentVariable {
-                    enabled: true,
-                    name: "1PASSWORD_TOKEN".to_string(),
-                    value: "ops_abc123".to_string(),
-                    id: None,
-                }],
-                ..Default::default()
-            },
-            &host.update_source(),
-        )
-        .expect("environment");
-    let environment =
-        host.db().list_environments_ensure_base(&workspace.id).expect("list").remove(0);
-
-    let mut values = HashMap::new();
-    values.insert("token".to_string(), JsonPrimitive::String("${[1PASSWORD_TOKEN]}".to_string()));
-
-    // The host refuses the call itself — it has no plugins — but only after the
-    // handler has rendered and handed over the values, which is what matters.
-    let _ = cmd_template_function_config(
-        host.clone(),
-        yaak_rpc_schema::CmdTemplateFunctionConfigReq {
-            function_name: "1password.item".to_string(),
-            values,
-            model: AnyModel::Workspace(workspace),
-            environment_id: Some(environment.id),
-        },
-    )
-    .await;
-
-    let seen = host.fn_values.borrow().clone().expect("the host should have been called");
-    assert!(
-        matches!(seen.get("token"), Some(JsonPrimitive::String(v)) if v == "ops_abc123"),
-        "the template should have been rendered before reaching the host, got {:?}",
-        seen.get("token"),
-    );
-}
@@ -47,7 +47,6 @@ export type Folder = {
  settingFollowRedirects: InheritedBoolSetting;
  settingRequestTimeout: InheritedIntSetting;
  settingRequestMessageSize: InheritedIntSetting;
-  settingHttpVersion: InheritedHttpVersionSetting;
 };

 export type GrpcRequest = {
@@ -100,7 +99,6 @@ export type HttpRequest = {
  settingValidateCertificates: InheritedBoolSetting;
  settingFollowRedirects: InheritedBoolSetting;
  settingRequestTimeout: InheritedIntSetting;
-  settingHttpVersion: InheritedHttpVersionSetting;
 };

 export type HttpRequestHeader = { enabled?: boolean; name: string; value: string; id?: string };
@@ -116,12 +114,8 @@ export type HttpUrlParameter = {
  id?: string;
 };

-export type HttpVersion = "auto" | "http1" | "http2";
-
 export type InheritedBoolSetting = { enabled?: boolean; value: boolean };

-export type InheritedHttpVersionSetting = { enabled?: boolean; value: HttpVersion };
-
 export type InheritedIntSetting = { enabled?: boolean; value: number };

 export type SyncModel =
@@ -175,5 +169,4 @@ export type Workspace = {
  settingDnsOverrides: Array<DnsOverride>;
  settingSendCookies: boolean;
  settingStoreCookies: boolean;
-  settingHttpVersion: HttpVersion;
 };
@@ -210,7 +210,7 @@ fn field_to_type_or_ref(root_name: &str, field: FieldDescriptor) -> JsonSchemaEn
                // [Protocol Buffers Well-Known Types]: https://protobuf.dev/reference/protobuf/google.protobuf/
                "google.protobuf.FieldMask" => JsonSchemaEntry::string(),
                "google.protobuf.Timestamp" => JsonSchemaEntry::string_with_format("date-time"),
-                "google.protobuf.Duration" => JsonSchemaEntry::string_with_format("duration"),
+                "google.protobuf.Duration" => JsonSchemaEntry::string(),
                "google.protobuf.StringValue" => JsonSchemaEntry::string(),
                "google.protobuf.BytesValue" => JsonSchemaEntry::string_with_format("byte"),
                "google.protobuf.Int32Value" => JsonSchemaEntry::number("int32"),
@@ -3,7 +3,7 @@ use crate::error::Result;
 use log::{debug, info, warn};
 use reqwest::{Client, ClientBuilder, Proxy, redirect};
 use std::sync::{Arc, Mutex};
-use yaak_models::models::{DnsOverride, HttpVersion};
+use yaak_models::models::DnsOverride;
 use yaak_tls::{
    ClientCertificateConfig, NativeClientIdentity, get_tls_config, load_native_client_identity,
 };
@@ -39,7 +39,6 @@ impl ConfiguredClient {
 /// supports TLS 1.0+ for legacy servers.
 fn build_native_tls_connector(
    client_cert: Option<ClientCertificateConfig>,
-    http_version: HttpVersion,
 ) -> Result<native_tls::TlsConnector> {
    let mut builder = native_tls::TlsConnector::builder();
    builder.danger_accept_invalid_certs(true);
@@ -47,11 +46,7 @@ fn build_native_tls_connector(
    builder.min_protocol_version(Some(native_tls::Protocol::Tlsv10));
    // reqwest cannot add ALPN to a connector it did not build, so without this
    // the native path would silently negotiate HTTP/1.1 for every request.
-    match http_version {
-        HttpVersion::Auto => builder.request_alpns(&["h2", "http/1.1"]),
-        HttpVersion::Http1 => builder.request_alpns(&["http/1.1"]),
-        HttpVersion::Http2 => builder.request_alpns(&["h2"]),
-    };
+    builder.request_alpns(&["h2", "http/1.1"]);

    if let Some(identity) = build_native_tls_identity(client_cert)? {
        builder.identity(identity);
@@ -105,7 +100,6 @@ pub enum HttpConnectionProxySetting {
 pub struct HttpConnectionOptions {
    pub id: String,
    pub validate_certificates: bool,
-    pub http_version: HttpVersion,
    pub proxy: HttpConnectionProxySetting,
    pub client_certificate: Option<ClientCertificateConfig>,
    pub dns_overrides: Vec<DnsOverride>,
@@ -134,28 +128,14 @@ impl HttpConnectionOptions {
            // This is needed so we can emit DNS timing events for each request
            .pool_max_idle_per_host(0);

-        match self.http_version {
-            HttpVersion::Auto => {}
-            HttpVersion::Http1 => client = client.http1_only(),
-            HttpVersion::Http2 => client = client.http2_prior_knowledge(),
-        }
-
        // Configure TLS
        if self.validate_certificates {
            // Use rustls with platform certificate verification (TLS 1.2+ only)
-            let mut config = get_tls_config(true, true, self.client_certificate.clone())?;
-            // A forced version must also constrain ALPN, or the server may
-            // negotiate a protocol the client then refuses to speak
-            match self.http_version {
-                HttpVersion::Auto => {}
-                HttpVersion::Http1 => config.alpn_protocols = vec![b"http/1.1".to_vec()],
-                HttpVersion::Http2 => config.alpn_protocols = vec![b"h2".to_vec()],
-            }
+            let config = get_tls_config(true, true, self.client_certificate.clone())?;
            client = client.use_preconfigured_tls(config);
        } else {
            // Use native TLS for maximum compatibility (supports TLS 1.0+)
-            let connector =
-                build_native_tls_connector(self.client_certificate.clone(), self.http_version)?;
+            let connector = build_native_tls_connector(self.client_certificate.clone())?;
            client = client.use_preconfigured_tls(connector);
        }

@@ -28,10 +28,7 @@ impl HttpConnectionManager {

    pub async fn get_client(&self, opt: &HttpConnectionOptions) -> Result<CachedClient> {
        let mut connections = self.connections.write().await;
-        // The key must include any per-request option that changes how the
-        // client is built, or a send after a settings change reuses a client
-        // built with the old value for up to the cache TTL.
-        let id = format!("{}::{}::{}", opt.id, opt.validate_certificates, opt.http_version);
+        let id = opt.id.clone();

        // Clean old connections
        connections.retain(|_, (_, last_used)| last_used.elapsed() <= self.ttl);
@@ -110,7 +110,6 @@ export type Folder = {
  settingFollowRedirects: InheritedBoolSetting;
  settingRequestTimeout: InheritedIntSetting;
  settingRequestMessageSize: InheritedIntSetting;
-  settingHttpVersion: InheritedHttpVersionSetting;
 };

 export type GraphQlIntrospection = {
@@ -215,7 +214,6 @@ export type HttpRequest = {
  settingValidateCertificates: InheritedBoolSetting;
  settingFollowRedirects: InheritedBoolSetting;
  settingRequestTimeout: InheritedIntSetting;
-  settingHttpVersion: InheritedHttpVersionSetting;
 };

 export type HttpRequestHeader = { enabled?: boolean; name: string; value: string; id?: string };
@@ -320,7 +318,6 @@ export type HttpSendSettings = {
  timeoutMs: number;
  sendCookies: boolean;
  storeCookies: boolean;
-  httpVersion: HttpVersion;
 };

 export type HttpUrlParameter = {
@@ -334,12 +331,8 @@ export type HttpUrlParameter = {
  id?: string;
 };

-export type HttpVersion = "auto" | "http1" | "http2";
-
 export type InheritedBoolSetting = { enabled?: boolean; value: boolean };

-export type InheritedHttpVersionSetting = { enabled?: boolean; value: HttpVersion };
-
 export type InheritedIntSetting = { enabled?: boolean; value: number };

 export type KeyValue = {
@@ -482,14 +475,7 @@ export type WebsocketEvent = {
 };

 export type WebsocketEventType =
-  | "binary"
-  | "close"
-  | "error"
-  | "frame"
-  | "open"
-  | "ping"
-  | "pong"
-  | "text";
+  "binary" | "close" | "error" | "frame" | "open" | "ping" | "pong" | "text";

 export type WebsocketMessageType = "text" | "binary";

@@ -536,7 +522,6 @@ export type Workspace = {
  settingDnsOverrides: Array<DnsOverride>;
  settingSendCookies: boolean;
  settingStoreCookies: boolean;
-  settingHttpVersion: HttpVersion;
 };

 export type WorkspaceMeta = {
@@ -2,22 +2,3 @@
 import type { Environment, Folder, GrpcRequest, HttpRequest, WebsocketRequest, Workspace } from "./gen_models";

 export type BatchUpsertResult = { workspaces: Array<Workspace>, environments: Array<Environment>, folders: Array<Folder>, httpRequests: Array<HttpRequest>, grpcRequests: Array<GrpcRequest>, websocketRequests: Array<WebsocketRequest>, };
-
-/**
- * Where a staged import will be committed.
- *
- * The destination workspace and optional folder IDs are captured in the plan so the preview describes
- * the exact destination that confirmation will use.
- */
-export type ImportDestination = { "type": "new_workspace" } | { "type": "existing_workspace", workspaceId: string, folderId?: string, };
-
-export type ImportPlan = { importer: string, destination: ImportDestination, resources: BatchUpsertResult, warnings: Array<ImportPlanWarning>, 
-/**
- * Stable source key for every model in `resources`, keyed by its freshly minted ID.
- *
- * Committing the plan can persist these so a later import of the same document recognizes
- * which models it already created, instead of duplicating them.
- */
-sourceKeys: { [key in string]?: string }, };
-
-export type ImportPlanWarning = { title: string, detail: string, };
@@ -1,5 +0,0 @@
-ALTER TABLE workspaces ADD COLUMN setting_http_version TEXT DEFAULT 'auto' NOT NULL;
-
-ALTER TABLE folders ADD COLUMN setting_http_version TEXT DEFAULT '{"enabled":false,"value":"auto"}' NOT NULL;
-
-ALTER TABLE http_requests ADD COLUMN setting_http_version TEXT DEFAULT '{"enabled":false,"value":"auto"}' NOT NULL;
@@ -1,9 +1,9 @@
 use crate::error::Result;
 use crate::models::HttpRequestIden::{
    Authentication, AuthenticationType, Body, BodyType, CreatedAt, Description, FolderId, Headers,
-    Method, Name, SettingFollowRedirects, SettingHttpVersion, SettingRequestTimeout,
-    SettingSendCookies, SettingStoreCookies, SettingValidateCertificates, SortPriority, UpdatedAt,
-    Url, UrlParameters, WorkspaceId,
+    Method, Name, SettingFollowRedirects, SettingRequestTimeout, SettingSendCookies,
+    SettingStoreCookies, SettingValidateCertificates, SortPriority, UpdatedAt, Url, UrlParameters,
+    WorkspaceId,
 };
 use crate::util::generate_prefixed_id;
 use chrono::{NaiveDateTime, Utc};
@@ -143,7 +143,6 @@ pub struct ResolvedHttpRequestSettings {
    pub request_message_size: ResolvedSetting<i32>,
    pub send_cookies: ResolvedSetting<bool>,
    pub store_cookies: ResolvedSetting<bool>,
-    pub http_version: ResolvedSetting<HttpVersion>,
 }

 impl Default for ResolvedHttpRequestSettings {
@@ -155,7 +154,6 @@ impl Default for ResolvedHttpRequestSettings {
            request_message_size: ResolvedSetting::default_source(DEFAULT_REQUEST_MESSAGE_SIZE),
            send_cookies: ResolvedSetting::default_source(true),
            store_cookies: ResolvedSetting::default_source(true),
-            http_version: ResolvedSetting::default_source(HttpVersion::Auto),
        }
    }
 }
@@ -193,7 +191,6 @@ impl ResolvedHttpRequestSettings {
            event("timeout", timeout, &self.request_timeout),
            event("send_cookies", self.send_cookies.value.to_string(), &self.send_cookies),
            event("store_cookies", self.store_cookies.value.to_string(), &self.store_cookies),
-            event("http_version", self.http_version.value.to_string(), &self.http_version),
        ]
    }
 }
@@ -211,8 +208,6 @@ pub struct HttpSendSettings {
    pub timeout_ms: i32,
    pub send_cookies: bool,
    pub store_cookies: bool,
-    #[serde(default)]
-    pub http_version: HttpVersion,
 }

 impl From<&ResolvedHttpRequestSettings> for HttpSendSettings {
@@ -223,7 +218,6 @@ impl From<&ResolvedHttpRequestSettings> for HttpSendSettings {
            timeout_ms: s.request_timeout.value,
            send_cookies: s.send_cookies.value,
            store_cookies: s.store_cookies.value,
-            http_version: s.http_version.value,
        }
    }
 }
@@ -261,49 +255,6 @@ impl Default for InheritedIntSetting {
    }
 }

-#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize, JsonSchema, TS)]
-#[serde(rename_all = "snake_case")]
-#[ts(export, export_to = "gen_models.ts")]
-pub enum HttpVersion {
-    #[default]
-    Auto,
-    Http1,
-    Http2,
-}
-
-impl FromStr for HttpVersion {
-    type Err = crate::error::Error;
-
-    fn from_str(s: &str) -> Result<Self> {
-        match s {
-            "http1" => Ok(Self::Http1),
-            "http2" => Ok(Self::Http2),
-            _ => Ok(Self::Auto),
-        }
-    }
-}
-
-impl Display for HttpVersion {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let str = match self {
-            HttpVersion::Auto => "auto",
-            HttpVersion::Http1 => "http1",
-            HttpVersion::Http2 => "http2",
-        };
-        write!(f, "{}", str)
-    }
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Default, Serialize, Deserialize, JsonSchema, TS)]
-#[serde(default, rename_all = "camelCase")]
-#[ts(export, export_to = "gen_models.ts")]
-pub struct InheritedHttpVersionSetting {
-    #[serde(default)]
-    #[ts(optional, as = "Option<bool>")]
-    pub enabled: bool,
-    pub value: HttpVersion,
-}
-
 #[derive(Debug, Clone, Serialize, Deserialize, TS)]
 #[serde(rename_all = "snake_case")]
 #[ts(export, export_to = "gen_models.ts")]
@@ -533,7 +484,6 @@ impl Default for Workspace {
            setting_dns_overrides: Vec::new(),
            setting_send_cookies: true,
            setting_store_cookies: true,
-            setting_http_version: HttpVersion::Auto,
        }
    }
 }
@@ -566,7 +516,6 @@ pub struct Workspace {
    pub setting_dns_overrides: Vec<DnsOverride>,
    pub setting_send_cookies: bool,
    pub setting_store_cookies: bool,
-    pub setting_http_version: HttpVersion,
 }

 impl UpsertModelInfo for Workspace {
@@ -611,7 +560,6 @@ impl UpsertModelInfo for Workspace {
            (SettingDnsOverrides, serde_json::to_string(&self.setting_dns_overrides)?.into()),
            (SettingSendCookies, self.setting_send_cookies.into()),
            (SettingStoreCookies, self.setting_store_cookies.into()),
-            (SettingHttpVersion, self.setting_http_version.to_string().into()),
        ])
    }

@@ -631,7 +579,6 @@ impl UpsertModelInfo for Workspace {
            WorkspaceIden::SettingDnsOverrides,
            WorkspaceIden::SettingSendCookies,
            WorkspaceIden::SettingStoreCookies,
-            WorkspaceIden::SettingHttpVersion,
        ]
    }

@@ -642,7 +589,6 @@ impl UpsertModelInfo for Workspace {
        let headers: String = row.get("headers")?;
        let authentication: String = row.get("authentication")?;
        let setting_dns_overrides: String = row.get("setting_dns_overrides")?;
-        let setting_http_version: String = row.get("setting_http_version")?;
        Ok(Self {
            id: row.get("id")?,
            model: row.get("model")?,
@@ -661,7 +607,6 @@ impl UpsertModelInfo for Workspace {
            setting_dns_overrides: serde_json::from_str(&setting_dns_overrides).unwrap_or_default(),
            setting_send_cookies: row.get("setting_send_cookies")?,
            setting_store_cookies: row.get("setting_store_cookies")?,
-            setting_http_version: setting_http_version.parse().unwrap_or_default(),
        })
    }
 }
@@ -1133,7 +1078,6 @@ impl Default for Folder {
                enabled: false,
                value: DEFAULT_REQUEST_MESSAGE_SIZE,
            },
-            setting_http_version: InheritedHttpVersionSetting::default(),
        }
    }
 }
@@ -1164,7 +1108,6 @@ pub struct Folder {
    pub setting_follow_redirects: InheritedBoolSetting,
    pub setting_request_timeout: InheritedIntSetting,
    pub setting_request_message_size: InheritedIntSetting,
-    pub setting_http_version: InheritedHttpVersionSetting,
 }

 impl UpsertModelInfo for Folder {
@@ -1216,7 +1159,6 @@ impl UpsertModelInfo for Folder {
                SettingRequestMessageSize,
                serde_json::to_string(&self.setting_request_message_size)?.into(),
            ),
-            (SettingHttpVersion, serde_json::to_string(&self.setting_http_version)?.into()),
        ])
    }

@@ -1236,7 +1178,6 @@ impl UpsertModelInfo for Folder {
            FolderIden::SettingFollowRedirects,
            FolderIden::SettingRequestTimeout,
            FolderIden::SettingRequestMessageSize,
-            FolderIden::SettingHttpVersion,
        ]
    }

@@ -1252,7 +1193,6 @@ impl UpsertModelInfo for Folder {
        let setting_follow_redirects: String = row.get("setting_follow_redirects")?;
        let setting_request_timeout: String = row.get("setting_request_timeout")?;
        let setting_request_message_size: String = row.get("setting_request_message_size")?;
-        let setting_http_version: String = row.get("setting_http_version")?;
        Ok(Self {
            id: row.get("id")?,
            model: row.get("model")?,
@@ -1276,7 +1216,6 @@ impl UpsertModelInfo for Folder {
                .unwrap_or_default(),
            setting_request_message_size: serde_json::from_str(&setting_request_message_size)
                .unwrap_or_else(|_| default_request_message_size_setting()),
-            setting_http_version: serde_json::from_str(&setting_http_version).unwrap_or_default(),
        })
    }
 }
@@ -1344,7 +1283,6 @@ impl Default for HttpRequest {
            setting_validate_certificates: InheritedBoolSetting::default(),
            setting_follow_redirects: InheritedBoolSetting::default(),
            setting_request_timeout: InheritedIntSetting::default(),
-            setting_http_version: InheritedHttpVersionSetting::default(),
        }
    }
 }
@@ -1381,7 +1319,6 @@ pub struct HttpRequest {
    pub setting_validate_certificates: InheritedBoolSetting,
    pub setting_follow_redirects: InheritedBoolSetting,
    pub setting_request_timeout: InheritedIntSetting,
-    pub setting_http_version: InheritedHttpVersionSetting,
 }

 impl UpsertModelInfo for HttpRequest {
@@ -1433,7 +1370,6 @@ impl UpsertModelInfo for HttpRequest {
            ),
            (SettingFollowRedirects, serde_json::to_string(&self.setting_follow_redirects)?.into()),
            (SettingRequestTimeout, serde_json::to_string(&self.setting_request_timeout)?.into()),
-            (SettingHttpVersion, serde_json::to_string(&self.setting_http_version)?.into()),
        ])
    }

@@ -1458,7 +1394,6 @@ impl UpsertModelInfo for HttpRequest {
            SettingValidateCertificates,
            SettingFollowRedirects,
            SettingRequestTimeout,
-            SettingHttpVersion,
        ]
    }

@@ -1472,7 +1407,6 @@ impl UpsertModelInfo for HttpRequest {
        let setting_validate_certificates: String = row.get("setting_validate_certificates")?;
        let setting_follow_redirects: String = row.get("setting_follow_redirects")?;
        let setting_request_timeout: String = row.get("setting_request_timeout")?;
-        let setting_http_version: String = row.get("setting_http_version")?;
        Ok(Self {
            id: row.get("id")?,
            model: row.get("model")?,
@@ -1499,7 +1433,6 @@ impl UpsertModelInfo for HttpRequest {
                .unwrap_or_default(),
            setting_request_timeout: serde_json::from_str(&setting_request_timeout)
                .unwrap_or_default(),
-            setting_http_version: serde_json::from_str(&setting_http_version).unwrap_or_default(),
        })
    }
 }
@@ -208,14 +208,6 @@ impl<'a> ClientDb<'a> {
            } else {
                parent.store_cookies
            },
-            http_version: if folder.setting_http_version.enabled {
-                ResolvedSetting::from_model(
-                    folder.setting_http_version.value,
-                    AnyModel::Folder(folder.clone()),
-                )
-            } else {
-                parent.http_version
-            },
        })
    }
 }
@@ -153,14 +153,6 @@ impl<'a> ClientDb<'a> {
            } else {
                parent.store_cookies
            },
-            http_version: if http_request.setting_http_version.enabled {
-                ResolvedSetting::from_model(
-                    http_request.setting_http_version.value,
-                    AnyModel::HttpRequest(http_request.clone()),
-                )
-            } else {
-                parent.http_version
-            },
        })
    }

@@ -182,10 +174,7 @@ impl<'a> ClientDb<'a> {
 #[cfg(test)]
 mod tests {
    use crate::init_in_memory;
-    use crate::models::{
-        Folder, HttpRequest, HttpRequestHeader, HttpVersion, InheritedHttpVersionSetting, Workspace,
-    };
-    use crate::util::UpdateSource;
+    use crate::models::{HttpRequest, HttpRequestHeader};

    #[test]
    fn request_resolution_preserves_duplicate_request_headers() {
@@ -221,77 +210,4 @@ mod tests {
        assert_eq!(cookies[1].value, "optional=1");
        assert!(!cookies[1].enabled);
    }
-
-    #[test]
-    fn http_version_resolves_through_the_inheritance_chain() {
-        let (query_manager, _blob_manager, _rx) = init_in_memory().expect("Failed to init DB");
-        let db = query_manager.connect();
-
-        let workspace = db
-            .upsert_workspace(
-                &Workspace {
-                    name: "Test".to_string(),
-                    setting_http_version: HttpVersion::Http2,
-                    ..Default::default()
-                },
-                &UpdateSource::Background,
-            )
-            .expect("Failed to upsert workspace");
-
-        let folder = db
-            .upsert_folder(
-                &Folder { workspace_id: workspace.id.clone(), ..Default::default() },
-                &UpdateSource::Background,
-            )
-            .expect("Failed to upsert folder");
-
-        let request = db
-            .upsert_http_request(
-                &HttpRequest {
-                    workspace_id: workspace.id.clone(),
-                    folder_id: Some(folder.id.clone()),
-                    ..Default::default()
-                },
-                &UpdateSource::Background,
-            )
-            .expect("Failed to upsert request");
-
-        // No overrides, so the workspace base value applies
-        let resolved = db.resolve_settings_for_http_request(&request).expect("Failed to resolve");
-        assert_eq!(resolved.http_version.value, HttpVersion::Http2);
-        assert_eq!(resolved.http_version.source_model, "workspace");
-
-        // A folder override beats the workspace base
-        db.upsert_folder(
-            &Folder {
-                setting_http_version: InheritedHttpVersionSetting {
-                    enabled: true,
-                    value: HttpVersion::Http1,
-                },
-                ..folder
-            },
-            &UpdateSource::Background,
-        )
-        .expect("Failed to update folder");
-        let resolved = db.resolve_settings_for_http_request(&request).expect("Failed to resolve");
-        assert_eq!(resolved.http_version.value, HttpVersion::Http1);
-        assert_eq!(resolved.http_version.source_model, "folder");
-
-        // A request override beats them both
-        let request = db
-            .upsert_http_request(
-                &HttpRequest {
-                    setting_http_version: InheritedHttpVersionSetting {
-                        enabled: true,
-                        value: HttpVersion::Auto,
-                    },
-                    ..request
-                },
-                &UpdateSource::Background,
-            )
-            .expect("Failed to update request");
-        let resolved = db.resolve_settings_for_http_request(&request).expect("Failed to resolve");
-        assert_eq!(resolved.http_version.value, HttpVersion::Auto);
-        assert_eq!(resolved.http_version.source_model, "http_request");
-    }
 }
@@ -96,8 +96,8 @@ impl<'a> ClientDb<'a> {
                deleted
            }
            Err(e) => {
-                let _ =
-                    conn.execute_batch("ROLLBACK TO delete_workspace; RELEASE delete_workspace");
+                let _ = conn
+                    .execute_batch("ROLLBACK TO delete_workspace; RELEASE delete_workspace");
                return Err(e);
            }
        };
@@ -177,10 +177,6 @@ impl<'a> ClientDb<'a> {
                workspace.setting_store_cookies,
                AnyModel::Workspace(workspace.clone()),
            ),
-            http_version: ResolvedSetting::from_model(
-                workspace.setting_http_version,
-                AnyModel::Workspace(workspace.clone()),
-            ),
        }
    }
 }
@@ -85,48 +85,6 @@ pub struct BatchUpsertResult {
    pub websocket_requests: Vec<WebsocketRequest>,
 }

-/// Where a staged import will be committed.
-///
-/// The destination workspace and optional folder IDs are captured in the plan so the preview describes
-/// the exact destination that confirmation will use.
-#[derive(Debug, Clone, Deserialize, Serialize, TS)]
-#[serde(rename_all = "snake_case", tag = "type")]
-#[ts(export, export_to = "gen_util.ts")]
-pub enum ImportDestination {
-    NewWorkspace,
-    ExistingWorkspace {
-        #[serde(rename = "workspaceId")]
-        workspace_id: String,
-        #[serde(rename = "folderId")]
-        #[ts(optional)]
-        folder_id: Option<String>,
-    },
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize, TS)]
-#[serde(rename_all = "camelCase")]
-#[ts(export, export_to = "gen_util.ts")]
-pub struct ImportPlanWarning {
-    pub title: String,
-    pub detail: String,
-}
-
-#[derive(Debug, Deserialize, Serialize, TS)]
-#[serde(rename_all = "camelCase")]
-#[ts(export, export_to = "gen_util.ts")]
-pub struct ImportPlan {
-    pub importer: String,
-    pub destination: ImportDestination,
-    pub resources: BatchUpsertResult,
-    pub warnings: Vec<ImportPlanWarning>,
-
-    /// Stable source key for every model in `resources`, keyed by its freshly minted ID.
-    ///
-    /// Committing the plan can persist these so a later import of the same document recognizes
-    /// which models it already created, instead of duplicating them.
-    pub source_keys: BTreeMap<String, String>,
-}
-
 pub fn get_workspace_export_resources(
    db: &ClientDb,
    yaak_version: &str,
@@ -474,19 +474,7 @@ export type ImportRequest = { content: string, };

 export type ImportResources = { workspaces: Array<Workspace>, environments: Array<Environment>, folders: Array<Folder>, httpRequests: Array<HttpRequest>, grpcRequests: Array<GrpcRequest>, websocketRequests: Array<WebsocketRequest>, };

-export type ImportResponse = { 
-/**
- * Display name of the importer that recognized the input.
- */
-importer: string, resources: ImportResources, 
-/**
- * Stable identity for imported resources, keyed by the resource IDs in `resources`.
- *
- * A key identifies the same source element across re-parses of an edited document, which
- * lets a later import recognize what it already imported. Importers only populate it for
- * formats that carry their own identifiers; the host derives a key for anything missing.
- */
-sourceKeys?: { [key in string]?: string }, };
+export type ImportResponse = { resources: ImportResources, };

 export type InternalEvent = { id: string, pluginRefId: string, pluginName: string, replyId: string | null, context: PluginContext, payload: InternalEventPayload, };

@@ -109,7 +109,6 @@ export type Folder = {
  settingFollowRedirects: InheritedBoolSetting;
  settingRequestTimeout: InheritedIntSetting;
  settingRequestMessageSize: InheritedIntSetting;
-  settingHttpVersion: InheritedHttpVersionSetting;
 };

 export type GraphQlIntrospection = {
@@ -214,7 +213,6 @@ export type HttpRequest = {
  settingValidateCertificates: InheritedBoolSetting;
  settingFollowRedirects: InheritedBoolSetting;
  settingRequestTimeout: InheritedIntSetting;
-  settingHttpVersion: InheritedHttpVersionSetting;
 };

 export type HttpRequestHeader = { enabled?: boolean; name: string; value: string; id?: string };
@@ -316,12 +314,8 @@ export type HttpUrlParameter = {
  id?: string;
 };

-export type HttpVersion = "auto" | "http1" | "http2";
-
 export type InheritedBoolSetting = { enabled?: boolean; value: boolean };

-export type InheritedHttpVersionSetting = { enabled?: boolean; value: HttpVersion };
-
 export type InheritedIntSetting = { enabled?: boolean; value: number };

 export type KeyValue = {
@@ -384,7 +378,6 @@ export type Settings = {
  themeLight: string;
  updateChannel: string;
  hideLicenseBadge: boolean;
-  promptFeedback: boolean;
  autoupdate: boolean;
  autoDownloadUpdates: boolean;
  checkNotifications: boolean;
@@ -435,14 +428,7 @@ export type WebsocketEvent = {
 };

 export type WebsocketEventType =
-  | "binary"
-  | "close"
-  | "error"
-  | "frame"
-  | "open"
-  | "ping"
-  | "pong"
-  | "text";
+  "binary" | "close" | "error" | "frame" | "open" | "ping" | "pong" | "text";

 export type WebsocketRequest = {
  model: "websocket_request";
@@ -487,7 +473,6 @@ export type Workspace = {
  settingDnsOverrides: Array<DnsOverride>;
  settingSendCookies: boolean;
  settingStoreCookies: boolean;
-  settingHttpVersion: HttpVersion;
 };

 export type WorkspaceMeta = {
@@ -1,5 +1,5 @@
 use serde::{Deserialize, Serialize};
-use std::collections::{BTreeMap, HashMap};
+use std::collections::HashMap;
 use ts_rs::TS;
 use yaak_models::models::{
    AnyModel, Environment, Folder, GrpcRequest, HttpRequest, HttpResponse, WebsocketRequest,
@@ -247,17 +247,7 @@ pub struct ImportRequest {
 #[serde(default, rename_all = "camelCase")]
 #[ts(export, export_to = "gen_events.ts")]
 pub struct ImportResponse {
-    /// Display name of the importer that recognized the input.
-    pub importer: String,
    pub resources: ImportResources,
-
-    /// Stable identity for imported resources, keyed by the resource IDs in `resources`.
-    ///
-    /// A key identifies the same source element across re-parses of an edited document, which
-    /// lets a later import recognize what it already imported. Importers only populate it for
-    /// formats that carry their own identifiers; the host derives a key for anything missing.
-    #[ts(optional)]
-    pub source_keys: Option<BTreeMap<String, String>>,
 }

 #[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
@@ -1104,19 +1104,8 @@ impl PluginManager {
            .await?;

        // TODO: Don't just return the first valid response
-        let result = reply_events.into_iter().find_map(|e| match e {
-            InternalEvent {
-                plugin_name,
-                payload: InternalEventPayload::ImportResponse(mut resp),
-                ..
-            } => {
-                // Older plugin runtimes do not include the importer's display name. The plugin
-                // package name is still enough to identify the detected format in that case.
-                if resp.importer.is_empty() {
-                    resp.importer = plugin_name;
-                }
-                Some(resp)
-            }
+        let result = reply_events.into_iter().find_map(|e| match e.payload {
+            InternalEventPayload::ImportResponse(resp) => Some(resp),
            _ => None,
        });

@@ -47,7 +47,6 @@ export type Folder = {
  settingFollowRedirects: InheritedBoolSetting;
  settingRequestTimeout: InheritedIntSetting;
  settingRequestMessageSize: InheritedIntSetting;
-  settingHttpVersion: InheritedHttpVersionSetting;
 };

 export type GrpcRequest = {
@@ -100,7 +99,6 @@ export type HttpRequest = {
  settingValidateCertificates: InheritedBoolSetting;
  settingFollowRedirects: InheritedBoolSetting;
  settingRequestTimeout: InheritedIntSetting;
-  settingHttpVersion: InheritedHttpVersionSetting;
 };

 export type HttpRequestHeader = { enabled?: boolean; name: string; value: string; id?: string };
@@ -116,12 +114,8 @@ export type HttpUrlParameter = {
  id?: string;
 };

-export type HttpVersion = "auto" | "http1" | "http2";
-
 export type InheritedBoolSetting = { enabled?: boolean; value: boolean };

-export type InheritedHttpVersionSetting = { enabled?: boolean; value: HttpVersion };
-
 export type InheritedIntSetting = { enabled?: boolean; value: number };

 export type SyncModel =
@@ -188,5 +182,4 @@ export type Workspace = {
  settingDnsOverrides: Array<DnsOverride>;
  settingSendCookies: boolean;
  settingStoreCookies: boolean;
-  settingHttpVersion: HttpVersion;
 };
@@ -8,12 +8,25 @@ use std::future::Future;

 const MAX_DEPTH: usize = 50;

+/// `Send`, except on wasm32, where a template function is a call into
+/// JavaScript: the future holds a `JsFuture` and the callback an `Rc` pool,
+/// neither of which can be `Send`. Every other host spawns rendering onto a
+/// thread pool and needs the bound.
+#[cfg(not(target_arch = "wasm32"))]
+pub trait MaybeSend: Send {}
+#[cfg(not(target_arch = "wasm32"))]
+impl<T: Send> MaybeSend for T {}
+#[cfg(target_arch = "wasm32")]
+pub trait MaybeSend {}
+#[cfg(target_arch = "wasm32")]
+impl<T> MaybeSend for T {}
+
 pub trait TemplateCallback {
    fn run(
        &self,
        fn_name: &str,
        args: HashMap<String, serde_json::Value>,
-    ) -> impl Future<Output = Result<String>> + Send;
+    ) -> impl Future<Output = Result<String>> + MaybeSend;

    fn transform_arg(&self, fn_name: &str, arg_name: &str, arg_value: &str) -> Result<String>;
 }
@@ -25,6 +25,7 @@ crate-type = ["cdylib", "rlib"]
 log = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
+md5 = "0.7"
 yaak-lifecycle = { workspace = true }
 yaak-models = { workspace = true }
 # No default features: the template exports belong to @yaakapp-internal/templates, not this module
@@ -3,4 +3,12 @@
 // This is loaded by the SharedWorker in packages/platform/src/web/worker.ts and
 // nowhere else: it owns a SQLite database, and there must be exactly one of it
 // per origin.
-export { blob_delete, blob_get, blob_put, boot, prepare_http_send, rpc } from "./pkg";
+export {
+  blob_delete,
+  blob_get,
+  blob_put,
+  boot,
+  prepare_http_send,
+  render_template,
+  rpc,
+} from "./pkg";
@@ -26,15 +26,24 @@ export function blob_put(id: string, bytes: Uint8Array): void;
 export function boot(): Promise<void>;

 /**
- * Resolve and render a request for sending, exactly as the desktop does before it puts the
- * request on the network: the environment chain, inherited headers and auth, request
- * settings, the cookie jar. Nothing here touches a socket. What comes back is what the tab
- * posts to the Yaak server.
+ * Resolve and render a request for sending, exactly as the desktop does: the environment
+ * chain, inherited headers and auth, request settings, the cookie jar. Nothing here touches
+ * a socket.
 *
- * Refuses, with a message the user can act on, when the request needs something this host
- * doesn't have: an authentication plugin, or a template function.
+ * `plugins` is the template function bridge: a JS function taking a name and JSON args,
+ * resolving to the rendered string. Passing nothing is allowed.
+ *
+ * Authentication is applied by the caller, not here, because the plugin that applies it
+ * needs to see the request as it will be sent.
 */
-export function prepare_http_send(payload: any): Promise<any>;
+export function prepare_http_send(payload: any, plugins: any): Promise<any>;
+
+/**
+ * What `cmd_render_template` does on the desktop. `ignore_error` matches it too: a preview
+ * shows an empty string where a send would refuse, since a half-typed template is not yet a
+ * mistake.
+ */
+export function render_template(payload: any, plugins: any): Promise<any>;

 /**
 * Run one command as `label` (the calling tab's identity, which stands in for
@@ -5,5 +5,5 @@ import { __wbg_set_wasm } from "./yaak_wasm_bg.js";
 __wbg_set_wasm(wasm);
 wasm.__wbindgen_start();
 export {
-    blob_delete, blob_get, blob_put, boot, prepare_http_send, rpc
+    blob_delete, blob_get, blob_put, boot, prepare_http_send, render_template, rpc
 } from "./yaak_wasm_bg.js";
@@ -63,18 +63,34 @@ export function boot() {
 }

 /**
- * Resolve and render a request for sending, exactly as the desktop does before it puts the
- * request on the network: the environment chain, inherited headers and auth, request
- * settings, the cookie jar. Nothing here touches a socket. What comes back is what the tab
- * posts to the Yaak server.
+ * Resolve and render a request for sending, exactly as the desktop does: the environment
+ * chain, inherited headers and auth, request settings, the cookie jar. Nothing here touches
+ * a socket.
 *
- * Refuses, with a message the user can act on, when the request needs something this host
- * doesn't have: an authentication plugin, or a template function.
+ * `plugins` is the template function bridge: a JS function taking a name and JSON args,
+ * resolving to the rendered string. Passing nothing is allowed.
+ *
+ * Authentication is applied by the caller, not here, because the plugin that applies it
+ * needs to see the request as it will be sent.
 * @param {any} payload
+ * @param {any} plugins
 * @returns {Promise<any>}
 */
-export function prepare_http_send(payload) {
-    const ret = wasm.prepare_http_send(payload);
+export function prepare_http_send(payload, plugins) {
+    const ret = wasm.prepare_http_send(payload, plugins);
+    return ret;
+}
+
+/**
+ * What `cmd_render_template` does on the desktop. `ignore_error` matches it too: a preview
+ * shows an empty string where a send would refuse, since a half-typed template is not yet a
+ * mistake.
+ * @param {any} payload
+ * @param {any} plugins
+ * @returns {Promise<any>}
+ */
+export function render_template(payload, plugins) {
+    const ret = wasm.render_template(payload, plugins);
    return ret;
 }

@@ -225,6 +241,10 @@ export function __wbg_call_dfde26266607c996() { return handleError(function (arg
    const ret = arg0.call(arg1, arg2);
    return ret;
 }, arguments); }
+export function __wbg_call_faa0a261f288f846() { return handleError(function (arg0, arg1, arg2, arg3) {
+    const ret = arg0.call(arg1, arg2, arg3);
+    return ret;
+}, arguments); }
 export function __wbg_clear_bb1b3ff877b62598() { return handleError(function (arg0) {
    const ret = arg0.clear();
    return ret;
@@ -669,6 +689,10 @@ export function __wbg_then_837494e384b37459(arg0, arg1) {
    const ret = arg0.then(arg1);
    return ret;
 }
+export function __wbg_then_bd927500e8905df2(arg0, arg1, arg2) {
+    const ret = arg0.then(arg1, arg2);
+    return ret;
+}
 export function __wbg_toString_1dda136fd8f30a5f(arg0) {
    const ret = arg0.toString();
    return ret;
@@ -697,22 +721,22 @@ export function __wbg_warn_b6f36cac66fc96a4(arg0, arg1) {
    console.warn(arg0, arg1);
 }
 export function __wbindgen_cast_0000000000000001(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 1117, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+    // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 1140, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
    const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__ha1c2fa93df0107f3);
    return ret;
 }
 export function __wbindgen_cast_0000000000000002(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("Event")], shim_idx: 212, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("Event")], shim_idx: 229, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
    const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__ha7903b6e296dd8f4);
    return ret;
 }
 export function __wbindgen_cast_0000000000000003(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("IDBVersionChangeEvent")], shim_idx: 83, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
-    const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h4381d8e749fe46cf);
+    // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("IDBVersionChangeEvent")], shim_idx: 74, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__he166673e9c1b4e95);
    return ret;
 }
 export function __wbindgen_cast_0000000000000004(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 210, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 227, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
    const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__ha1b480b83daa641f);
    return ret;
 }
@@ -765,8 +789,8 @@ function wasm_bindgen__convert__closures_____invoke__ha1c2fa93df0107f3(arg0, arg
    }
 }

-function wasm_bindgen__convert__closures_____invoke__h4381d8e749fe46cf(arg0, arg1, arg2) {
-    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h4381d8e749fe46cf(arg0, arg1, arg2);
+function wasm_bindgen__convert__closures_____invoke__he166673e9c1b4e95(arg0, arg1, arg2) {
+    const ret = wasm.wasm_bindgen__convert__closures_____invoke__he166673e9c1b4e95(arg0, arg1, arg2);
    if (ret[1]) {
        throw takeFromExternrefTable0(ret[0]);
    }
@@ -5,7 +5,8 @@ export const blob_delete: (a: number, b: number) => [number, number];
 export const blob_get: (a: number, b: number) => [number, number, number, number];
 export const blob_put: (a: number, b: number, c: number, d: number) => [number, number];
 export const boot: () => any;
-export const prepare_http_send: (a: any) => any;
+export const prepare_http_send: (a: any, b: any) => any;
+export const render_template: (a: any, b: any) => any;
 export const rpc: (a: number, b: number, c: any, d: number, e: number) => [number, number, number];
 export const rust_sqlite_wasm_abort: () => void;
 export const rust_sqlite_wasm_assert_fail: (a: number, b: number, c: number, d: number) => void;
@@ -18,7 +19,7 @@ export const rust_sqlite_wasm_realloc: (a: number, b: number) => number;
 export const sqlite3_os_end: () => number;
 export const sqlite3_os_init: () => number;
 export const wasm_bindgen__convert__closures_____invoke__ha1c2fa93df0107f3: (a: number, b: number, c: any) => [number, number];
-export const wasm_bindgen__convert__closures_____invoke__h4381d8e749fe46cf: (a: number, b: number, c: any) => [number, number];
+export const wasm_bindgen__convert__closures_____invoke__he166673e9c1b4e95: (a: number, b: number, c: any) => [number, number];
 export const wasm_bindgen__convert__closures_____invoke__h2cf3f4cce3b29948: (a: number, b: number, c: any, d: any) => void;
 export const wasm_bindgen__convert__closures_____invoke__ha7903b6e296dd8f4: (a: number, b: number, c: any) => void;
 export const wasm_bindgen__convert__closures_____invoke__ha1b480b83daa641f: (a: number, b: number) => void;
@@ -232,6 +232,14 @@ struct PersistSendCookiesReq {
    after: Vec<Cookie>,
 }

+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct PluginKeyValueReq {
+    plugin_name: String,
+    key: String,
+    value: Option<String>,
+}
+
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
 struct InsertResponseEventsReq {
@@ -415,6 +423,34 @@ fn dispatch(
            to_json(())
        }

+        // Namespaced by plugin name exactly as `build_shared_reply` does in
+        // crates/yaak/src/plugin_events.rs, so a token is found under the same key on either host.
+        "web_plugin_kv_get" => {
+            let req: PluginKeyValueReq = from_js(payload)?;
+            let found = host.queries.connect().get_plugin_key_value(&req.plugin_name, &req.key);
+            to_json(found.map(|kv| kv.value))
+        }
+
+        "web_plugin_kv_set" => {
+            let req: PluginKeyValueReq = from_js(payload)?;
+            host.queries.connect().set_plugin_key_value(
+                &req.plugin_name,
+                &req.key,
+                &req.value.unwrap_or_default(),
+            );
+            to_json(())
+        }
+
+        "web_plugin_kv_delete" => {
+            let req: PluginKeyValueReq = from_js(payload)?;
+            let deleted = host
+                .queries
+                .connect()
+                .delete_plugin_key_value(&req.plugin_name, &req.key)
+                .map_err(js_error)?;
+            to_json(deleted)
+        }
+
        other => Err(js_error(format!("yaak-web: `{other}` is not a command this host answers"))),
    }
 }
@@ -439,6 +475,9 @@ struct PreparedHttpSend {
    /// The request with inherited headers and authentication applied and every template
    /// rendered. What the proxy sends, and what the response records as its request.
    request: HttpRequest,
+    /// Whichever model the auth was inherited from, hashed as the desktop hashes it. An
+    /// OAuth token cache belongs to the folder that declared the auth, not to each request.
+    auth_context_id: String,
    settings: HttpSendSettings,
    /// The `* Setting name=value` timeline lines the desktop writes at the top of a send,
    /// sources and all. The tab records them before the proxy's own events.
@@ -447,22 +486,44 @@ struct PreparedHttpSend {
    cookie_jar: Option<CookieJar>,
 }

-/// A template callback for a host with no plugins. Variables render; a function is a clear
-/// refusal naming the function, so the user knows what the request needs rather than seeing
-/// an empty string sent in its place.
-struct NoPluginsCallback;
+/// Reaches a template function through a JavaScript function the worker installed, which
+/// forwards to the plugin sandbox. Without one, a template function is a refusal naming it
+/// rather than an empty string sent in its place.
+struct JsTemplateCallback {
+    call: Option<js_sys::Function>,
+}

-impl TemplateCallback for NoPluginsCallback {
+impl TemplateCallback for JsTemplateCallback {
    fn run(
        &self,
        fn_name: &str,
-        _args: HashMap<String, serde_json::Value>,
-    ) -> impl std::future::Future<Output = yaak_templates::error::Result<String>> + Send {
-        let message = format!(
-            "This request uses the template function \"{fn_name}\", which needs plugins. \
-             Plugins aren't available in the browser yet"
-        );
-        async move { Err(yaak_templates::error::Error::RenderError(message)) }
+        args: HashMap<String, serde_json::Value>,
+    ) -> impl std::future::Future<Output = yaak_templates::error::Result<String>> {
+        let call = self.call.clone();
+        let fn_name = fn_name.to_string();
+        let args = serde_json::to_string(&args).unwrap_or_else(|_| "{}".into());
+
+        async move {
+            use yaak_templates::error::Error::RenderError;
+
+            let Some(call) = call else {
+                return Err(RenderError(format!(
+                    "This request uses the template function \"{fn_name}\", which needs plugins. \
+                     No plugin provides it"
+                )));
+            };
+
+            let promise = call
+                .call2(&JsValue::NULL, &JsValue::from_str(&fn_name), &JsValue::from_str(&args))
+                .map_err(|e| RenderError(js_message(&e)))?;
+            let value = wasm_bindgen_futures::JsFuture::from(js_sys::Promise::from(promise))
+                .await
+                .map_err(|e| RenderError(js_message(&e)))?;
+
+            value.as_string().ok_or_else(|| {
+                RenderError(format!("Template function \"{fn_name}\" did not return a string"))
+            })
+        }
    }

    fn transform_arg(
@@ -475,19 +536,35 @@ impl TemplateCallback for NoPluginsCallback {
    }
 }

-/// Resolve and render a request for sending, exactly as the desktop does before it puts the
-/// request on the network: the environment chain, inherited headers and auth, request
-/// settings, the cookie jar. Nothing here touches a socket. What comes back is what the tab
-/// posts to the Yaak server.
+fn js_message(value: &JsValue) -> String {
+    if let Some(text) = value.as_string() {
+        return text;
+    }
+    let message = js_sys::Reflect::get(value, &JsValue::from_str("message"))
+        .ok()
+        .and_then(|m| m.as_string());
+    message.unwrap_or_else(|| format!("{value:?}"))
+}
+
+fn template_callback(plugins: JsValue) -> JsTemplateCallback {
+    JsTemplateCallback { call: plugins.dyn_into::<js_sys::Function>().ok() }
+}
+
+/// Resolve and render a request for sending, exactly as the desktop does: the environment
+/// chain, inherited headers and auth, request settings, the cookie jar. Nothing here touches
+/// a socket.
 ///
-/// Refuses, with a message the user can act on, when the request needs something this host
-/// doesn't have: an authentication plugin, or a template function.
+/// `plugins` is the template function bridge: a JS function taking a name and JSON args,
+/// resolving to the rendered string. Passing nothing is allowed.
+///
+/// Authentication is applied by the caller, not here, because the plugin that applies it
+/// needs to see the request as it will be sent.
 #[wasm_bindgen]
-pub async fn prepare_http_send(payload: JsValue) -> Result<JsValue> {
+pub async fn prepare_http_send(payload: JsValue, plugins: JsValue) -> Result<JsValue> {
    let req: PrepareHttpSendReq = from_js(payload)?;

    // Everything from the database first, then release the host borrow before rendering.
-    let (request, environment_chain, settings, cookie_jar) = with_host(|host| {
+    let (request, environment_chain, settings, cookie_jar, auth_context_id) = with_host(|host| {
        let db = host.queries.connect();
        let request = db.get_http_request(&req.request_id).map_err(js_error)?;
        let environment_chain = db
@@ -497,7 +574,7 @@ pub async fn prepare_http_send(payload: JsValue) -> Result<JsValue> {
                req.environment_id.as_deref(),
            )
            .map_err(js_error)?;
-        let (authentication_type, authentication, _auth_context_id) =
+        let (authentication_type, authentication, auth_context_id) =
            db.resolve_auth_for_http_request(&request).map_err(js_error)?;
        let headers = db.resolve_headers_for_http_request(&request).map_err(js_error)?;
        let settings = db.resolve_settings_for_http_request(&request).map_err(js_error)?;
@@ -506,34 +583,21 @@ pub async fn prepare_http_send(payload: JsValue) -> Result<JsValue> {
            None => None,
        };
        let request = HttpRequest { authentication_type, authentication, headers, ..request };
-        Ok((request, environment_chain, settings, cookie_jar))
+        Ok((request, environment_chain, settings, cookie_jar, auth_context_id))
    })?;

    let rendered = render_http_request(
        &request,
        environment_chain,
-        &NoPluginsCallback,
+        &template_callback(plugins),
        &RenderOptions::throw(),
    )
    .await
    .map_err(js_error)?;

-    // Authentication is applied by a plugin on the desktop. There is no plugin here, and a
-    // request sent without the auth it asked for is worse than one refused with the reason.
-    let auth_disabled =
-        rendered.authentication.get("disabled").and_then(|v| v.as_bool()) == Some(true);
-    if let Some(auth_type) = rendered.authentication_type.as_deref()
-        && auth_type != "none"
-        && !auth_disabled
-    {
-        return Err(js_error(format!(
-            "This request uses {auth_type} authentication, which needs plugins. \
-             Plugins aren't available in the browser yet"
-        )));
-    }
-
    let prepared = PreparedHttpSend {
        request: rendered,
+        auth_context_id: format!("{:x}", md5::compute(auth_context_id)),
        settings: HttpSendSettings::from(&settings),
        setting_events: settings.timeline_events(),
        cookie_jar,
@@ -544,6 +608,43 @@ pub async fn prepare_http_send(payload: JsValue) -> Result<JsValue> {
    prepared.serialize(&serde_wasm_bindgen::Serializer::json_compatible()).map_err(js_error)
 }

+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct RenderTemplateReq {
+    template: String,
+    workspace_id: String,
+    environment_id: Option<String>,
+    ignore_error: Option<bool>,
+}
+
+/// What `cmd_render_template` does on the desktop. `ignore_error` matches it too: a preview
+/// shows an empty string where a send would refuse, since a half-typed template is not yet a
+/// mistake.
+#[wasm_bindgen]
+pub async fn render_template(payload: JsValue, plugins: JsValue) -> Result<JsValue> {
+    let req: RenderTemplateReq = from_js(payload)?;
+
+    let environment_chain = with_host(|host| {
+        host.queries
+            .connect()
+            .resolve_environments(&req.workspace_id, None, req.environment_id.as_deref())
+            .map_err(js_error)
+    })?;
+
+    let vars = yaak_models::render::make_vars_hashmap(environment_chain);
+    let options = if req.ignore_error == Some(true) {
+        RenderOptions::return_empty()
+    } else {
+        RenderOptions::throw()
+    };
+
+    let rendered =
+        yaak_templates::parse_and_render(&req.template, &vars, &template_callback(plugins), &options)
+            .await
+            .map_err(js_error)?;
+    to_json(rendered).map(|v| JsValue::from_str(v.as_str().unwrap_or_default()))
+}
+
 /* -------------------------------------------------------------------------- */
 /* Blobs                                                                       */
 /* -------------------------------------------------------------------------- */
@@ -21,6 +21,5 @@ yaak-templates = { workspace = true }
 yaak-tls = { workspace = true }

 [dev-dependencies]
-rusqlite = { version = "0.38", features = ["bundled"] }
 tempfile = "3"
 tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }
@@ -190,7 +190,6 @@ impl SendRequestExecutor for ConnectionManagerSendRequestExecutor<'_> {
            .get_client(&HttpConnectionOptions {
                id: self.plugin_context_id.clone(),
                validate_certificates: runtime_config.settings.validate_certificates.value,
-                http_version: runtime_config.settings.http_version.value,
                proxy: runtime_config.proxy.clone(),
                client_certificate,
                dns_overrides: runtime_config.dns_overrides.clone(),
@@ -16,6 +16,7 @@
        "packages/platform",
        "packages/plugin-runtime",
        "packages/plugin-runtime-types",
+        "packages/plugin-sandbox",
        "plugins-external/mcp-server",
        "plugins-external/faker",
        "plugins-external/httpsnippet",
@@ -1470,6 +1471,21 @@
        "node": ">=18.0.0"
      }
    },
+    "node_modules/@jitl/quickjs-ffi-types": {
+      "version": "0.32.0",
+      "resolved": "https://registry.npmjs.org/@jitl/quickjs-ffi-types/-/quickjs-ffi-types-0.32.0.tgz",
+      "integrity": "sha512-v9T+GQpmk43VDJ7d72sf0Nexhk+ArvtUihW27dy7lqAl0zBObFKtSBBIm5RBjwIhE8VwsPPm9PNuvPvNqLWUEg==",
+      "license": "MIT"
+    },
+    "node_modules/@jitl/quickjs-ng-wasmfile-release-sync": {
+      "version": "0.32.0",
+      "resolved": "https://registry.npmjs.org/@jitl/quickjs-ng-wasmfile-release-sync/-/quickjs-ng-wasmfile-release-sync-0.32.0.tgz",
+      "integrity": "sha512-XAX2jjZWWh3M0YaRqi82xMKNW/gkF6mo3MpW3UY2cmVxnQai1JuboVsJQVoLU629iEL4XWvHtO4h5lo7NRnAcg==",
+      "license": "MIT",
+      "dependencies": {
+        "@jitl/quickjs-ffi-types": "0.32.0"
+      }
+    },
    "node_modules/@jridgewell/gen-mapping": {
      "version": "0.3.13",
      "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz",
@@ -5638,6 +5654,10 @@
      "resolved": "packages/plugin-runtime",
      "link": true
    },
+    "node_modules/@yaakapp-internal/plugin-sandbox": {
+      "resolved": "packages/plugin-sandbox",
+      "link": true
+    },
    "node_modules/@yaakapp-internal/plugins": {
      "resolved": "crates/yaak-plugins",
      "link": true
@@ -12799,6 +12819,15 @@
      ],
      "license": "MIT"
    },
+    "node_modules/quickjs-emscripten-core": {
+      "version": "0.32.0",
+      "resolved": "https://registry.npmjs.org/quickjs-emscripten-core/-/quickjs-emscripten-core-0.32.0.tgz",
+      "integrity": "sha512-QFnPfjFey8EqknSrSxe1hZrf1/8z7/6s1QzGOmKo6++02r7QRRX7ZoyNaZh7JuVjWsVW87KnQrbZqnHkOAzUyg==",
+      "license": "MIT",
+      "dependencies": {
+        "@jitl/quickjs-ffi-types": "0.32.0"
+      }
+    },
    "node_modules/railroad-diagrams": {
      "version": "1.0.0",
      "resolved": "https://registry.npmjs.org/railroad-diagrams/-/railroad-diagrams-1.0.0.tgz",
@@ -15859,6 +15888,17 @@
      "dev": true,
      "license": "MIT"
    },
+    "packages/plugin-sandbox": {
+      "name": "@yaakapp-internal/plugin-sandbox",
+      "version": "1.0.0",
+      "dependencies": {
+        "@jitl/quickjs-ng-wasmfile-release-sync": "^0.32.0",
+        "quickjs-emscripten-core": "^0.32.0"
+      },
+      "devDependencies": {
+        "esbuild": "^0.28.0"
+      }
+    },
    "packages/tailwind-config": {
      "name": "@yaakapp-internal/tailwind-config",
      "version": "1.0.0"
@@ -15,6 +15,7 @@
    "packages/platform",
    "packages/plugin-runtime",
    "packages/plugin-runtime-types",
+    "packages/plugin-sandbox",
    "plugins-external/mcp-server",
    "plugins-external/faker",
    "plugins-external/httpsnippet",
@@ -2,3 +2,5 @@ export * from "./debounce";
 export * from "./eagerDebounceAsync";
 export * from "./formatSize";
 export * from "./templateFunction";
+export * from "./pluginForms";
+export * from "./responseBody";
@@ -0,0 +1,403 @@
+/**
+ * `ctx`, built once for every runtime that has one. A runtime supplies only how
+ * a payload reaches its host.
+ *
+ * `stream` and `form` are optional because they are the two places a host
+ * genuinely differs: both need a conversation rather than one reply.
+ */
+
+import type {
+  CallPromptFormDynamicArgs,
+  Context,
+  DynamicPromptFormArg,
+} from "@yaakapp/api";
+import type {
+  DeleteKeyValueResponse,
+  DeleteModelResponse,
+  FindHttpResponsesResponse,
+  Folder,
+  FormInput,
+  GetCookieValueRequest,
+  GetCookieValueResponse,
+  GetHttpRequestByIdResponse,
+  GetHttpResponseBodyInfoResponse,
+  GetKeyValueResponse,
+  HttpRequest,
+  HttpResponse,
+  InternalEventPayload,
+  ListCookieNamesResponse,
+  ListFoldersResponse,
+  ListHttpRequestsRequest,
+  ListHttpRequestsResponse,
+  ListOpenWorkspacesResponse,
+  PluginContext,
+  PromptFormResponse,
+  PromptTextResponse,
+  ReadHttpResponseBodyChunkResponse,
+  RenderGrpcRequestResponse,
+  RenderHttpRequestResponse,
+  SendHttpRequestResponse,
+  TemplateRenderRequest,
+  TemplateRenderResponse,
+  UpsertModelResponse,
+  WindowInfoResponse,
+} from "@yaakapp-internal/plugins";
+import { applyDynamicFormInput, stripDynamicCallbacks } from "./pluginForms";
+import { createResponseBody, decodeBase64Chunk } from "./responseBody";
+import { applyFormInputDefaults } from "./templateFunction";
+
+export interface PluginTransport {
+  request(
+    context: PluginContext,
+    payload: InternalEventPayload,
+  ): Promise<Record<string, unknown>>;
+
+  notify(context: PluginContext, payload: InternalEventPayload): void;
+
+  /** Send once, keep receiving. Windows report navigation until they close. */
+  stream?(
+    context: PluginContext,
+    payload: InternalEventPayload,
+    onReply: (payload: InternalEventPayload) => void,
+  ): void;
+
+  /**
+   * A form that may re-render before it settles: `onChange` answers with the
+   * form to show next. Without it, a form is drawn once from its defaults.
+   */
+  form?(
+    context: PluginContext,
+    payload: InternalEventPayload,
+    onChange: (
+      values: Record<string, unknown>,
+    ) => Promise<InternalEventPayload | null>,
+  ): Promise<PromptFormResponse>;
+}
+
+/** `bodyPath` names a file on a host's disk; plugins address bodies by id. */
+function forPlugin(httpResponse: HttpResponse): HttpResponse {
+  const { bodyPath: _bodyPath, ...rest } = httpResponse as HttpResponse & {
+    bodyPath?: string | null;
+  };
+  return rest;
+}
+
+export function createPluginContext(
+  transport: PluginTransport,
+  context: PluginContext,
+): Context {
+  const send = <T>(payload: InternalEventPayload): Promise<T> =>
+    transport.request(context, payload) as Promise<T>;
+
+  const storedBody = async (responseId: string) => {
+    const bodyInfo = () =>
+      send<GetHttpResponseBodyInfoResponse>({
+        type: "get_http_response_body_info_request",
+        responseId,
+      });
+    const info = await bodyInfo();
+
+    return createResponseBody(
+      {
+        responseId,
+        contentLength: info.contentLength,
+        contentType: info.contentType ?? null,
+        complete: info.complete,
+      },
+      async (offset, length) => {
+        const chunk = await send<ReadHttpResponseBodyChunkResponse>({
+          type: "read_http_response_body_chunk_request",
+          responseId,
+          offset,
+          length,
+        });
+        return decodeBase64Chunk(chunk.data);
+      },
+      { refresh: bodyInfo },
+    );
+  };
+
+  const windowInfo = async () => {
+    if (context.label == null) {
+      throw new Error("Can't get window context without an active window");
+    }
+    return send<WindowInfoResponse>({ type: "window_info_request", label: context.label });
+  };
+
+  const ctx: Context = {
+    clipboard: {
+      copyText: async (text) => {
+        await send({ type: "copy_text_request", text });
+      },
+    },
+    toast: {
+      show: async (args) => {
+        await send({
+          type: "show_toast_request",
+          // Defaulted here because null and undefined both become None in Rust.
+          timeout: args.timeout === undefined ? 5000 : args.timeout,
+          ...args,
+        });
+      },
+    },
+    window: {
+      requestId: async () => (await windowInfo()).requestId,
+      workspaceId: async () => (await windowInfo()).workspaceId,
+      environmentId: async () => (await windowInfo()).environmentId,
+      openUrl: async ({ onNavigate, onClose, ...args }) => {
+        if (transport.stream == null) {
+          throw new Error("ctx.window.openUrl is not available in this runtime");
+        }
+        args.label = args.label || `${Math.random()}`;
+        transport.stream(context, { type: "open_window_request", ...args }, (event) => {
+          if (event.type === "window_navigate_event") onNavigate?.(event);
+          else if (event.type === "window_close_event") onClose?.();
+        });
+        return {
+          close: () => {
+            transport.notify(context, { type: "close_window_request", label: args.label });
+          },
+        };
+      },
+      openExternalUrl: async (url) => {
+        await send({ type: "open_external_url_request", url });
+      },
+    },
+    prompt: {
+      text: async (args) => {
+        const reply = await send<PromptTextResponse>({ type: "prompt_text_request", ...args });
+        return reply.value;
+      },
+      form: async (args) => {
+        // Inputs may compute from the values entered so far, and a function
+        // cannot cross to a host.
+        const resolve = async (values: Record<string, unknown>) => {
+          const callArgs: CallPromptFormDynamicArgs = { values } as CallPromptFormDynamicArgs;
+          const resolved = await applyDynamicFormInput(
+            ctx,
+            args.inputs as DynamicPromptFormArg[],
+            callArgs,
+          );
+          return stripDynamicCallbacks(resolved) as FormInput[];
+        };
+
+        const initial = await resolve(applyFormInputDefaults(args.inputs, {}));
+        const payload: InternalEventPayload = {
+          type: "prompt_form_request",
+          ...args,
+          inputs: initial,
+        };
+
+        if (transport.form == null) {
+          const reply = await send<PromptFormResponse>(payload);
+          return reply.values;
+        }
+
+        const reply = await transport.form(context, payload, async (values) => {
+          // Fired on mount, before there is anything to recompute from.
+          if (values == null || Object.keys(values).length === 0) return null;
+          return { type: "prompt_form_request", ...args, inputs: await resolve(values) };
+        });
+        return reply.values;
+      },
+    },
+    httpResponse: {
+      find: async (args) => {
+        const { httpResponses } = await send<FindHttpResponsesResponse>({
+          type: "find_http_responses_request",
+          ...args,
+        });
+        return httpResponses.map(forPlugin);
+      },
+      body: ({ responseId }) => storedBody(responseId),
+    },
+    grpcRequest: {
+      render: async (args) => {
+        const { grpcRequest } = await send<RenderGrpcRequestResponse>({
+          type: "render_grpc_request_request",
+          ...args,
+        });
+        return grpcRequest;
+      },
+    },
+    httpRequest: {
+      getById: async (args) => {
+        const { httpRequest } = await send<GetHttpRequestByIdResponse>({
+          type: "get_http_request_by_id_request",
+          ...args,
+        });
+        return httpRequest;
+      },
+      send: async (args) => {
+        const { httpResponse, body } = await send<SendHttpRequestResponse>({
+          type: "send_http_request_request",
+          ...args,
+        });
+
+        // A send with no request behind it saves nothing, so the reply carries
+        // the only copy of its body.
+        if (body == null) {
+          return { httpResponse: forPlugin(httpResponse), body: await storedBody(httpResponse.id) };
+        }
+
+        const bytes = decodeBase64Chunk(body);
+        return {
+          httpResponse: forPlugin(httpResponse),
+          body: createResponseBody(
+            {
+              responseId: httpResponse.id,
+              contentLength: bytes.byteLength,
+              contentType:
+                httpResponse.headers.find((h) => h.name.toLowerCase() === "content-type")?.value ??
+                null,
+              // The host waited for the whole send before replying.
+              complete: true,
+            },
+            async (offset, length) => bytes.slice(offset, offset + length),
+          ),
+        };
+      },
+      render: async (args) => {
+        const { httpRequest } = await send<RenderHttpRequestResponse>({
+          type: "render_http_request_request",
+          ...args,
+        });
+        return httpRequest;
+      },
+      list: async (args?: { folderId?: string }) => {
+        const payload: InternalEventPayload = {
+          type: "list_http_requests_request",
+          folderId: args?.folderId,
+        } satisfies ListHttpRequestsRequest & { type: "list_http_requests_request" };
+        const { httpRequests } = await send<ListHttpRequestsResponse>(payload);
+        return httpRequests;
+      },
+      create: async (args) => {
+        const response = await send<UpsertModelResponse>({
+          type: "upsert_model_request",
+          model: { name: "", method: "GET", ...args, id: "", model: "http_request" },
+        } as InternalEventPayload);
+        return response.model as HttpRequest;
+      },
+      update: async (args) => {
+        const response = await send<UpsertModelResponse>({
+          type: "upsert_model_request",
+          model: { model: "http_request", ...args },
+        } as InternalEventPayload);
+        return response.model as HttpRequest;
+      },
+      delete: async (args) => {
+        const response = await send<DeleteModelResponse>({
+          type: "delete_model_request",
+          model: "http_request",
+          id: args.id,
+        } as InternalEventPayload);
+        return response.model as HttpRequest;
+      },
+    },
+    folder: {
+      list: async () => {
+        const { folders } = await send<ListFoldersResponse>({ type: "list_folders_request" });
+        return folders;
+      },
+      getById: async (args: { id: string }) => {
+        const { folders } = await send<ListFoldersResponse>({ type: "list_folders_request" });
+        return folders.find((f) => f.id === args.id) ?? null;
+      },
+      create: async ({ name, ...args }) => {
+        const response = await send<UpsertModelResponse>({
+          type: "upsert_model_request",
+          model: { ...args, name: name ?? "", id: "", model: "folder" },
+        } as InternalEventPayload);
+        return response.model as Folder;
+      },
+      update: async (args) => {
+        const response = await send<UpsertModelResponse>({
+          type: "upsert_model_request",
+          model: { model: "folder", ...args },
+        } as InternalEventPayload);
+        return response.model as Folder;
+      },
+      delete: async (args: { id: string }) => {
+        const response = await send<DeleteModelResponse>({
+          type: "delete_model_request",
+          model: "folder",
+          id: args.id,
+        } as InternalEventPayload);
+        return response.model as Folder;
+      },
+    },
+    cookies: {
+      getValue: async (args: GetCookieValueRequest) => {
+        const { value } = await send<GetCookieValueResponse>({
+          type: "get_cookie_value_request",
+          ...args,
+        });
+        return value;
+      },
+      listNames: async () => {
+        const { names } = await send<ListCookieNamesResponse>({ type: "list_cookie_names_request" });
+        return names;
+      },
+    },
+    templates: {
+      render: async (args: TemplateRenderRequest) => {
+        const result = await send<TemplateRenderResponse>({
+          type: "template_render_request",
+          ...args,
+        });
+        // oxlint-disable-next-line no-explicit-any -- the caller knows its own shape
+        return result.data as any;
+      },
+    },
+    store: {
+      get: async <T>(key: string) => {
+        const result = await send<GetKeyValueResponse>({ type: "get_key_value_request", key });
+        return result.value ? (JSON.parse(result.value) as T) : undefined;
+      },
+      set: async <T>(key: string, value: T) => {
+        await send<GetKeyValueResponse>({
+          type: "set_key_value_request",
+          key,
+          value: JSON.stringify(value),
+        });
+      },
+      delete: async (key: string) => {
+        const result = await send<DeleteKeyValueResponse>({
+          type: "delete_key_value_request",
+          key,
+        });
+        return result.deleted;
+      },
+    },
+    plugin: {
+      reload: () => {
+        transport.notify(context, { type: "reload_response", silent: true });
+      },
+    },
+    workspace: {
+      list: async () => {
+        const response = await send<ListOpenWorkspacesResponse>({
+          type: "list_open_workspaces_request",
+        });
+        return response.workspaces.map((w) => {
+          type WorkspaceInfoInternal = typeof w & { label?: string };
+          return {
+            id: w.id,
+            name: w.name,
+            // Kept for routing, hidden from plugin authors.
+            _label: (w as WorkspaceInfoInternal).label as string,
+          };
+        });
+      },
+      withContext: (handle: { id: string; name: string; _label?: string }) =>
+        createPluginContext(transport, {
+          ...context,
+          label: handle._label || null,
+          workspaceId: handle.id,
+        }),
+    },
+  };
+
+  return ctx;
+}
@@ -4,10 +4,12 @@ import type {
  DynamicAuthenticationArg,
  DynamicPromptFormArg,
  DynamicTemplateFunctionArg,
+  TemplateFunctionPlugin,
 } from "@yaakapp/api";
 import type {
  CallHttpAuthenticationActionArgs,
  CallTemplateFunctionArgs,
+  FormInput,
 } from "@yaakapp-internal/plugins";

 type AnyDynamicArg = DynamicTemplateFunctionArg | DynamicAuthenticationArg | DynamicPromptFormArg;
@@ -73,3 +75,33 @@ export async function applyDynamicFormInput(
  }
  return resolvedArgs;
 }
+
+/** What a host receives has to be data all the way down. */
+export function stripDynamicCallbacks(inputs: { dynamic?: unknown }[]): FormInput[] {
+  return inputs.map((input) => {
+    // oxlint-disable-next-line no-explicit-any -- stripping dynamic from union type
+    const { dynamic: _dynamic, ...rest } = input as any;
+    if ("inputs" in rest && Array.isArray(rest.inputs)) {
+      rest.inputs = stripDynamicCallbacks(rest.inputs);
+    }
+    return rest as FormInput;
+  });
+}
+
+/** Select options used to carry `name` where they now carry `label`. */
+export function migrateTemplateFunctionSelectOptions(
+  f: TemplateFunctionPlugin,
+): TemplateFunctionPlugin {
+  const migratedArgs = f.args.map((a) => {
+    if (a.type === "select") {
+      type LegacyOption = { label?: string; value: string; name?: string };
+      a.options = a.options.map((o) => {
+        const legacy = o as LegacyOption;
+        return { label: legacy.label ?? legacy.name ?? "", value: legacy.value };
+      });
+    }
+    return a;
+  });
+
+  return { ...f, args: migratedArgs };
+}
@@ -17,15 +17,22 @@
 * up here as a type error rather than as a runtime surprise.
 */

+import type { HttpRequest } from "@yaakapp-internal/models";
+import type { JsonPrimitive } from "@yaakapp-internal/plugins";
 import type { RpcSchema } from "@yaakapp-internal/rpc-schema";
 import type { CapabilityName, RpcPayload } from "../types";
 import type { WorkerConnection } from "./connection";
 import { unsupported } from "./errors";
+import type { WebPlugins } from "./plugins";
 import { sendHttpRequest } from "./send";

 export type AppCmd = keyof RpcSchema;

-type Handler = (payload: RpcPayload, db: WorkerConnection) => Promise<unknown>;
+type Handler = (
+  payload: RpcPayload,
+  db: WorkerConnection,
+  plugins: WebPlugins,
+) => Promise<unknown>;

 /** Placeholder shown wherever the desktop would show a real filesystem path. */
 const NO_PATH = "";
@@ -41,6 +48,31 @@ function text(payload: RpcPayload, key: string): string {
  return typeof value === "string" ? value : "";
 }

+/** Form values as the plugin protocol carries them. */
+function values(payload: RpcPayload, key = "values"): Record<string, JsonPrimitive> {
+  const value = payload[key];
+  return value != null && typeof value === "object"
+    ? (value as Record<string, JsonPrimitive>)
+    : {};
+}
+
+/**
+ * The id a plugin keys its stored state on.
+ *
+ * The desktop hashes the id of whichever model the configuration was read from,
+ * so two requests inheriting one folder's authentication share a token cache.
+ * The preview paths here have no such model in hand and pass what they were
+ * given, which is enough to be stable per form.
+ */
+function contextId(payload: RpcPayload): string {
+  const model = payload.model;
+  if (model != null && typeof model === "object" && "id" in model) {
+    const id = (model as { id?: unknown }).id;
+    return typeof id === "string" ? id : "";
+  }
+  return "";
+}
+
 /**
 * Commands this host answers itself.
 *
@@ -73,10 +105,16 @@ const HANDLERS: Partial<Record<AppCmd, Handler>> = {

  // The tab renders and stores; a stateless server puts the bytes on the wire.
  // See send.ts for the whole shape of it.
-  cmd_send_http_request: (payload, db) => {
+  cmd_send_http_request: (payload, db, plugins) => {
    const requestId = str(payload, "requestId");
    if (requestId == null) throw new Error("cmd_send_http_request needs a requestId");
-    return sendHttpRequest(db, requestId, str(payload, "environmentId"), str(payload, "cookieJarId"));
+    return sendHttpRequest(
+      db,
+      plugins,
+      requestId,
+      str(payload, "environmentId"),
+      str(payload, "cookieJarId"),
+    );
  },

  /* -------------------------------- app ---------------------------------- */
@@ -146,22 +184,67 @@ const HANDLERS: Partial<Record<AppCmd, Handler>> = {
   * Both of these are polled once a second until they answer with something, so
   * an empty list is not a quiet no — it is a poll that never stops.
   *
-   * The auth list names what Yaak actually offers, so the picker tells the
-   * truth about the product even though the form behind each entry stays empty
-   * until plugins run here. Template functions get the opposite treatment: one
-   * provider contributing no functions. That settles the poll while putting
-   * nothing in the autocomplete, which is the honest answer — a function the
-   * user could insert but nothing could evaluate would be worse than none.
+   * Both now answer from the plugins actually loaded in the sandbox, which is
+   * the only answer that stays true: an authentication method in the picker
+   * that no loaded plugin can apply would be a promise this host cannot keep,
+   * and a template function offered in the autocomplete that nothing can
+   * evaluate would be worse than none.
   */
-  async cmd_get_http_authentication_summaries() {
-    return HTTP_AUTHENTICATION_SUMMARIES;
+  async cmd_get_http_authentication_summaries(_payload, _db, plugins) {
+    return plugins.httpAuthenticationSummaries();
  },
-  async cmd_template_function_summaries() {
-    return [{ pluginRefId: "web", functions: [] }];
+  async cmd_template_function_summaries(_payload, _db, plugins) {
+    return plugins.templateFunctionSummaries();
  },

-  async cmd_get_http_authentication_config() {
-    return { args: [], pluginRefId: "web" };
+  async cmd_get_http_authentication_config(payload, _db, plugins) {
+    const authName = str(payload, "authName");
+    const config =
+      authName == null
+        ? null
+        : await plugins.httpAuthenticationConfig(authName, values(payload), contextId(payload));
+    return config ?? { args: [], actions: [], pluginRefId: "web" };
+  },
+
+  async cmd_template_function_config(payload, _db, plugins) {
+    const name = str(payload, "functionName") ?? str(payload, "name");
+    if (name == null) return null;
+    return plugins.templateFunctionConfig(name, values(payload), contextId(payload));
+  },
+
+  async cmd_call_http_authentication_action(payload, _db, plugins) {
+    const authName = str(payload, "authName");
+    if (authName == null) return null;
+    const index = payload.actionIndex;
+    await plugins.callHttpAuthenticationAction(
+      authName,
+      typeof index === "number" ? index : 0,
+      values(payload),
+      contextId(payload),
+    );
+    return null;
+  },
+
+  /**
+   * Turn a pasted cURL command into a request.
+   *
+   * Routed through the same importer the desktop uses, in the sandbox, which
+   * is why this is a handler and no longer a refusal. The reshaping afterwards
+   * matches `cmd_curl_to_request` in crates/yaak-commands: the importer names a
+   * workspace of its own invention and mints an id, and both belong to the
+   * caller instead.
+   */
+  async cmd_curl_to_request(payload, _db, plugins) {
+    const resources = await plugins.import(text(payload, "command"));
+    const imported = resources?.httpRequests?.[0];
+    if (imported == null) {
+      throw new Error("Failed to import cURL command");
+    }
+    return {
+      ...imported,
+      id: "",
+      workspaceId: str(payload, "workspaceId") ?? imported.workspaceId,
+    } as HttpRequest;
  },

  async cmd_format_json(payload) {
@@ -176,13 +259,19 @@ const HANDLERS: Partial<Record<AppCmd, Handler>> = {
  },

  /**
-   * Rendering resolves variables and calls template functions, and the
-   * functions live in plugins. Handing the template back unrendered is what the
-   * preview then shows — the raw `${[...]}`, which is at least the thing the
-   * user typed rather than a wrong value.
+   * Resolve variables and call template functions, in the engine, exactly as
+   * `cmd_render_template` does on the desktop. The functions come back out to
+   * the sandbox as the render reaches them — see `templateBridge` in worker.ts.
   */
-  async cmd_render_template(payload) {
-    return text(payload, "template");
+  async cmd_render_template(payload, db) {
+    const workspaceId = str(payload, "workspaceId");
+    if (workspaceId == null) return text(payload, "template");
+    return db.renderTemplate({
+      template: text(payload, "template"),
+      workspaceId,
+      environmentId: str(payload, "environmentId"),
+      ignoreError: payload.ignoreError === true,
+    });
  },

  /* ------------------------------- bodies -------------------------------- */
@@ -224,21 +313,6 @@ const HANDLERS: Partial<Record<AppCmd, Handler>> = {
  },
 };

-/**
- * The auth methods Yaak ships as plugins today (plugins/auth-*). Listed so the
- * picker is truthful about the product; choosing one currently yields an empty
- * config form, because the plugin that defines the form isn't running.
- */
-const HTTP_AUTHENTICATION_SUMMARIES = [
-  { name: "apikey", label: "API Key", shortLabel: "API Key" },
-  { name: "aws", label: "AWS SigV4", shortLabel: "AWS" },
-  { name: "basic", label: "Basic Auth", shortLabel: "Basic" },
-  { name: "bearer", label: "Bearer Token", shortLabel: "Bearer" },
-  { name: "jwt", label: "JWT Bearer", shortLabel: "JWT" },
-  { name: "ntlm", label: "NTLM", shortLabel: "NTLM" },
-  { name: "oauth1", label: "OAuth 1.0", shortLabel: "OAuth 1" },
-  { name: "oauth2", label: "OAuth 2.0", shortLabel: "OAuth 2" },
-];

 /**
 * Commands this host declines, each with the reason a user would need.
@@ -253,7 +327,6 @@ const DECLINED: Partial<Record<AppCmd, [reason: string, capability: CapabilityNa
  // ones nothing stores, used for GraphQL introspection — take the same road but
  // return the body inline; not wired yet.
  cmd_send_ephemeral_request: ["Sending unsaved requests isn't available in the browser yet", null],
-  cmd_curl_to_request: ["Importing from cURL needs a plugin, which this host doesn't run", null],

  // Protocols that need a real socket.
  cmd_grpc_reflect: ["gRPC isn't available in the browser", "grpc"],
@@ -267,7 +340,6 @@ const DECLINED: Partial<Record<AppCmd, [reason: string, capability: CapabilityNa
  // Anything that needs files the page can't reach.
  cmd_import_data: ["Importing from a file needs a filesystem, which a browser tab has no", "localFiles"],
  cmd_import_url: ["Importing from a URL needs the Yaak server, which isn't available yet", null],
-  cmd_commit_import: ["Importing needs a plugin, which this host doesn't run", null],
  cmd_export_data: ["Exporting to a file isn't available in the browser yet", "localFiles"],
  cmd_save_response: ["Saving a response to disk isn't available in the browser", "localFiles"],
  cmd_save_base64_to_binary: ["Saving to disk isn't available in the browser", "localFiles"],
@@ -296,14 +368,12 @@ const DECLINED: Partial<Record<AppCmd, [reason: string, capability: CapabilityNa
  cmd_plugins_uninstall: ["Plugins aren't available in the browser yet", "plugins"],
  cmd_plugins_updates: ["Plugins aren't available in the browser yet", "plugins"],
  cmd_plugins_update_all: ["Plugins aren't available in the browser yet", "plugins"],
-  cmd_template_function_config: ["Template functions come from plugins, which this host doesn't run", "plugins"],
  cmd_template_tokens_to_string: ["Template functions come from plugins, which this host doesn't run", "plugins"],
  cmd_call_http_request_action: ["Plugins aren't available in the browser yet", "plugins"],
  cmd_call_websocket_request_action: ["Plugins aren't available in the browser yet", "plugins"],
  cmd_call_grpc_request_action: ["Plugins aren't available in the browser yet", "plugins"],
  cmd_call_workspace_action: ["Plugins aren't available in the browser yet", "plugins"],
  cmd_call_folder_action: ["Plugins aren't available in the browser yet", "plugins"],
-  cmd_call_http_authentication_action: ["Plugins aren't available in the browser yet", "plugins"],

  cmd_send_feedback: ["Feedback goes through the desktop app for now", null],
 };
@@ -330,9 +400,10 @@ export async function runCommand(
  cmd: string,
  payload: RpcPayload,
  db: WorkerConnection,
+  plugins: WebPlugins,
 ): Promise<unknown> {
  const handler = HANDLERS[cmd as AppCmd];
-  if (handler != null) return handler(payload, db);
+  if (handler != null) return handler(payload, db, plugins);

  const declined = DECLINED[cmd as AppCmd];
  if (declined != null) throw unsupported(cmd, declined[0], declined[1]);
@@ -50,6 +50,9 @@ export class WorkerConnection {
  /** True once the worker has said anything at all. */
  private heard = false;

+  /** Unset until the sandbox is up; a render before then gets a refusal. */
+  private templateFunctions: ((name: string, args: string) => Promise<string>) | null = null;
+
  constructor() {
    // Both are required and neither is faked. Without a shared worker every
    // tab would need its own SQLite over the same pages; without Web Locks
@@ -147,6 +150,9 @@ export class WorkerConnection {
      case "event":
        this.deliver(message.event, message.payload);
        return;
+      case "template_function":
+        void this.runTemplateFunction(message.id, message.name, message.args);
+        return;
    }
  }

@@ -159,6 +165,34 @@ export class WorkerConnection {
    });
  }

+  setTemplateFunctionHandler(handler: (name: string, args: string) => Promise<string>): void {
+    this.templateFunctions = handler;
+  }
+
+  private async runTemplateFunction(id: number, name: string, args: string): Promise<void> {
+    if (this.templateFunctions == null) {
+      this.post({
+        type: "template_function_result",
+        id,
+        error: `The template function \`${name}\` needs a plugin, and none are loaded yet`,
+      });
+      return;
+    }
+    try {
+      this.post({
+        type: "template_function_result",
+        id,
+        value: await this.templateFunctions(name, args),
+      });
+    } catch (err) {
+      this.post({
+        type: "template_function_result",
+        id,
+        error: err instanceof Error ? err.message : String(err),
+      });
+    }
+  }
+
  rpc<T>(cmd: string, payload: unknown): Promise<T> {
    return this.request<T>((id) => ({ type: "rpc", id, cmd, payload, label: this.label }));
  }
@@ -168,6 +202,11 @@ export class WorkerConnection {
    return this.request<T>((id) => ({ type: "prepare_http_send", id, payload }));
  }

+  /** See `render_template` in crates/yaak-wasm. */
+  renderTemplate(payload: unknown): Promise<string> {
+    return this.request<string>((id) => ({ type: "render_template", id, payload }));
+  }
+
  async blobGet(blobId: string): Promise<Uint8Array<ArrayBuffer> | null> {
    const buf = await this.request<ArrayBuffer | null>((id) => ({ type: "blob_get", id, blobId }));
    return buf == null ? null : new Uint8Array(buf);
@@ -28,6 +28,7 @@ import type {
 import { commandSupport, runCommand } from "./commands";
 import { WorkerConnection } from "./connection";
 import { unsupported } from "./errors";
+import { WebPlugins } from "./plugins";
 import { requestPersistence } from "./storage";

 /** What this host can do, reported honestly. */
@@ -60,7 +61,9 @@ function capabilitiesFor(): PlatformCapabilities {
    // The browser already zooms the page, on the same keys, and remembers it
    // per site. The app stays out of the way.
    interfaceZoom: false,
-    plugins: false,
+    // Plugins run in a QuickJS sandbox, but only the bundled set: there is no
+    // installing them, so the plugin manager stays unavailable and says so.
+    plugins: true,
    encryption: false,
    updater: false,
    // Reading needs a permission prompt at first paint, which is a bad ask for
@@ -160,8 +163,12 @@ function createWindow(db: WorkerConnection): PlatformWindow {

 export function createWebPlatform(): Platform {
  const db = new WorkerConnection();
+  const plugins = new WebPlugins(db);
  const capabilities = capabilitiesFor();

+  // Registered before anything can render, not inside the first send.
+  db.setTemplateFunctionHandler((name, args) => plugins.callTemplateFunction(name, args));
+
  // Without this, IndexedDB is best-effort storage and a browser reclaiming
  // space may drop someone's workspaces. Asking is all we can do, and there is
  // nothing useful to do about a refusal.
@@ -231,7 +238,7 @@ export function createWebPlatform(): Platform {
      // `plugin:` commands are Tauri host plugins, not engine commands, and
      // never reached the router even on the desktop.
      if (cmd.startsWith("plugin:")) return hostPluginCommand<T>(cmd, payload);
-      return runCommand(cmd, payload ?? {}, db) as Promise<T>;
+      return runCommand(cmd, payload ?? {}, db, plugins) as Promise<T>;
    },

    async rpcStream<T, M>(
@@ -244,7 +251,7 @@ export function createWebPlatform(): Platform {
      const streamId = crypto.randomUUID();
      const unlisten = db.listen(`stream_${streamId}`, (p) => onMessage(p as M));
      try {
-        const result = (await runCommand(cmd, { ...payload, streamId }, db)) as T;
+        const result = (await runCommand(cmd, { ...payload, streamId }, db, plugins)) as T;
        return { result, unlisten };
      } catch (err) {
        unlisten();
@@ -0,0 +1,298 @@
+/**
+ * Keeps a sandbox, loads the bundled plugins into it, routes by what each one
+ * contributes, and answers the `ctx` calls they make. `hostRequest` below is
+ * the whole of what a plugin can do to the world here.
+ */
+
+import { PluginSandbox, type PluginSummary } from "@yaakapp-internal/plugin-sandbox";
+import type {
+  GetHttpAuthenticationConfigResponse,
+  GetHttpAuthenticationSummaryResponse,
+  GetTemplateFunctionConfigResponse,
+  GetTemplateFunctionSummaryResponse,
+  ImportResources,
+  InternalEventPayload,
+  JsonPrimitive,
+  PluginContext,
+} from "@yaakapp-internal/plugins";
+import type { WorkerConnection } from "./connection";
+import { SANDBOX_PLUGINS } from "./sandboxPlugins.generated";
+
+type KeyValueRequest = { key: string };
+
+export interface AppliedAuthentication {
+  setHeaders?: { name: string; value: string }[] | null;
+  setQueryParameters?: { name: string; value: string }[] | null;
+}
+
+export class WebPlugins {
+  private readonly db: WorkerConnection;
+  private sandbox: PluginSandbox | null = null;
+  private loading: Promise<void> | null = null;
+
+  private readonly byTemplateFunction = new Map<string, string>();
+  private readonly byAuthName = new Map<string, string>();
+  private readonly importers: string[] = [];
+  private readonly summaries = new Map<string, PluginSummary>();
+
+  constructor(db: WorkerConnection) {
+    this.db = db;
+  }
+
+  /**
+   * Called from every entry point rather than at construction, so a session
+   * that never touches a plugin never pays for QuickJS.
+   */
+  ready(): Promise<void> {
+    this.loading ??= this.start();
+    return this.loading;
+  }
+
+  private async start(): Promise<void> {
+    const sandbox = new PluginSandbox({
+      onHostRequest: (envelope) => this.hostRequest(envelope),
+      onLog: ({ pluginRefId, level, message }) => {
+        // Prefixed, or a plugin's console output blames the app's own code.
+        const write = level === "error" ? console.error : console.log;
+        write(`[plugin ${pluginRefId}] ${message}`);
+      },
+    });
+    this.sandbox = sandbox;
+
+    await Promise.all(
+      SANDBOX_PLUGINS.map(async ({ name, source }) => {
+        try {
+          const summary = await sandbox.load(name, source);
+          this.summaries.set(name, summary);
+          for (const fn of summary.templateFunctions) this.byTemplateFunction.set(fn, name);
+          if (summary.authentication != null) this.byAuthName.set(summary.authentication, name);
+          if (summary.importer) this.importers.push(name);
+        } catch (err) {
+          // One bad bundle should cost its own features and nothing else.
+          console.error(`Failed to load plugin \`${name}\``, err);
+        }
+      }),
+    );
+  }
+
+  /* ------------------------------ what exists ------------------------------ */
+
+  async templateFunctionSummaries(): Promise<GetTemplateFunctionSummaryResponse[]> {
+    await this.ready();
+    return this.gather("get_template_function_summary_request", this.summaries.keys());
+  }
+
+  async httpAuthenticationSummaries(): Promise<GetHttpAuthenticationSummaryResponse[]> {
+    await this.ready();
+    return this.gather("get_http_authentication_summary_request", this.byAuthName.values());
+  }
+
+  /** One broken plugin must not empty the picker for the others. */
+  private async gather<T>(type: string, ids: Iterable<string>): Promise<T[]> {
+    const replies = await Promise.all(
+      Array.from(ids).map(async (id): Promise<{ type: string } | null> => {
+        try {
+          return await this.dispatch(id, { type } as InternalEventPayload);
+        } catch (err) {
+          console.error(`Plugin \`${id}\` failed to answer \`${type}\``, err);
+          return null;
+        }
+      }),
+    );
+    return replies.filter((r) => r != null && r.type !== "empty_response") as T[];
+  }
+
+  /* -------------------------------- calling -------------------------------- */
+
+  async templateFunctionConfig(
+    name: string,
+    values: Record<string, JsonPrimitive>,
+    contextId: string,
+  ): Promise<GetTemplateFunctionConfigResponse | null> {
+    await this.ready();
+    const id = this.byTemplateFunction.get(name);
+    if (id == null) return null;
+    return this.dispatch(id, {
+      type: "get_template_function_config_request",
+      contextId,
+      name,
+      values,
+    } as InternalEventPayload);
+  }
+
+  /**
+   * What the engine's render calls back into. A function nothing provides is a
+   * throw naming it, not an empty string: a request sent with a silently blank
+   * token is worse than one that refuses to be sent.
+   */
+  async callTemplateFunction(name: string, argsJson: string): Promise<string> {
+    await this.ready();
+    const id = this.byTemplateFunction.get(name);
+    if (id == null) {
+      throw new Error(`No plugin provides the template function \`${name}\``);
+    }
+
+    const values = JSON.parse(argsJson) as Record<string, JsonPrimitive>;
+    const reply = await this.dispatch<{ value: string | null; error?: string | null }>(id, {
+      type: "call_template_function_request",
+      name,
+      args: { purpose: "send", values },
+    } as InternalEventPayload);
+
+    if (reply.error) throw new Error(reply.error);
+    return reply.value ?? "";
+  }
+
+  async httpAuthenticationConfig(
+    authName: string,
+    values: Record<string, JsonPrimitive>,
+    contextId: string,
+  ): Promise<GetHttpAuthenticationConfigResponse | null> {
+    await this.ready();
+    const id = this.byAuthName.get(authName);
+    if (id == null) return null;
+    return this.dispatch(id, {
+      type: "get_http_authentication_config_request",
+      contextId,
+      values,
+    } as InternalEventPayload);
+  }
+
+  async callHttpAuthenticationAction(
+    authName: string,
+    index: number,
+    values: Record<string, JsonPrimitive>,
+    contextId: string,
+  ): Promise<void> {
+    await this.ready();
+    const id = this.byAuthName.get(authName);
+    if (id == null) throw new Error(`No plugin provides \`${authName}\` authentication`);
+    await this.dispatch(id, {
+      type: "call_http_authentication_action_request",
+      index,
+      pluginRefId: id,
+      args: { contextId, values },
+    } as InternalEventPayload);
+  }
+
+
+  async applyHttpAuthentication(
+    authName: string,
+    request: {
+      contextId: string;
+      values: Record<string, JsonPrimitive>;
+      method: string;
+      url: string;
+      headers: { name: string; value: string }[];
+      body: string | null;
+    },
+  ): Promise<AppliedAuthentication> {
+    await this.ready();
+    const id = this.byAuthName.get(authName);
+    if (id == null) {
+      throw new Error(
+        `This request uses ${authName} authentication, which no plugin in the browser provides`,
+      );
+    }
+    return this.dispatch<AppliedAuthentication>(id, {
+      type: "call_http_authentication_request",
+      ...request,
+    } as InternalEventPayload);
+  }
+
+  /** First importer that recognizes the text wins, as `import_data` decides too. */
+  async import(content: string): Promise<ImportResources | null> {
+    await this.ready();
+    for (const id of this.importers) {
+      try {
+        const reply = await this.dispatch<{ resources?: ImportResources }>(id, {
+          type: "import_request",
+          content,
+        } as InternalEventPayload);
+        if (reply.type === "import_response" && reply.resources != null) return reply.resources;
+      } catch (err) {
+        console.error(`Importer \`${id}\` failed`, err);
+      }
+    }
+    return null;
+  }
+
+  /* ------------------------------- internals ------------------------------- */
+
+  private async dispatch<T>(
+    pluginRefId: string,
+    payload: InternalEventPayload,
+  ): Promise<T & { type: string }> {
+    if (this.sandbox == null) throw new Error("The plugin sandbox is not running");
+    return this.sandbox.dispatch<T>(pluginRefId, this.context(), payload);
+  }
+
+  /**
+   * `label` names a desktop window, so it stays null and the calls needing one
+   * refuse rather than guess which request the user is looking at.
+   */
+  private context(): PluginContext {
+    return { id: "web", label: null, workspaceId: null };
+  }
+
+  /**
+   * Every addition here is a capability decision, which is why they are written
+   * out one at a time instead of forwarded wholesale.
+   */
+  private async hostRequest(envelope: string): Promise<string> {
+    const { pluginRefId, payload } = JSON.parse(envelope) as {
+      pluginRefId: string;
+      context: PluginContext;
+      payload: InternalEventPayload;
+    };
+
+    const reply = async (): Promise<InternalEventPayload> => {
+      switch (payload.type) {
+        case "get_key_value_request": {
+          const value = await this.db.rpc<string | null>("web_plugin_kv_get", {
+            pluginName: pluginRefId,
+            key: (payload as unknown as KeyValueRequest).key,
+          });
+          return { type: "get_key_value_response", value } as InternalEventPayload;
+        }
+        case "set_key_value_request": {
+          const { key, value } = payload as unknown as { key: string; value: string };
+          await this.db.rpc("web_plugin_kv_set", {
+            pluginName: pluginRefId,
+            key,
+            value,
+          });
+          return { type: "set_key_value_response" } as InternalEventPayload;
+        }
+        case "delete_key_value_request": {
+          const deleted = await this.db.rpc<boolean>("web_plugin_kv_delete", {
+            pluginName: pluginRefId,
+            key: (payload as unknown as KeyValueRequest).key,
+          });
+          return { type: "delete_key_value_response", deleted } as InternalEventPayload;
+        }
+
+        case "show_toast_request": {
+          const { type: _type, ...toast } = payload;
+          this.db.deliver("show_toast", toast);
+          return { type: "empty_response" };
+        }
+
+        default:
+          throw new Error(
+            `\`${payload.type}\` isn't something a plugin can do when Yaak runs in a browser yet`,
+          );
+      }
+    };
+
+    try {
+      return JSON.stringify(await reply());
+    } catch (err) {
+      return JSON.stringify({
+        type: "error_response",
+        error: err instanceof Error ? err.message : String(err),
+      });
+    }
+  }
+
+}
@@ -16,6 +16,15 @@ export type ToWorker =
   * async in the engine (rendering is), where every `rpc` command is not.
   */
  | { type: "prepare_http_send"; id: number; payload: unknown }
+  /** Async for the same reason `prepare_http_send` is: it can call a plugin. */
+  | { type: "render_template"; id: number; payload: unknown }
+  /** The tab's answer to a `template_function` call. */
+  | {
+      type: "template_function_result";
+      id: number;
+      value?: string;
+      error?: string;
+    }
  | { type: "blob_get"; id: number; blobId: string }
  | { type: "blob_put"; id: number; blobId: string; bytes: ArrayBuffer }
  | { type: "blob_delete"; id: number; blobId: string }
@@ -38,7 +47,9 @@ export type FromWorker =
  | { type: "result"; id: number; result: unknown }
  | { type: "error"; id: number; message: string }
  /** A backend event for the app — today only `model_writes`. Sent to every port. */
-  | { type: "event"; event: string; payload: unknown };
+  | { type: "event"; event: string; payload: unknown }
+  /** The one message that runs the other way: the engine asking for a plugin. */
+  | { type: "template_function"; id: number; name: string; args: string };

 /** What the worker registers itself under. Tabs on one origin share it. */
 export const WORKER_NAME = "yaak-db";
@@ -33,7 +33,8 @@ import type {
 } from "@yaakapp-internal/models";
 import type { Frame, SendRequest } from "@yaakapp-internal/web";
 import type { WorkerConnection } from "./connection";
-import { serverIdentity, serverSendUrl, readFrames } from "./server";
+import type { WebPlugins } from "./plugins";
+import { readFrames, serverIdentity, serverSendUrl } from "./server";

 /* -------------------------------- shapes --------------------------------- */

@@ -51,11 +52,59 @@ type ResponsePatch = Partial<HttpResponse>;
 /** What `prepare_http_send` (crates/yaak-wasm) hands back. */
 interface PreparedHttpSend {
  request: HttpRequest;
+  /** Hashed id of the model the auth came from; plugins key stored state on it. */
+  authContextId: string;
  settings: HttpSendSettings;
  settingEvents: HttpResponseEventData[];
  cookieJar: CookieJar | null;
 }

+/**
+ * The desktop applies auth to the sendable request; here the server builds that,
+ * so the plugin's answer goes onto the model and the server folds it in. Same
+ * bytes for a method that sets a header, which is every one that runs here.
+ *
+ * Not the same for one that *signs*, since the plugin sees the request before
+ * the server assembles it. AWS SigV4 and OAuth 1.0 are refused rather than
+ * mis-signed; see the sandbox README.
+ */
+async function applyAuthentication(
+  plugins: WebPlugins,
+  prepared: PreparedHttpSend,
+): Promise<HttpRequest> {
+  const { request } = prepared;
+  const authType = request.authenticationType;
+  const disabled = request.authentication?.disabled === true;
+  if (authType == null || authType === "none" || disabled) return request;
+
+  const applied = await plugins.applyHttpAuthentication(authType, {
+    contextId: prepared.authContextId,
+    values: request.authentication as Record<string, never>,
+    method: request.method,
+    url: request.url,
+    headers: request.headers.filter((h) => h.enabled !== false),
+    // Only signing schemes hash the body, and those are already refused.
+    body: null,
+  });
+
+  const headers = [...request.headers];
+  for (const header of applied.setHeaders ?? []) {
+    // Replace-or-append, case-insensitively, matching `insert_header` in
+    // crates/yaak-http.
+    const at = headers.findIndex((h) => h.name.toLowerCase() === header.name.toLowerCase());
+    const entry = { name: header.name, value: header.value, enabled: true };
+    if (at >= 0) headers[at] = { ...headers[at], ...entry };
+    else headers.push(entry);
+  }
+
+  const urlParameters = [...request.urlParameters];
+  for (const param of applied.setQueryParameters ?? []) {
+    urlParameters.push({ name: param.name, value: param.value, enabled: true });
+  }
+
+  return { ...request, headers, urlParameters };
+}
+
 /** The desktop writes progress at most this often while a body streams in. */
 const PROGRESS_INTERVAL_MS = 100;

@@ -63,6 +112,7 @@ const PROGRESS_INTERVAL_MS = 100;

 export async function sendHttpRequest(
  db: WorkerConnection,
+  plugins: WebPlugins,
  requestId: string,
  environmentId: string | null,
  cookieJarId: string | null,
@@ -78,7 +128,7 @@ export async function sendHttpRequest(
  const unlistenCancel = db.listen(`cancel_http_response_${response.id}`, () => cancel.abort());

  try {
-    await runSend(db, response, requestId, environmentId, cookieJarId, cancel.signal);
+    await runSend(db, plugins, response, requestId, environmentId, cookieJarId, cancel.signal);
  } catch (err) {
    const message = cancel.signal.aborted ? "Request canceled" : errorMessage(err);
    await response.finish({ error: message });
@@ -90,6 +140,7 @@ export async function sendHttpRequest(

 async function runSend(
  db: WorkerConnection,
+  plugins: WebPlugins,
  response: ResponseWriter,
  requestId: string,
  environmentId: string | null,
@@ -101,7 +152,8 @@ async function runSend(
    environmentId,
    cookieJarId,
  });
-  await response.patch({ url: prepared.request.url });
+  const request = await applyAuthentication(plugins, prepared);
+  await response.patch({ url: request.url });

  // The first line of the timeline says what did the sending and where. A
  // request through a proxy shows a different origin to the server than the
@@ -111,7 +163,7 @@ async function runSend(
  timeline.push(prepared.settingEvents);

  const body: SendRequest = {
-    request: prepared.request,
+    request,
    settings: prepared.settings,
    cookies: prepared.cookieJar?.cookies ?? null,
  };
@@ -108,12 +108,36 @@ function bootOnce(): Promise<void> {
  return booted;
 }

+/**
+ * Rendering happens here; the functions it calls live in a sandbox the tab
+ * owns. Asked of the port that started the render, not every port, because
+ * only that tab is waiting and only its sandbox has those plugins.
+ */
+const pendingTemplateFunctions = new Map<number, (result: string | Error) => void>();
+let nextTemplateFunctionId = 1;
+
+function templateBridge(port: MessagePort): (name: string, args: string) => Promise<string> {
+  return (name, args) =>
+    new Promise<string>((resolve, reject) => {
+      const id = nextTemplateFunctionId++;
+      pendingTemplateFunctions.set(id, (r) => (r instanceof Error ? reject(r) : resolve(r)));
+      send(port, { type: "template_function", id, name, args });
+    });
+}
+
 async function handle(port: MessagePort, message: ToWorker): Promise<void> {
  if (message.type === "goodbye") {
    ports.delete(port);
    return;
  }

+  if (message.type === "template_function_result") {
+    const settle = pendingTemplateFunctions.get(message.id);
+    pendingTemplateFunctions.delete(message.id);
+    settle?.(message.error != null ? new Error(message.error) : (message.value ?? ""));
+    return;
+  }
+
  // Every command waits for boot rather than the tab having to. Tabs post
  // the moment they load; the port queues; this drains once the DB is open.
  try {
@@ -122,7 +146,8 @@ async function handle(port: MessagePort, message: ToWorker): Promise<void> {
    send(port, { type: "error", id: message.id, message: bootError ?? "Database failed to open" });
    return;
  }
-  const { rpc, blob_get, blob_put, blob_delete, prepare_http_send } = engine!;
+  const { rpc, blob_get, blob_put, blob_delete, prepare_http_send, render_template } =
+    engine!;

  try {
    switch (message.type) {
@@ -143,10 +168,15 @@ async function handle(port: MessagePort, message: ToWorker): Promise<void> {
        return;
      }
      case "prepare_http_send": {
-        const prepared = await prepare_http_send(message.payload);
+        const prepared = await prepare_http_send(message.payload, templateBridge(port));
        send(port, { type: "result", id: message.id, result: prepared });
        return;
      }
+      case "render_template": {
+        const rendered = await render_template(message.payload, templateBridge(port));
+        send(port, { type: "result", id: message.id, result: rendered });
+        return;
+      }
      case "blob_get": {
        const bytes = blob_get(message.blobId);
        if (bytes == null) {
@@ -474,19 +474,7 @@ export type ImportRequest = { content: string, };

 export type ImportResources = { workspaces: Array<Workspace>, environments: Array<Environment>, folders: Array<Folder>, httpRequests: Array<HttpRequest>, grpcRequests: Array<GrpcRequest>, websocketRequests: Array<WebsocketRequest>, };

-export type ImportResponse = { 
-/**
- * Display name of the importer that recognized the input.
- */
-importer: string, resources: ImportResources, 
-/**
- * Stable identity for imported resources, keyed by the resource IDs in `resources`.
- *
- * A key identifies the same source element across re-parses of an edited document, which
- * lets a later import recognize what it already imported. Importers only populate it for
- * formats that carry their own identifiers; the host derives a key for anything missing.
- */
-sourceKeys?: { [key in string]?: string }, };
+export type ImportResponse = { resources: ImportResources, };

 export type InternalEvent = { id: string, pluginRefId: string, pluginName: string, replyId: string | null, context: PluginContext, payload: InternalEventPayload, };

@@ -109,7 +109,6 @@ export type Folder = {
  settingFollowRedirects: InheritedBoolSetting;
  settingRequestTimeout: InheritedIntSetting;
  settingRequestMessageSize: InheritedIntSetting;
-  settingHttpVersion: InheritedHttpVersionSetting;
 };

 export type GraphQlIntrospection = {
@@ -214,7 +213,6 @@ export type HttpRequest = {
  settingValidateCertificates: InheritedBoolSetting;
  settingFollowRedirects: InheritedBoolSetting;
  settingRequestTimeout: InheritedIntSetting;
-  settingHttpVersion: InheritedHttpVersionSetting;
 };

 export type HttpRequestHeader = { enabled?: boolean; name: string; value: string; id?: string };
@@ -316,12 +314,8 @@ export type HttpUrlParameter = {
  id?: string;
 };

-export type HttpVersion = "auto" | "http1" | "http2";
-
 export type InheritedBoolSetting = { enabled?: boolean; value: boolean };

-export type InheritedHttpVersionSetting = { enabled?: boolean; value: HttpVersion };
-
 export type InheritedIntSetting = { enabled?: boolean; value: number };

 export type KeyValue = {
@@ -384,7 +378,6 @@ export type Settings = {
  themeLight: string;
  updateChannel: string;
  hideLicenseBadge: boolean;
-  promptFeedback: boolean;
  autoupdate: boolean;
  autoDownloadUpdates: boolean;
  checkNotifications: boolean;
@@ -435,14 +428,7 @@ export type WebsocketEvent = {
 };

 export type WebsocketEventType =
-  | "binary"
-  | "close"
-  | "error"
-  | "frame"
-  | "open"
-  | "ping"
-  | "pong"
-  | "text";
+  "binary" | "close" | "error" | "frame" | "open" | "ping" | "pong" | "text";

 export type WebsocketRequest = {
  model: "websocket_request";
@@ -487,7 +473,6 @@ export type Workspace = {
  settingDnsOverrides: Array<DnsOverride>;
  settingSendCookies: boolean;
  settingStoreCookies: boolean;
-  settingHttpVersion: HttpVersion;
 };

 export type WorkspaceMeta = {
@@ -16,16 +16,6 @@ export type PartialImportResources = {

 export type ImportPluginResponse = null | {
  resources: PartialImportResources;
-
-  /**
-   * Stable identity for imported resources, keyed by the resource IDs in `resources`.
-   *
-   * A key identifies the same source element across re-parses of an edited document, so it must
-   * come from the document itself and must not be derived from anything the user can change in
-   * Yaak after importing. Omit resources the format gives no identifier — the host derives a key
-   * for those.
-   */
-  sourceKeys?: Record<string, string>;
 };

 export type ImporterPlugin = {
@@ -2,72 +2,36 @@ import console from "node:console";
 import { type Stats, statSync, watch } from "node:fs";
 import path from "node:path";
 import type {
-  CallPromptFormDynamicArgs,
  Context,
  DynamicPromptFormArg,
  PluginDefinition,
 } from "@yaakapp/api";
+import {
+  createPluginContext,
+  type PluginTransport,
+} from "@yaakapp-internal/lib/pluginContext";
+import {
+  applyDynamicFormInput,
+  migrateTemplateFunctionSelectOptions,
+  stripDynamicCallbacks,
+} from "@yaakapp-internal/lib/pluginForms";
 import {
  applyFormInputDefaults,
  validateTemplateFunctionArgs,
 } from "@yaakapp-internal/lib/templateFunction";
 import type {
  BootRequest,
-  DeleteKeyValueResponse,
-  DeleteModelResponse,
-  FindHttpResponsesResponse,
-  Folder,
-  FormInput,
-  GetCookieValueRequest,
-  GetCookieValueResponse,
-  GetHttpRequestByIdResponse,
-  GetHttpResponseBodyInfoResponse,
-  GetKeyValueResponse,
  GrpcRequestAction,
  HttpAuthenticationAction,
-  HttpRequest,
  HttpRequestAction,
-  HttpResponse,
  ImportResources,
  InternalEvent,
  InternalEventPayload,
-  ListCookieNamesResponse,
-  ListFoldersResponse,
-  ListHttpRequestsRequest,
-  ListHttpRequestsResponse,
-  ListOpenWorkspacesResponse,
  PluginContext,
  PromptFormResponse,
-  PromptTextResponse,
-  ReadHttpResponseBodyChunkResponse,
-  RenderGrpcRequestResponse,
-  RenderHttpRequestResponse,
-  SendHttpRequestResponse,
  TemplateFunction,
-  TemplateRenderRequest,
-  TemplateRenderResponse,
-  UpsertModelResponse,
-  WindowInfoResponse,
 } from "@yaakapp-internal/plugins";
-import { applyDynamicFormInput } from "./common";
 import { EventChannel } from "./EventChannel";
-import { migrateTemplateFunctionSelectOptions } from "./migrations";
-import { createResponseBody, decodeBase64Chunk } from "./responseBody";
-
-/**
- * A response as a plugin should see it.
- *
- * The host still puts `bodyPath` on the wire for its own callers, but it names
- * a file on the host's disk — meaningless to a plugin, absent once bodies move
- * off the filesystem, and impossible in a browser. Plugins address bodies by
- * response id, so drop it here rather than let one grow a dependency on it.
- */
-function forPlugin(httpResponse: HttpResponse): HttpResponse {
-  const { bodyPath: _bodyPath, ...rest } = httpResponse as HttpResponse & {
-    bodyPath?: string | null;
-  };
-  return rest;
-}

 export interface PluginWorkerData {
  bootRequest: BootRequest;
@@ -167,9 +131,7 @@ export class PluginInstance {
        if (reply != null) {
          const replyPayload: InternalEventPayload = {
            type: "import_response",
-            importer: this.#mod.importer.name,
            resources: reply.resources as ImportResources,
-            sourceKeys: reply.sourceKeys ?? null,
          };
          this.#sendPayload(context, replyPayload, replyId);
          return;
@@ -631,444 +593,64 @@ export class PluginInstance {
    this.#sendEvent(eventToSend);
  }

-  #newCtx(context: PluginContext): Context {
-    /** Read a body the host has stored, a chunk at a time, following it if it is still arriving. */
-    const storedBody = async (responseId: string) => {
-      const bodyInfo = () =>
-        this.#sendForReply<GetHttpResponseBodyInfoResponse>(context, {
-          type: "get_http_response_body_info_request",
-          responseId,
-        });
-      const info = await bodyInfo();
+  /**
+   * How a plugin reaches the app from this runtime.
+   *
+   * Every request is an event whose reply is matched by id. This runtime can
+   * hold a conversation open, so it supplies `stream` and `form`: a window
+   * reports navigation until it closes, and a prompt form re-renders as values
+   * change. `ctx` itself is built from these in @yaakapp-internal/lib, the same
+   * way the sandbox runtime builds it.
+   */
+  #transport: PluginTransport = {
+    request: (context, payload) => this.#sendForReply(context, payload),

-      return createResponseBody(
-        {
-          responseId,
-          contentLength: info.contentLength,
-          contentType: info.contentType ?? null,
-          complete: info.complete,
-        },
-        async (offset, length) => {
-          const chunk = await this.#sendForReply<ReadHttpResponseBodyChunkResponse>(
-            context,
-            { type: "read_http_response_body_chunk_request", responseId, offset, length },
-          );
-          return decodeBase64Chunk(chunk.data);
-        },
-        { refresh: bodyInfo },
-      );
-    };
+    notify: (context, payload) => {
+      this.#sendPayload(context, payload, null);
+    },

-    const _windowInfo = async () => {
-      if (context.label == null) {
-        throw new Error("Can't get window context without an active window");
-      }
-      const payload: InternalEventPayload = {
-        type: "window_info_request",
-        label: context.label,
-      };
+    stream: (context, payload, onReply) => {
+      this.#sendAndListenForEvents(context, payload, onReply);
+    },

-      return this.#sendForReply<WindowInfoResponse>(context, payload);
-    };
+    form: (context, payload, onChange) => {
+      // Built by hand so the event id is available: intermediate re-renders
+      // reply to the original request rather than starting a new one.
+      const eventToSend = this.#buildEventToSend(context, payload, null);

-    return {
-      clipboard: {
-        copyText: async (text) => {
-          await this.#sendForReply(context, {
-            type: "copy_text_request",
-            text,
-          });
-        },
-      },
-      toast: {
-        show: async (args) => {
-          await this.#sendForReply(context, {
-            type: "show_toast_request",
-            // Handle default here because null/undefined both convert to None in Rust translation
-            timeout: args.timeout === undefined ? 5000 : args.timeout,
-            ...args,
-          });
-        },
-      },
-      window: {
-        requestId: async () => {
-          return (await _windowInfo()).requestId;
-        },
-        async workspaceId(): Promise<string | null> {
-          return (await _windowInfo()).workspaceId;
-        },
-        async environmentId(): Promise<string | null> {
-          return (await _windowInfo()).environmentId;
-        },
-        openUrl: async ({ onNavigate, onClose, ...args }) => {
-          args.label = args.label || `${Math.random()}`;
-          const payload: InternalEventPayload = { type: "open_window_request", ...args };
-          const onEvent = (event: InternalEventPayload) => {
-            if (event.type === "window_navigate_event") {
-              onNavigate?.(event);
-            } else if (event.type === "window_close_event") {
-              onClose?.();
-            }
-          };
-          this.#sendAndListenForEvents(context, payload, onEvent);
-          return {
-            close: () => {
-              const closePayload: InternalEventPayload = {
-                type: "close_window_request",
-                label: args.label,
-              };
-              this.#sendPayload(context, closePayload, null);
-            },
-          };
-        },
-        openExternalUrl: async (url) => {
-          await this.#sendForReply(context, {
-            type: "open_external_url_request",
-            url,
-          });
-        },
-      },
-      prompt: {
-        text: async (args) => {
-          const reply: PromptTextResponse = await this.#sendForReply(context, {
-            type: "prompt_text_request",
-            ...args,
-          });
-          return reply.value;
-        },
-        form: async (args) => {
-          // Resolve dynamic callbacks on initial inputs using default values
-          const defaults = applyFormInputDefaults(args.inputs, {});
-          const callArgs: CallPromptFormDynamicArgs = { values: defaults };
-          const resolvedInputs = await applyDynamicFormInput(
-            this.#newCtx(context),
-            args.inputs,
-            callArgs,
-          );
-          const strippedInputs = stripDynamicCallbacks(resolvedInputs);
+      return new Promise<PromptFormResponse>((resolve) => {
+        const cb = (event: InternalEvent) => {
+          if (event.replyId !== eventToSend.id) return;
+          if (event.payload.type !== "prompt_form_response") return;

-          // Build the event manually so we can get the event ID for keying
-          const eventToSend = this.#buildEventToSend(
-            context,
-            { type: "prompt_form_request", ...args, inputs: strippedInputs },
-            null,
-          );
-
-          // Store original inputs (with dynamic callbacks) for later resolution
-          this.#pendingDynamicForms.set(eventToSend.id, args.inputs);
-
-          const reply = await new Promise<PromptFormResponse>((resolve) => {
-            const cb = (event: InternalEvent) => {
-              if (event.replyId !== eventToSend.id) return;
-
-              if (event.payload.type === "prompt_form_response") {
-                const { done, values } = event.payload as PromptFormResponse;
-                if (done) {
-                  // Final response — resolve the promise and clean up
-                  this.#appToPluginEvents.unlisten(cb);
-                  this.#pendingDynamicForms.delete(eventToSend.id);
-                  resolve({ values } as PromptFormResponse);
-                } else {
-                  // Intermediate value change — resolve dynamic inputs and send back
-                  // Skip empty values (fired on initial mount before user interaction)
-                  const storedInputs = this.#pendingDynamicForms.get(eventToSend.id);
-                  if (storedInputs && values && Object.keys(values).length > 0) {
-                    const ctx = this.#newCtx(context);
-                    const callArgs: CallPromptFormDynamicArgs = { values };
-                    applyDynamicFormInput(ctx, storedInputs, callArgs)
-                      .then((resolvedInputs) => {
-                        const stripped = stripDynamicCallbacks(resolvedInputs);
-                        this.#sendPayload(
-                          context,
-                          { type: "prompt_form_request", ...args, inputs: stripped },
-                          eventToSend.id,
-                        );
-                      })
-                      .catch((err) => {
-                        console.error("Failed to resolve dynamic form inputs", err);
-                      });
-                  }
-                }
-              }
-            };
-            this.#appToPluginEvents.listen(cb);
-
-            // Send the initial event after we start listening (to prevent race)
-            this.#sendEvent(eventToSend);
-          });
-
-          return reply.values;
-        },
-      },
-      httpResponse: {
-        find: async (args) => {
-          const payload = {
-            type: "find_http_responses_request",
-            ...args,
-          } as const;
-          const { httpResponses } = await this.#sendForReply<FindHttpResponsesResponse>(
-            context,
-            payload,
-          );
-          return httpResponses.map(forPlugin);
-        },
-        body: ({ responseId }) => storedBody(responseId),
-      },
-      grpcRequest: {
-        render: async (args) => {
-          const payload = {
-            type: "render_grpc_request_request",
-            ...args,
-          } as const;
-          const { grpcRequest } = await this.#sendForReply<RenderGrpcRequestResponse>(
-            context,
-            payload,
-          );
-          return grpcRequest;
-        },
-      },
-      httpRequest: {
-        getById: async (args) => {
-          const payload = {
-            type: "get_http_request_by_id_request",
-            ...args,
-          } as const;
-          const { httpRequest } = await this.#sendForReply<GetHttpRequestByIdResponse>(
-            context,
-            payload,
-          );
-          return httpRequest;
-        },
-        send: async (args) => {
-          const payload = {
-            type: "send_http_request_request",
-            ...args,
-          } as const;
-          const { httpResponse, body } = await this.#sendForReply<SendHttpRequestResponse>(
-            context,
-            payload,
-          );
-
-          // A send with no request behind it saves nothing, so the reply
-          // carries the only copy of its body. A saved one is read back from
-          // the host like any other. Callers get the same thing either way.
-          if (body == null) {
-            return { httpResponse: forPlugin(httpResponse), body: await storedBody(httpResponse.id) };
+          const { done, values } = event.payload as PromptFormResponse;
+          if (done) {
+            this.#appToPluginEvents.unlisten(cb);
+            resolve({ values } as PromptFormResponse);
+            return;
          }

-          const bytes = decodeBase64Chunk(body);
-          return {
-            httpResponse: forPlugin(httpResponse),
-            body: createResponseBody(
-              {
-                responseId: httpResponse.id,
-                contentLength: bytes.byteLength,
-                contentType:
-                  httpResponse.headers.find((h) => h.name.toLowerCase() === "content-type")
-                    ?.value ?? null,
-                // The host waited for the whole send before replying.
-                complete: true,
-              },
-              async (offset, length) => bytes.slice(offset, offset + length),
-            ),
-          };
-        },
-        render: async (args) => {
-          const payload = {
-            type: "render_http_request_request",
-            ...args,
-          } as const;
-          const { httpRequest } = await this.#sendForReply<RenderHttpRequestResponse>(
-            context,
-            payload,
-          );
-          return httpRequest;
-        },
-        list: async (args?: { folderId?: string }) => {
-          const payload: InternalEventPayload = {
-            type: "list_http_requests_request",
-            folderId: args?.folderId,
-          } satisfies ListHttpRequestsRequest & { type: "list_http_requests_request" };
-          const { httpRequests } = await this.#sendForReply<ListHttpRequestsResponse>(
-            context,
-            payload,
-          );
-          return httpRequests;
-        },
-        create: async (args) => {
-          const payload = {
-            type: "upsert_model_request",
-            model: {
-              name: "",
-              method: "GET",
-              ...args,
-              id: "",
-              model: "http_request",
-            },
-          } as InternalEventPayload;
-          const response = await this.#sendForReply<UpsertModelResponse>(context, payload);
-          return response.model as HttpRequest;
-        },
-        update: async (args) => {
-          const payload = {
-            type: "upsert_model_request",
-            model: {
-              model: "http_request",
-              ...args,
-            },
-          } as InternalEventPayload;
-          const response = await this.#sendForReply<UpsertModelResponse>(context, payload);
-          return response.model as HttpRequest;
-        },
-        delete: async (args) => {
-          const payload = {
-            type: "delete_model_request",
-            model: "http_request",
-            id: args.id,
-          } as InternalEventPayload;
-          const response = await this.#sendForReply<DeleteModelResponse>(context, payload);
-          return response.model as HttpRequest;
-        },
-      },
-      folder: {
-        list: async () => {
-          const payload = { type: "list_folders_request" } as const;
-          const { folders } = await this.#sendForReply<ListFoldersResponse>(context, payload);
-          return folders;
-        },
-        getById: async (args: { id: string }) => {
-          const payload = { type: "list_folders_request" } as const;
-          const { folders } = await this.#sendForReply<ListFoldersResponse>(context, payload);
-          return folders.find((f) => f.id === args.id) ?? null;
-        },
-        create: async ({ name, ...args }) => {
-          const payload = {
-            type: "upsert_model_request",
-            model: {
-              ...args,
-              name: name ?? "",
-              id: "",
-              model: "folder",
-            },
-          } as InternalEventPayload;
-          const response = await this.#sendForReply<UpsertModelResponse>(context, payload);
-          return response.model as Folder;
-        },
-        update: async (args) => {
-          const payload = {
-            type: "upsert_model_request",
-            model: {
-              model: "folder",
-              ...args,
-            },
-          } as InternalEventPayload;
-          const response = await this.#sendForReply<UpsertModelResponse>(context, payload);
-          return response.model as Folder;
-        },
-        delete: async (args: { id: string }) => {
-          const payload = {
-            type: "delete_model_request",
-            model: "folder",
-            id: args.id,
-          } as InternalEventPayload;
-          const response = await this.#sendForReply<DeleteModelResponse>(context, payload);
-          return response.model as Folder;
-        },
-      },
-      cookies: {
-        getValue: async (args: GetCookieValueRequest) => {
-          const payload = {
-            type: "get_cookie_value_request",
-            ...args,
-          } as const;
-          const { value } = await this.#sendForReply<GetCookieValueResponse>(context, payload);
-          return value;
-        },
-        listNames: async () => {
-          const payload = { type: "list_cookie_names_request" } as const;
-          const { names } = await this.#sendForReply<ListCookieNamesResponse>(context, payload);
-          return names;
-        },
-      },
-      templates: {
-        /**
-         * Invoke Yaak's template engine to render a value. If the value is a nested type
-         * (eg. object), it will be recursively rendered.
-         */
-        render: async (args: TemplateRenderRequest) => {
-          const payload = { type: "template_render_request", ...args } as const;
-          const result = await this.#sendForReply<TemplateRenderResponse>(context, payload);
-          // oxlint-disable-next-line no-explicit-any -- That's okay
-          return result.data as any;
-        },
-      },
-      store: {
-        get: async <T>(key: string) => {
-          const payload = { type: "get_key_value_request", key } as const;
-          const result = await this.#sendForReply<GetKeyValueResponse>(context, payload);
-          return result.value ? (JSON.parse(result.value) as T) : undefined;
-        },
-        set: async <T>(key: string, value: T) => {
-          const valueStr = JSON.stringify(value);
-          const payload: InternalEventPayload = {
-            type: "set_key_value_request",
-            key,
-            value: valueStr,
-          };
-          await this.#sendForReply<GetKeyValueResponse>(context, payload);
-        },
-        delete: async (key: string) => {
-          const payload = { type: "delete_key_value_request", key } as const;
-          const result = await this.#sendForReply<DeleteKeyValueResponse>(context, payload);
-          return result.deleted;
-        },
-      },
-      plugin: {
-        reload: () => {
-          this.#sendPayload(context, { type: "reload_response", silent: true }, null);
-        },
-      },
-      workspace: {
-        list: async () => {
-          const payload = {
-            type: "list_open_workspaces_request",
-          } as InternalEventPayload;
-          const response = await this.#sendForReply<ListOpenWorkspacesResponse>(context, payload);
-          return response.workspaces.map((w) => {
-            // Internal workspace info includes label field not in public API
-            type WorkspaceInfoInternal = typeof w & { label?: string };
-            return {
-              id: w.id,
-              name: w.name,
-              // Hide label from plugin authors, but keep it for internal routing
-              _label: (w as WorkspaceInfoInternal).label as string,
-            };
-          });
-        },
-        withContext: (workspaceHandle: { id: string; name: string; _label?: string }) => {
-          // Create a new context with the workspace's window label
-          const newContext: PluginContext = {
-            ...context,
-            label: workspaceHandle._label || null,
-            workspaceId: workspaceHandle.id,
-          };
-          return this.#newCtx(newContext);
-        },
-      },
-    };
+          onChange(values ?? {})
+            .then((next) => {
+              if (next != null) this.#sendPayload(context, next, eventToSend.id);
+            })
+            .catch((err: unknown) => {
+              console.error("Failed to resolve dynamic form inputs", err);
+            });
+        };
+        this.#appToPluginEvents.listen(cb);
+
+        // Sent after the listener is attached, to prevent a race.
+        this.#sendEvent(eventToSend);
+      });
+    },
+  };
+
+  #newCtx(context: PluginContext): Context {
+    return createPluginContext(this.#transport, context);
  }
 }

-function stripDynamicCallbacks(inputs: { dynamic?: unknown }[]): FormInput[] {
-  return inputs.map((input) => {
-    // oxlint-disable-next-line no-explicit-any -- stripping dynamic from union type
-    const { dynamic: _dynamic, ...rest } = input as any;
-    if ("inputs" in rest && Array.isArray(rest.inputs)) {
-      rest.inputs = stripDynamicCallbacks(rest.inputs);
-    }
-    return rest as FormInput;
-  });
-}

 function genId(len = 5): string {
  const alphabet = "01234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
@@ -1,22 +0,0 @@
-import type { TemplateFunctionPlugin } from "@yaakapp/api";
-
-export function migrateTemplateFunctionSelectOptions(
-  f: TemplateFunctionPlugin,
-): TemplateFunctionPlugin {
-  const migratedArgs = f.args.map((a) => {
-    if (a.type === "select") {
-      // Migrate old options that had 'name' instead of 'label'
-      type LegacyOption = { label?: string; value: string; name?: string };
-      a.options = a.options.map((o) => {
-        const legacy = o as LegacyOption;
-        return {
-          label: legacy.label ?? legacy.name ?? "",
-          value: legacy.value,
-        };
-      });
-    }
-    return a;
-  });
-
-  return { ...f, args: migratedArgs };
-}
@@ -0,0 +1,275 @@
+# The Yaak plugin sandbox
+
+A QuickJS interpreter, a small set of globals, and one function that calls the
+host. That is the whole runtime. Everything else a plugin does — read a request,
+send one, store a token, ask the user something — is a message the host chose to
+answer.
+
+This document is the contract. It is written to be implementable twice: once
+here, in wasm, for the browser, and once in Rust with `rquickjs`, for the desktop
+and the CLI. **If the two hosts disagree about anything below, that is a bug in
+whichever one drifted, not a platform difference to work around.** The promise
+to plugin authors is that there is one sandbox and it behaves the same
+everywhere; a promise like that is only worth making if it is enforceable, which
+is why the browser runs QuickJS rather than the Worker's own JavaScript engine.
+
+## The engine
+
+**quickjs-ng**, and only quickjs-ng.
+
+There is no real choice: `rquickjs` — the Rust binding the desktop host will use
+— vendors quickjs-ng as a git submodule and offers no alternative. Picking
+Bellard's upstream for the browser would mean the two hosts run different
+engines, which is exactly the thing this design exists to prevent.
+
+| | Version | Notes |
+|---|---|---|
+| Browser (this package) | quickjs-ng **0.12.1** | via `@jitl/quickjs-ng-wasmfile-release-sync` 0.32.0 |
+| Desktop (planned) | quickjs-ng **0.15.1** | via `rquickjs` 0.12.2 |
+
+**The version skew is a known gap, and closing it is slice-2 work.** Three minor
+versions is small — the differences are bug fixes and `Temporal` progress, not
+semantics anything here depends on — but "identical everywhere" is not a claim
+that survives being approximate indefinitely. Whoever builds the Rust host
+should pin both sides to the same tag and add a test that asserts the version
+string matches.
+
+### Why the sync build, not ASYNCIFY
+
+`quickjs-emscripten` ships an ASYNCIFY variant that lets guest code call an async
+host function *synchronously*. We use the plain sync build instead:
+
+- ASYNCIFY is about twice the wasm size (1.08 MB vs 529 KB) and, measured,
+  **2.2x slower**.
+- It can only suspend for one host call at a time. A runtime that runs several
+  plugins would have to hold one wasm instance per in-flight call.
+- We do not need it. The guest gets real `await` anyway: a host function returns
+  a QuickJS deferred promise, the host resolves it, and the host drains the job
+  queue. `ctx.store.get(...)` is an ordinary `await` inside a plugin.
+
+The only thing lost is a host call that *looks* synchronous to the guest, and no
+Yaak plugin wants one — the whole `ctx` API has been async since it existed.
+
+## What exists inside the sandbox
+
+QuickJS gives you the language and nothing else. Everything below is either
+installed by `src/guest/globals.ts` or absent. **Both hosts must install exactly
+this list.**
+
+### From the engine
+
+`Object`, `Array`, `Function`, `String`, `Number`, `Boolean`, `Symbol`, `Math`,
+`JSON`, `Date`, `RegExp`, `Error` and subclasses, `Map`, `Set`, `WeakMap`,
+`WeakSet`, `WeakRef`, `Promise`, `Proxy`, `Reflect`, `BigInt`, `ArrayBuffer`,
+`SharedArrayBuffer`, `DataView`, all `TypedArray`s, `globalThis`,
+`queueMicrotask`, `performance`.
+
+Language level is ES2023 plus most of ES2024 — `Object.groupBy`,
+`Array.prototype.at`, `String.prototype.replaceAll`, async generators, private
+fields, `??=` all work.
+
+### Installed by the runtime
+
+| Global | Notes |
+|---|---|
+| `console` | `.log/.info/.warn/.error/.debug/.trace`. Arguments are formatted to a string **inside** the sandbox, so only strings cross out — a cycle or an exotic prototype is the guest's problem, not the host's. |
+| `setTimeout` / `clearTimeout` | The host holds the real timer; QuickJS has no clock to wake on. A sandbox torn down mid-wait takes its pending timers with it. |
+| `TextEncoder` / `TextDecoder` | UTF-8 only. Pure JavaScript, in-sandbox — a bridge would cost a copy each way. Lone surrogates encode to U+FFFD, matching the standard. |
+| `btoa` / `atob` | Latin-1, same narrow contract as the browser's. |
+
+### Deliberately absent
+
+`fetch`, `XMLHttpRequest`, `WebSocket`, `crypto`, `structuredClone`, `URL`,
+`URLSearchParams`, `setInterval`, `require`, `module`, `process`, `Buffer`,
+`std`, `os`, and every Node built-in.
+
+- **Network and storage are absent because they are `ctx`'s job.** A plugin that
+  could open its own socket would defeat the point of the sandbox and would not
+  work in a browser anyway.
+- **`setInterval` is absent** because an interval is a timer that rearms and
+  nothing in a plugin should be polling. Build one from `setTimeout`, visibly.
+- **`crypto` is absent, and this is the one real gap.** The decided direction is
+  pure-JavaScript `@noble/*` inside the sandbox: audited, dependency-free,
+  identical on both hosts, no host API to keep in sync. A `yaak.crypto` builtin
+  is the escape hatch **if** a hot path is measured, not before. Concretely,
+  `template-function-uuid` does not run in the sandbox today because its `uuid`
+  dependency reaches for `node:crypto`; that is a slice-2 conversion, not a
+  missing capability.
+- **`URL` is absent** only because nothing has needed it yet. It is a reasonable
+  future addition; it must be added to both hosts together.
+
+## The module contract
+
+A module arrives as **source text**, not a file — there is no filesystem, and in
+a browser there could not be one.
+
+It is evaluated as CommonJS, via `new Function("module", "exports", "require", source)`,
+and must assign `module.exports.plugin` (or `module.exports.default`). `new
+Function` rather than an ES module is deliberate: the bundle's top-level names
+cannot collide with the shell's, and the source needs no loader hook.
+
+`require` exists **only to throw**, naming the specifier. A bundle that still
+calls it was not bundled for this target, and saying which module is missing
+beats an `undefined` that surfaces ten frames later.
+
+Bundling requirements: CommonJS, no external modules, no Node built-ins, ES2022.
+`scripts/bundle-sandbox-plugins.mjs` does this today; what a real
+`yaakcli build --target sandbox` needs is listed at the bottom of that file.
+
+## The host interface
+
+Four functions, installed on `globalThis` before any plugin code runs. A Rust
+host must expose the same four with the same names and shapes.
+
+| Function | Direction | Shape |
+|---|---|---|
+| `__yaak_call(envelopeJson)` | guest → host | Returns a **promise** of the reply JSON. The one door out. |
+| `__yaak_log(level, message)` | guest → host | Both strings. Fire and forget. |
+| `__yaak_timer_start(id, ms)` | guest → host | Host calls `__yaak_guest.fireTimer(id)` when due. |
+| `__yaak_timer_cancel(id)` | guest → host | |
+
+And the guest exposes `globalThis.__yaak_guest`:
+
+| Method | Shape |
+|---|---|
+| `load(source, pluginRefId)` | Evaluate a module. Throws if it exports no `plugin`. |
+| `summary()` | What the module contributes, as plain data. |
+| `dispatch(envelopeJson)` | Returns a promise of the reply payload JSON. |
+| `fireTimer(id)` | |
+
+### Envelopes
+
+Both directions carry `InternalEventPayload` from
+`crates/yaak-plugins/src/events.rs`, **unchanged**. That is what makes a plugin
+unable to tell which runtime it is in.
+
+```jsonc
+// dispatch, host → guest
+{ "context": { "id": "...", "label": null, "workspaceId": "..." },
+  "payload": { "type": "call_template_function_request", "name": "...", "args": { ... } } }
+
+// __yaak_call, guest → host
+{ "pluginRefId": "auth-bearer",
+  "context": { ... },
+  "payload": { "type": "get_key_value_request", "key": "token" } }
+```
+
+`pluginRefId` rides on outgoing calls because one host handler serves every
+loaded module, and a plugin's stored state is namespaced by which plugin it is —
+the same namespacing `build_shared_reply` does in `crates/yaak/src/plugin_events.rs`.
+
+A throw inside a plugin becomes `{"type":"error_response","error":"..."}`, never
+a crash and never silence: whatever asked gets a message.
+
+## The `ctx` API
+
+Built entirely out of `__yaak_call`. See `src/guest/context.ts` — it is the same
+surface the Node runtime's `PluginInstance` builds, so it is not repeated here.
+
+What differs is which calls a **host** answers. The browser host answers a
+deliberately short list (`packages/platform/src/web/plugins.ts`) and refuses the
+rest by name. Refusing by name matters: a plugin that needs something it cannot
+have should fail with a sentence someone can act on.
+
+Answered in the browser today: `get_key_value`, `set_key_value`,
+`delete_key_value`, `show_toast`. Everything else — sends, model reads and
+writes, prompts, response bodies, window info — refuses. Those are capability
+decisions, not oversights, and each should be added one at a time.
+
+`ctx.window.openUrl` throws in *every* sandbox host: a plugin-opened window is a
+desktop affordance with no browser equivalent, and handing back a handle whose
+`close()` does nothing would be worse.
+
+## Isolation and limits
+
+One runtime per worker, **one context per module**. A context is the isolation
+boundary — its own globals, its own `Object`, its own prototypes — so two plugins
+cannot see or patch each other. Sharing the runtime is deliberate: the engine and
+its wasm instance are the expensive part; contexts are not.
+
+| Limit | Value | Why |
+|---|---|---|
+| Memory | 256 MB per runtime | Sized for an importer holding a large document and the objects it parses into. |
+| Stack | 2 MB | Deep recursion becomes a guest stack overflow, not a worker crash. |
+| Synchronous execution | 60 s | A watchdog for `while (true)`, **not** a limit on real work. |
+
+The watchdog bounds *synchronous* execution only. A plugin awaiting the host is
+not looping, so the clock stops for the duration of a host call and restarts
+when the guest resumes. It is generous because it costs nothing to be: plugins
+run in their own worker, so one stuck there blocks no database command and no
+frame. It is sized off the slowest real work measured — GitHub's 12.3 MB OpenAPI
+description takes about 2.5 s (`bench/import.mjs`) — with room for a document
+several times larger before a legitimate import looks like a hang.
+
+## Where the sandbox runs, and why not in the database worker
+
+In the browser: a **dedicated worker owned by the tab**, separate from the
+SharedWorker that owns the database.
+
+- Plugin work is slow by design, and the database worker answers every tab's
+  commands synchronously. A large import in there would stall every other tab's
+  reads.
+- A plugin that never returns can be ended with `terminate()`. You cannot do
+  that to the worker holding the database.
+- The capabilities plugins actually ask for — a prompt, a toast, the active
+  request — belong to a tab, not to a database. Routing through the tab is the
+  shorter path, not a detour.
+
+The cost is that `ctx.store` goes worker → tab → database worker. It is a message
+either way, and this is the direction where a stuck plugin costs nothing.
+
+Template rendering is the one flow that runs backwards: rendering happens in the
+engine, in the database worker, but the functions it calls live here. So the
+engine is handed a callback that asks the tab, which asks the sandbox. See
+`templateBridge` in `packages/platform/src/web/worker.ts`.
+
+## Plugins versus scripts
+
+The shell is **not plugin-shaped underneath**. `load` takes source; `dispatch`
+takes an event. What a module *is* — a plugin today, a workspace script later —
+is decided by the payloads the host sends, not by the runtime.
+
+That matters for one reason. A plugin is installed, so someone consented to it,
+and a plugin may one day escalate to a full Node runtime by asking. **A script
+arrives inside a workspace — as data, through an import, a git sync, a shared
+repository — with no consent moment at all.** So scripts get this sandbox and
+only this sandbox, forever, regardless of feature pressure. Any capability added
+below must be evaluated against the script case, which is the stricter one:
+"would I want this to run because someone opened a workspace a stranger sent
+them?"
+
+Expected differences when scripts arrive, none of them built yet:
+
+- A different payload set (`run_script_request` and friends) — same envelope.
+- A tighter host-call allowlist. A script should probably not reach `ctx.store`
+  at all, and certainly not another plugin's namespace.
+- A much shorter watchdog. A pre-request script that runs for a minute is broken;
+  an importer that does is working.
+
+## Performance
+
+QuickJS is an interpreter with no JIT. Measured on GitHub's 12.3 MB OpenAPI
+description (1220 requests imported, **identical output** in both engines):
+
+| | First run | Best of 6 |
+|---|---|---|
+| Node (V8) | 304 ms | 164 ms |
+| QuickJS sandbox | 2503 ms | 2017 ms |
+
+That is **8x on the first run** and about **12x once V8 has compiled** — well
+inside the 10–50x folklore, and the first-run number is the one a user waits for
+because an import happens once. Reproduce with:
+
+```bash
+node packages/plugin-sandbox/bench/import.mjs <spec.json> 6
+```
+
+**Conclusion: importers stay in the sandbox.** 2.5 s in a worker, behind a
+progress state, for the largest public API description that exists, is a fine
+trade for one runtime everywhere. Revisit if a real document is measured
+materially worse — the escape hatch is a host builtin for the hot path, not a
+second runtime.
+
+Boot cost is small: about 80–140 ms to instantiate the wasm and load a plugin,
+paid once and lazily, so a session that never touches a plugin never pays it.
+The wasm is 529 KB, next to the 4.3 MB SQLite one.
@@ -0,0 +1,129 @@
+/**
+ * How much slower is an importer inside the sandbox? Yaak's OpenAPI importer is
+ * first-party JavaScript, so a large spec is parsed by whatever engine the
+ * runtime uses. Numbers are in the README.
+ *
+ *   node packages/plugin-sandbox/bench/import.mjs <spec.json> [iterations]
+ */
+
+import { build } from "esbuild";
+import { mkdirSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { pathToFileURL } from "node:url";
+import { bundlePlugin } from "../../../scripts/bundle-sandbox-plugins.mjs";
+
+const root = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "..");
+const PLUGIN = "importer-openapi";
+
+const specPath = process.argv[2];
+const iterations = Number(process.argv[3] ?? 3);
+if (specPath == null) {
+  console.error("usage: node bench/import.mjs <spec.json> [iterations]");
+  process.exit(1);
+}
+
+const spec = readFileSync(specPath, "utf8");
+console.log(`Spec: ${specPath} (${(spec.length / 1024 / 1024).toFixed(1)} MB)`);
+console.log(`Iterations: ${iterations}\n`);
+
+async function loadHost() {
+  const outDir = join(root, "node_modules", ".cache", "yaak-plugin-sandbox");
+  mkdirSync(outDir, { recursive: true });
+  const outfile = join(outDir, "host.mjs");
+  await build({
+    entryPoints: [join(root, "packages/plugin-sandbox/src/host/sandbox.ts")],
+    bundle: true,
+    format: "esm",
+    platform: "node",
+    target: "node22",
+    outfile,
+    // Resolved from the repo at run time, so the wasm variant is the real one.
+    external: ["@jitl/*", "quickjs-emscripten-core"],
+  });
+  return import(pathToFileURL(outfile).href);
+}
+
+const ctxStub = { id: "bench", label: null, workspaceId: "wk_bench" };
+
+function stats(times) {
+  const sorted = [...times].sort((a, b) => a - b);
+  const mean = times.reduce((a, b) => a + b, 0) / times.length;
+  return { min: sorted[0], median: sorted[Math.floor(sorted.length / 2)], mean };
+}
+
+function report(label, times, resourceCount) {
+  const { min, median } = stats(times);
+  console.log(
+    `${label.padEnd(20)} first ${times[0].toFixed(0).padStart(5)} ms   ` +
+      `best ${min.toFixed(0).padStart(5)} ms   ` +
+      `median ${median.toFixed(0).padStart(5)} ms   (${resourceCount} requests)`,
+  );
+  // The spread is the point: V8 compiles this across the first few passes and
+  // QuickJS does not compile at all.
+  console.log(`${" ".repeat(20)} runs: ${times.map((t) => t.toFixed(0)).join(", ")} ms`);
+  return { first: times[0], best: min };
+}
+
+/* --------------------------------- Node ---------------------------------- */
+
+const nodeTimes = [];
+let nodeCount = 0;
+{
+  const { createRequire } = await import("node:module");
+  const require = createRequire(join(root, "package.json"));
+  const mod = require(join(root, "plugins", PLUGIN, "build", "index.js"));
+  const plugin = mod.plugin ?? mod.default;
+
+  for (let i = 0; i < iterations; i++) {
+    const started = performance.now();
+    const result = await plugin.importer.onImport(ctxStub, { text: spec });
+    nodeTimes.push(performance.now() - started);
+    nodeCount = result?.resources?.httpRequests?.length ?? 0;
+  }
+}
+const node = report("Node (V8)", nodeTimes, nodeCount);
+
+/* -------------------------------- QuickJS -------------------------------- */
+
+const quickTimes = [];
+let quickCount = 0;
+{
+  const { PluginSandboxHost } = await loadHost();
+  const source = await bundlePlugin(PLUGIN);
+
+  const host = new PluginSandboxHost(
+    async () => JSON.stringify({ type: "empty_response" }),
+    (log) => console.error(`[${log.level}] ${log.message}`),
+  );
+
+  const loadStarted = performance.now();
+  await host.load(PLUGIN, source);
+  console.log(`(sandbox boot + load: ${(performance.now() - loadStarted).toFixed(0)} ms)\n`);
+
+  for (let i = 0; i < iterations; i++) {
+    const started = performance.now();
+    const reply = JSON.parse(
+      await host.dispatch(
+        PLUGIN,
+        JSON.stringify({ context: ctxStub, payload: { type: "import_request", content: spec } }),
+      ),
+    );
+    quickTimes.push(performance.now() - started);
+    if (reply.type === "error_response") throw new Error(reply.error);
+    quickCount = reply.resources?.httpRequests?.length ?? 0;
+  }
+  host.dispose();
+}
+const quick = report("QuickJS (sandbox)", quickTimes, quickCount);
+
+console.log(
+  `\nFirst run (what a user waits for): ${(quick.first / 1000).toFixed(1)}s in the sandbox ` +
+    `vs ${(node.first / 1000).toFixed(1)}s in Node — ${(quick.first / node.first).toFixed(1)}x.`,
+);
+console.log(
+  `Best run (both warm): ${(quick.best / node.best).toFixed(1)}x, which is the ceiling once V8 has compiled.`,
+);
+if (nodeCount !== quickCount) {
+  console.log(`WARNING: request counts differ (${nodeCount} vs ${quickCount}) — not the same work.`);
+}
@@ -0,0 +1,42 @@
+/**
+ * The shell has to reach QuickJS as source text. Emitted as a `.ts` module, not
+ * a `.js` asset, so Vite and plain Node get at it the same way. Committed, like
+ * the wasm packages, so a checkout builds without this having run.
+ */
+
+import { build } from "esbuild";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const here = dirname(fileURLToPath(import.meta.url));
+const outDir = join(here, "src", "generated");
+
+const result = await build({
+  entryPoints: [join(here, "src", "guest", "index.ts")],
+  bundle: true,
+  write: false,
+  format: "iife",
+  platform: "browser",
+  target: "es2022",
+  minify: false,
+  legalComments: "none",
+});
+
+const source = result.outputFiles[0].text;
+
+mkdirSync(outDir, { recursive: true });
+writeFileSync(
+  join(outDir, "guest.ts"),
+  [
+    "// Generated by build-guest.mjs. Do not edit.",
+    "//",
+    "// The runtime shell, as source text, for evaluation inside QuickJS.",
+    "// Regenerate with `npm run build --workspace @yaakapp-internal/plugin-sandbox`.",
+    "",
+    `export const GUEST_SOURCE = ${JSON.stringify(source)};`,
+    "",
+  ].join("\n"),
+);
+
+console.log(`Bundled guest shell: ${(source.length / 1024).toFixed(1)} KB`);
@@ -0,0 +1,17 @@
+{
+  "name": "@yaakapp-internal/plugin-sandbox",
+  "version": "1.0.0",
+  "private": true,
+  "main": "src/index.ts",
+  "scripts": {
+    "bootstrap": "npm run build",
+    "build": "node build-guest.mjs"
+  },
+  "dependencies": {
+    "@jitl/quickjs-ng-wasmfile-release-sync": "^0.32.0",
+    "quickjs-emscripten-core": "^0.32.0"
+  },
+  "devDependencies": {
+    "esbuild": "^0.28.0"
+  }
+}
@@ -0,0 +1,238 @@
+/**
+ * Everything a plugin can reach that isn't the language itself. The Rust host
+ * must install this same list; see the README.
+ */
+
+declare const __yaak_log: (level: string, message: string) => void;
+declare const __yaak_timer_start: (id: number, ms: number) => void;
+declare const __yaak_timer_cancel: (id: number) => void;
+
+/* -------------------------------- console -------------------------------- */
+
+/** Formatted in here, so only strings cross the boundary. */
+function formatArgs(args: unknown[]): string {
+  return args
+    .map((arg) => {
+      if (typeof arg === "string") return arg;
+      if (arg instanceof Error) return arg.stack ?? `${arg.name}: ${arg.message}`;
+      try {
+        return JSON.stringify(arg, replacer()) ?? String(arg);
+      } catch {
+        return String(arg);
+      }
+    })
+    .join(" ");
+}
+
+function replacer(): (key: string, value: unknown) => unknown {
+  const seen = new WeakSet<object>();
+  return (_key, value) => {
+    if (typeof value === "bigint") return `${value}n`;
+    if (typeof value === "function") return `[Function ${value.name || "anonymous"}]`;
+    if (typeof value === "object" && value !== null) {
+      if (seen.has(value)) return "[Circular]";
+      seen.add(value);
+    }
+    return value;
+  };
+}
+
+function installConsole(): void {
+  const log = (level: string) => (...args: unknown[]) => __yaak_log(level, formatArgs(args));
+  (globalThis as Record<string, unknown>).console = {
+    log: log("log"),
+    info: log("info"),
+    warn: log("warn"),
+    error: log("error"),
+    debug: log("debug"),
+    trace: log("debug"),
+  };
+}
+
+/* --------------------------------- timers -------------------------------- */
+
+/** QuickJS has no clock to wake on, so the host holds the real timer. */
+const timerCallbacks = new Map<number, () => void>();
+let nextTimerId = 1;
+
+function installTimers(): void {
+  const g = globalThis as Record<string, unknown>;
+
+  g.setTimeout = (callback: (...a: unknown[]) => void, ms?: number, ...args: unknown[]) => {
+    const id = nextTimerId++;
+    timerCallbacks.set(id, () => callback(...args));
+    __yaak_timer_start(id, Math.max(0, Number(ms) || 0));
+    return id;
+  };
+
+  g.clearTimeout = (id: number) => {
+    if (!timerCallbacks.delete(id)) return;
+    __yaak_timer_cancel(id);
+  };
+
+  // An interval is a timer that rearms, and nothing in a plugin should poll.
+  g.setInterval = undefined;
+  g.clearInterval = undefined;
+}
+
+/** Called by the host when a timer comes due. */
+function fireTimer(id: number): void {
+  const callback = timerCallbacks.get(id);
+  timerCallbacks.delete(id);
+  callback?.();
+}
+
+/* ------------------------------- text codecs ------------------------------ */
+
+class SandboxTextEncoder {
+  readonly encoding = "utf-8";
+
+  encode(input = ""): Uint8Array {
+    const out: number[] = [];
+    for (let i = 0; i < input.length; i++) {
+      let code = input.charCodeAt(i);
+      // A lone surrogate becomes U+FFFD, as the standard encoder does.
+      if (code >= 0xd800 && code <= 0xdbff) {
+        const next = input.charCodeAt(i + 1);
+        if (next >= 0xdc00 && next <= 0xdfff) {
+          code = (code - 0xd800) * 0x400 + (next - 0xdc00) + 0x10000;
+          i++;
+        } else {
+          code = 0xfffd;
+        }
+      } else if (code >= 0xdc00 && code <= 0xdfff) {
+        code = 0xfffd;
+      }
+
+      if (code < 0x80) out.push(code);
+      else if (code < 0x800) out.push(0xc0 | (code >> 6), 0x80 | (code & 0x3f));
+      else if (code < 0x10000)
+        out.push(0xe0 | (code >> 12), 0x80 | ((code >> 6) & 0x3f), 0x80 | (code & 0x3f));
+      else
+        out.push(
+          0xf0 | (code >> 18),
+          0x80 | ((code >> 12) & 0x3f),
+          0x80 | ((code >> 6) & 0x3f),
+          0x80 | (code & 0x3f),
+        );
+    }
+    return new Uint8Array(out);
+  }
+}
+
+class SandboxTextDecoder {
+  readonly encoding = "utf-8";
+
+  decode(input?: ArrayBuffer | ArrayBufferView): string {
+    if (input == null) return "";
+    const bytes =
+      input instanceof Uint8Array
+        ? input
+        : ArrayBuffer.isView(input)
+          ? new Uint8Array(input.buffer, input.byteOffset, input.byteLength)
+          : new Uint8Array(input);
+
+    let out = "";
+    for (let i = 0; i < bytes.length; ) {
+      const byte = bytes[i]!;
+      let code: number;
+      let size: number;
+      if (byte < 0x80) {
+        code = byte;
+        size = 1;
+      } else if ((byte & 0xe0) === 0xc0) {
+        code = byte & 0x1f;
+        size = 2;
+      } else if ((byte & 0xf0) === 0xe0) {
+        code = byte & 0x0f;
+        size = 3;
+      } else if ((byte & 0xf8) === 0xf0) {
+        code = byte & 0x07;
+        size = 4;
+      } else {
+        out += "�";
+        i++;
+        continue;
+      }
+
+      if (i + size > bytes.length) {
+        out += "�";
+        break;
+      }
+      for (let k = 1; k < size; k++) {
+        const cont = bytes[i + k]!;
+        if ((cont & 0xc0) !== 0x80) {
+          code = -1;
+          break;
+        }
+        code = (code << 6) | (cont & 0x3f);
+      }
+      i += size;
+
+      if (code < 0 || code > 0x10ffff || (code >= 0xd800 && code <= 0xdfff)) out += "�";
+      else if (code < 0x10000) out += String.fromCharCode(code);
+      else {
+        const c = code - 0x10000;
+        out += String.fromCharCode(0xd800 + (c >> 10), 0xdc00 + (c & 0x3ff));
+      }
+    }
+    return out;
+  }
+}
+
+function installTextCodecs(): void {
+  const g = globalThis as Record<string, unknown>;
+  g.TextEncoder = SandboxTextEncoder;
+  g.TextDecoder = SandboxTextDecoder;
+}
+
+/* ------------------------------ base64 helpers ---------------------------- */
+
+const B64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+function installBase64(): void {
+  const g = globalThis as Record<string, unknown>;
+
+  g.btoa = (input: string): string => {
+    let out = "";
+    for (let i = 0; i < input.length; i += 3) {
+      const a = input.charCodeAt(i);
+      const b = input.charCodeAt(i + 1);
+      const c = input.charCodeAt(i + 2);
+      if (a > 0xff || b > 0xff || c > 0xff) {
+        throw new Error("btoa: string contains characters outside of the Latin1 range");
+      }
+      const chunk = (a << 16) | ((Number.isNaN(b) ? 0 : b) << 8) | (Number.isNaN(c) ? 0 : c);
+      out += B64[(chunk >> 18) & 63]! + B64[(chunk >> 12) & 63]!;
+      out += Number.isNaN(b) ? "=" : B64[(chunk >> 6) & 63]!;
+      out += Number.isNaN(c) ? "=" : B64[chunk & 63]!;
+    }
+    return out;
+  };
+
+  g.atob = (input: string): string => {
+    const clean = input.replace(/[\t\n\f\r ]/g, "").replace(/=+$/, "");
+    let out = "";
+    let bits = 0;
+    let acc = 0;
+    for (const ch of clean) {
+      const value = B64.indexOf(ch);
+      if (value < 0) throw new Error("atob: string contains invalid characters");
+      acc = (acc << 6) | value;
+      bits += 6;
+      if (bits >= 8) {
+        bits -= 8;
+        out += String.fromCharCode((acc >> bits) & 0xff);
+      }
+    }
+    return out;
+  };
+}
+
+export function installGlobals(): { fireTimer: (id: number) => void } {
+  installConsole();
+  installTimers();
+  installTextCodecs();
+  installBase64();
+  return { fireTimer };
+}
@@ -0,0 +1,333 @@
+/**
+ * What QuickJS evaluates before any untrusted code does: install globals, load
+ * one module, answer events against it.
+ *
+ * `load` takes source and `dispatch` takes an event, so what a module *is* — a
+ * plugin today, a workspace script later — is the host's decision, not this
+ * file's. See the README on why scripts never get a second runtime.
+ */
+
+import type { PluginDefinition } from "@yaakapp/api";
+import {
+  applyFormInputDefaults,
+  validateTemplateFunctionArgs,
+} from "@yaakapp-internal/lib/templateFunction";
+import {
+  applyDynamicFormInput,
+  migrateTemplateFunctionSelectOptions,
+  stripDynamicCallbacks,
+} from "@yaakapp-internal/lib/pluginForms";
+import type {
+  GrpcRequestAction,
+  HttpAuthenticationAction,
+  HttpRequestAction,
+  ImportResources,
+  InternalEventPayload,
+  PluginContext,
+  TemplateFunction,
+} from "@yaakapp-internal/plugins";
+import {
+  createPluginContext,
+  type PluginTransport,
+} from "@yaakapp-internal/lib/pluginContext";
+import { installGlobals } from "./globals";
+
+declare const __yaak_call: (payloadJson: string) => Promise<string>;
+
+const { fireTimer } = installGlobals();
+
+let mod: PluginDefinition = {};
+let pluginRefId = "";
+
+/**
+ * `require` exists only to fail, by name: a bundle that still calls it was not
+ * built for this target, and naming the specifier beats an undefined that
+ * surfaces ten frames later.
+ */
+function load(source: string, refId: string): void {
+  const module: { exports: Record<string, unknown> } = { exports: {} };
+  const require = (specifier: string) => {
+    throw new Error(
+      `Module "${specifier}" is not available in the sandbox runtime. ` +
+        `Plugins must be bundled with no external or built-in modules.`,
+    );
+  };
+
+  // Isolation is the QuickJS context around this, not a lint rule.
+  // oxlint-disable-next-line no-implied-eval
+  const factory = new Function("module", "exports", "require", source);
+  factory(module, module.exports, require);
+
+  const loaded = (module.exports.plugin ?? module.exports.default) as PluginDefinition | undefined;
+  if (loaded == null || typeof loaded !== "object") {
+    throw new Error("Module did not export `plugin`");
+  }
+  mod = loaded;
+  pluginRefId = refId;
+}
+
+function summary(): Record<string, unknown> {
+  return {
+    templateFunctions: (mod.templateFunctions ?? []).map((f) => f.name),
+    authentication: mod.authentication?.name ?? null,
+    importer: mod.importer != null,
+    filter: mod.filter != null,
+    themes: (mod.themes ?? []).length,
+    httpRequestActions: (mod.httpRequestActions ?? []).length,
+    workspaceActions: (mod.workspaceActions ?? []).length,
+    folderActions: (mod.folderActions ?? []).length,
+    grpcRequestActions: (mod.grpcRequestActions ?? []).length,
+    websocketRequestActions: (mod.websocketRequestActions ?? []).length,
+  };
+}
+
+const EMPTY: InternalEventPayload = { type: "empty_response" };
+
+/**
+ * Every branch mirrors the Node runtime's: same payloads, so a plugin cannot
+ * tell which runtime it is in. An unmatched event gets `empty_response` rather
+ * than silence, so no caller waits forever.
+ */
+/**
+ * No `stream` and no `form`: both need the host to hold a conversation open,
+ * which this protocol deliberately does not. `openUrl` refuses and a prompt
+ * form is drawn once from its defaults, rather than quietly doing nothing.
+ */
+const transport: PluginTransport = {
+  async request(context, payload) {
+    // The id rides along because one host handler serves every loaded module,
+    // and a plugin's storage is namespaced by which plugin it is.
+    const replyJson = await __yaak_call(JSON.stringify({ pluginRefId, context, payload }));
+    const reply = JSON.parse(replyJson) as InternalEventPayload & { error?: string };
+    if (reply.type === "error_response") {
+      throw new Error(reply.error || `Host failed to handle ${payload.type}`);
+    }
+    const { type: _type, ...rest } = reply;
+    return rest as Record<string, unknown>;
+  },
+  notify(context, payload) {
+    void __yaak_call(JSON.stringify({ pluginRefId, context, payload }));
+  },
+};
+
+async function dispatch(
+  context: PluginContext,
+  payload: InternalEventPayload,
+): Promise<InternalEventPayload> {
+  const ctx = createPluginContext(transport, context);
+
+  if (payload.type === "boot_request") {
+    await mod.init?.(ctx);
+    return { type: "boot_response" };
+  }
+
+  if (payload.type === "terminate_request") {
+    await mod.dispose?.();
+    return { type: "terminate_response" };
+  }
+
+  if (payload.type === "import_request" && typeof mod.importer?.onImport === "function") {
+    const reply = await mod.importer.onImport(ctx, { text: payload.content });
+    if (reply != null) {
+      return { type: "import_response", resources: reply.resources as ImportResources };
+    }
+    return EMPTY;
+  }
+
+  if (payload.type === "filter_request" && typeof mod.filter?.onFilter === "function") {
+    const reply = await mod.filter.onFilter(ctx, {
+      filter: payload.filter,
+      payload: payload.content,
+      mimeType: payload.type,
+    });
+    return { type: "filter_response", ...reply };
+  }
+
+  if (payload.type === "get_themes_request" && Array.isArray(mod.themes)) {
+    return { type: "get_themes_response", themes: mod.themes };
+  }
+
+  /* --------------------------- template functions -------------------------- */
+
+  if (
+    payload.type === "get_template_function_summary_request" &&
+    Array.isArray(mod.templateFunctions)
+  ) {
+    const functions: TemplateFunction[] = mod.templateFunctions.map((f) => ({
+      ...migrateTemplateFunctionSelectOptions(f),
+      onRender: undefined,
+    }));
+    return { type: "get_template_function_summary_response", pluginRefId, functions };
+  }
+
+  if (
+    payload.type === "get_template_function_config_request" &&
+    Array.isArray(mod.templateFunctions)
+  ) {
+    const found = mod.templateFunctions.find((f) => f.name === payload.name);
+    if (found == null) return EMPTY;
+
+    const fn = { ...migrateTemplateFunctionSelectOptions(found), onRender: undefined };
+    payload.values = applyFormInputDefaults(fn.args, payload.values);
+    const resolved = await applyDynamicFormInput(ctx, fn.args, {
+      ...payload,
+      purpose: "preview",
+    } as const);
+
+    return {
+      type: "get_template_function_config_response",
+      pluginRefId,
+      function: { ...fn, args: stripDynamicCallbacks(resolved) },
+    };
+  }
+
+  if (payload.type === "call_template_function_request" && Array.isArray(mod.templateFunctions)) {
+    const fn = mod.templateFunctions.find((f) => f.name === payload.name);
+
+    if (
+      payload.args.purpose === "preview" &&
+      (fn?.previewType === "click" || fn?.previewType === "none")
+    ) {
+      return {
+        type: "call_template_function_response",
+        value: null,
+        error: "Live preview disabled for this function",
+      };
+    }
+
+    if (typeof fn?.onRender === "function") {
+      const resolved = await applyDynamicFormInput(ctx, fn.args, payload.args);
+      const values = applyFormInputDefaults(resolved, payload.args.values);
+      const error = validateTemplateFunctionArgs(fn.name, resolved, values);
+      if (error && payload.args.purpose !== "preview") {
+        return { type: "call_template_function_response", value: null, error };
+      }
+
+      const result = await fn.onRender(ctx, { ...payload.args, values });
+      return { type: "call_template_function_response", value: result ?? null };
+    }
+  }
+
+  /* --------------------------- http authentication ------------------------- */
+
+  if (payload.type === "get_http_authentication_summary_request" && mod.authentication) {
+    return { type: "get_http_authentication_summary_response", ...mod.authentication };
+  }
+
+  if (payload.type === "get_http_authentication_config_request" && mod.authentication) {
+    const { args, actions } = mod.authentication;
+    payload.values = applyFormInputDefaults(args, payload.values);
+    const resolved = await applyDynamicFormInput(ctx, args, payload);
+    const resolvedActions: HttpAuthenticationAction[] = [];
+    // oxlint-disable-next-line unbound-method
+    for (const { onSelect: _onSelect, ...action } of actions ?? []) resolvedActions.push(action);
+
+    return {
+      type: "get_http_authentication_config_response",
+      args: stripDynamicCallbacks(resolved),
+      actions: resolvedActions,
+      pluginRefId,
+    };
+  }
+
+  if (payload.type === "call_http_authentication_request" && mod.authentication) {
+    const auth = mod.authentication;
+    if (typeof auth.onApply === "function") {
+      const resolved = await applyDynamicFormInput(ctx, auth.args, payload);
+      payload.values = applyFormInputDefaults(resolved, payload.values);
+      return { type: "call_http_authentication_response", ...(await auth.onApply(ctx, payload)) };
+    }
+  }
+
+  if (payload.type === "call_http_authentication_action_request" && mod.authentication != null) {
+    const action = mod.authentication.actions?.[payload.index];
+    if (typeof action?.onSelect === "function") {
+      await action.onSelect(ctx, payload.args);
+      return EMPTY;
+    }
+  }
+
+  /* --------------------------------- actions ------------------------------- */
+
+  if (payload.type === "get_http_request_actions_request" && Array.isArray(mod.httpRequestActions)) {
+    const actions: HttpRequestAction[] = mod.httpRequestActions.map((a) => ({
+      ...a,
+      onSelect: undefined,
+    }));
+    return { type: "get_http_request_actions_response", pluginRefId, actions };
+  }
+
+  if (
+    payload.type === "get_websocket_request_actions_request" &&
+    Array.isArray(mod.websocketRequestActions)
+  ) {
+    const actions = mod.websocketRequestActions.map((a) => ({ ...a, onSelect: undefined }));
+    return { type: "get_websocket_request_actions_response", pluginRefId, actions };
+  }
+
+  if (payload.type === "get_grpc_request_actions_request" && Array.isArray(mod.grpcRequestActions)) {
+    const actions: GrpcRequestAction[] = mod.grpcRequestActions.map((a) => ({
+      ...a,
+      onSelect: undefined,
+    }));
+    return { type: "get_grpc_request_actions_response", pluginRefId, actions };
+  }
+
+  if (payload.type === "get_workspace_actions_request" && Array.isArray(mod.workspaceActions)) {
+    const actions = mod.workspaceActions.map((a) => ({ ...a, onSelect: undefined }));
+    return { type: "get_workspace_actions_response", pluginRefId, actions };
+  }
+
+  if (payload.type === "get_folder_actions_request" && Array.isArray(mod.folderActions)) {
+    const actions = mod.folderActions.map((a) => ({ ...a, onSelect: undefined }));
+    return { type: "get_folder_actions_response", pluginRefId, actions };
+  }
+
+  const called = await callAction(ctx, payload);
+  if (called) return EMPTY;
+
+  return EMPTY;
+}
+
+async function callAction(
+  ctx: ReturnType<typeof createPluginContext>,
+  payload: InternalEventPayload,
+): Promise<boolean> {
+  const lists = {
+    call_http_request_action_request: mod.httpRequestActions,
+    call_websocket_request_action_request: mod.websocketRequestActions,
+    call_grpc_request_action_request: mod.grpcRequestActions,
+    call_workspace_action_request: mod.workspaceActions,
+    call_folder_action_request: mod.folderActions,
+  } as const;
+
+  const list = lists[payload.type as keyof typeof lists];
+  if (!Array.isArray(list)) return false;
+
+  const action = list[(payload as { index: number }).index];
+  if (typeof action?.onSelect !== "function") return false;
+
+  await action.onSelect(ctx, (payload as { args: never }).args);
+  return true;
+}
+
+
+
+(globalThis as Record<string, unknown>).__yaak_guest = {
+  load,
+  summary,
+  fireTimer,
+  dispatch: async (envelopeJson: string): Promise<string> => {
+    const { context, payload } = JSON.parse(envelopeJson) as {
+      context: PluginContext;
+      payload: InternalEventPayload;
+    };
+    try {
+      return JSON.stringify(await dispatch(context, payload));
+    } catch (err) {
+      // A throw from a plugin is an answer, not a crash.
+      const error = (err instanceof Error ? err.message : String(err)).replace(/^Error:\s*/g, "");
+      return JSON.stringify({ type: "error_response", error });
+    }
+  },
+};
@@ -0,0 +1,312 @@
+/**
+ * One runtime, one context per module. The engine choice and the limits below
+ * are argued in this package's README, which is also the spec for the Rust host.
+ */
+
+import variant from "@jitl/quickjs-ng-wasmfile-release-sync";
+import {
+  newQuickJSWASMModuleFromVariant,
+  type QuickJSContext,
+  type QuickJSRuntime,
+  type QuickJSWASMModule,
+} from "quickjs-emscripten-core";
+import { GUEST_SOURCE } from "../generated/guest";
+
+const MEMORY_LIMIT_BYTES = 256 * 1024 * 1024;
+
+const STACK_SIZE_BYTES = 2 * 1024 * 1024;
+
+/** Bounds synchronous execution only: a plugin awaiting the host is not looping. */
+const SYNC_BUDGET_MS = 60_000;
+
+export type HostRequestHandler = (envelopeJson: string) => Promise<string>;
+
+export interface SandboxLog {
+  pluginRefId: string;
+  level: string;
+  message: string;
+}
+
+let modulePromise: Promise<QuickJSWASMModule> | null = null;
+
+function quickjs(): Promise<QuickJSWASMModule> {
+  modulePromise ??= newQuickJSWASMModuleFromVariant(variant);
+  return modulePromise;
+}
+
+class LoadedPlugin {
+  readonly pluginRefId: string;
+  readonly context: QuickJSContext;
+  /** Set while a dispatch is running; the interrupt handler reads it. */
+  deadline: number | null = null;
+  private nextTimer = new Map<number, ReturnType<typeof setTimeout>>();
+  private disposed = false;
+
+  constructor(pluginRefId: string, context: QuickJSContext) {
+    this.pluginRefId = pluginRefId;
+    this.context = context;
+  }
+
+  touch(): void {
+    if (this.deadline != null) this.deadline = Date.now() + SYNC_BUDGET_MS;
+  }
+
+  startTimer(id: number, ms: number, fire: () => void): void {
+    this.nextTimer.set(
+      id,
+      setTimeout(() => {
+        this.nextTimer.delete(id);
+        if (!this.disposed) fire();
+      }, ms),
+    );
+  }
+
+  cancelTimer(id: number): void {
+    const handle = this.nextTimer.get(id);
+    if (handle == null) return;
+    clearTimeout(handle);
+    this.nextTimer.delete(id);
+  }
+
+  dispose(): void {
+    if (this.disposed) return;
+    this.disposed = true;
+    for (const handle of this.nextTimer.values()) clearTimeout(handle);
+    this.nextTimer.clear();
+    this.context.dispose();
+  }
+}
+
+export class PluginSandboxHost {
+  private runtime: QuickJSRuntime | null = null;
+  private readonly plugins = new Map<string, LoadedPlugin>();
+
+  constructor(
+    private readonly onHostRequest: HostRequestHandler,
+    private readonly onLog: (log: SandboxLog) => void,
+  ) {}
+
+  async load(pluginRefId: string, source: string): Promise<Record<string, unknown>> {
+    const module = await quickjs();
+
+    if (this.runtime == null) {
+      this.runtime = module.newRuntime();
+      this.runtime.setMemoryLimit(MEMORY_LIMIT_BYTES);
+      this.runtime.setMaxStackSize(STACK_SIZE_BYTES);
+      this.runtime.setInterruptHandler(() => {
+        const now = Date.now();
+        for (const plugin of this.plugins.values()) {
+          if (plugin.deadline != null && now > plugin.deadline) return true;
+        }
+        return false;
+      });
+    }
+
+    this.plugins.get(pluginRefId)?.dispose();
+
+    const plugin = new LoadedPlugin(pluginRefId, this.runtime.newContext());
+    this.plugins.set(pluginRefId, plugin);
+
+    try {
+      this.installHostFunctions(plugin);
+      this.evalOrThrow(plugin, GUEST_SOURCE, "yaak:sandbox-shell");
+      await this.callGuest(plugin, "load", [source, pluginRefId]);
+      return await this.callGuest(plugin, "summary", []);
+    } catch (err) {
+      plugin.dispose();
+      this.plugins.delete(pluginRefId);
+      throw err;
+    }
+  }
+
+  loaded(): string[] {
+    return Array.from(this.plugins.keys());
+  }
+
+  unload(pluginRefId: string): void {
+    this.plugins.get(pluginRefId)?.dispose();
+    this.plugins.delete(pluginRefId);
+  }
+
+  async dispatch(pluginRefId: string, envelopeJson: string): Promise<string> {
+    const plugin = this.plugins.get(pluginRefId);
+    if (plugin == null) throw new Error(`No plugin loaded as \`${pluginRefId}\``);
+    const reply = await this.callGuest(plugin, "dispatch", [envelopeJson]);
+    return reply as unknown as string;
+  }
+
+  dispose(): void {
+    for (const plugin of this.plugins.values()) plugin.dispose();
+    this.plugins.clear();
+    this.runtime?.dispose();
+    this.runtime = null;
+  }
+
+  /* ------------------------------ internals ------------------------------- */
+
+  private installHostFunctions(plugin: LoadedPlugin): void {
+    const { context } = plugin;
+
+    const define = (name: string, fn: Parameters<QuickJSContext["newFunction"]>[1]) => {
+      const handle = context.newFunction(name, fn);
+      context.setProp(context.global, name, handle);
+      handle.dispose();
+    };
+
+    define("__yaak_log", (levelHandle, messageHandle) => {
+      this.onLog({
+        pluginRefId: plugin.pluginRefId,
+        level: context.getString(levelHandle),
+        message: context.getString(messageHandle),
+      });
+    });
+
+    define("__yaak_timer_start", (idHandle, msHandle) => {
+      const id = context.getNumber(idHandle);
+      plugin.startTimer(id, context.getNumber(msHandle), () => {
+          plugin.touch();
+        this.callGuestSync(plugin, "fireTimer", [id]);
+        this.pump(plugin);
+      });
+    });
+
+    define("__yaak_timer_cancel", (idHandle) => {
+      plugin.cancelTimer(context.getNumber(idHandle));
+    });
+
+    define("__yaak_call", (envelopeHandle) => {
+      const envelope = context.getString(envelopeHandle);
+
+      const wasWatching = plugin.deadline != null;
+      plugin.deadline = null;
+
+      const settle = this.onHostRequest(envelope).then(
+        (reply) => {
+          if (wasWatching) plugin.touch();
+          return context.newString(reply);
+        },
+        (err: unknown) => {
+          if (wasWatching) plugin.touch();
+          return context.newError(err instanceof Error ? err.message : String(err));
+        },
+      );
+
+      const deferred = context.newPromise(settle);
+      void deferred.settled.then(() => {
+        this.pump(plugin);
+        deferred.dispose();
+      });
+      return deferred.handle;
+    });
+  }
+
+  private pump(plugin: LoadedPlugin): void {
+    const result = this.runtime?.executePendingJobs();
+    if (result?.error != null) {
+      this.onLog({
+        pluginRefId: plugin.pluginRefId,
+        level: "error",
+        message: `Unhandled error in sandbox: ${result.error.consume(
+          plugin.context.dump.bind(plugin.context),
+        )}`,
+      });
+    }
+  }
+
+  private evalOrThrow(plugin: LoadedPlugin, source: string, filename: string): void {
+    plugin.deadline = Date.now() + SYNC_BUDGET_MS;
+    try {
+      const result = plugin.context.evalCode(source, filename);
+      if (result.error != null) {
+        throw this.toError(plugin, result.error.consume(plugin.context.dump.bind(plugin.context)));
+      }
+      result.value.dispose();
+    } finally {
+      plugin.deadline = null;
+    }
+  }
+
+  private async callGuest(
+    plugin: LoadedPlugin,
+    method: string,
+    args: (string | number)[],
+    // oxlint-disable-next-line no-explicit-any -- the caller knows the guest's shape
+  ): Promise<any> {
+    const { context } = plugin;
+    plugin.deadline = Date.now() + SYNC_BUDGET_MS;
+
+    const guest = context.getProp(context.global, "__yaak_guest");
+    const fn = context.getProp(guest, method);
+    const argHandles = args.map((a) =>
+      typeof a === "string" ? context.newString(a) : context.newNumber(a),
+    );
+
+    try {
+      const called = context.callFunction(fn, guest, ...argHandles);
+      if (called.error != null) {
+        throw this.toError(plugin, called.error.consume(context.dump.bind(context)));
+      }
+
+      const value = called.value;
+      const state = context.getPromiseState(value);
+      if (state.type !== "fulfilled" || state.notAPromise !== true) {
+        const resolved = context.resolvePromise(value);
+        value.dispose();
+        this.pump(plugin);
+        const settled = await resolved;
+        if (settled.error != null) {
+          throw this.toError(plugin, settled.error.consume(context.dump.bind(context)));
+        }
+        return settled.value.consume(context.dump.bind(context));
+      }
+
+      return value.consume(context.dump.bind(context));
+    } finally {
+      plugin.deadline = null;
+      for (const handle of argHandles) handle.dispose();
+      fn.dispose();
+      guest.dispose();
+    }
+  }
+
+  private callGuestSync(plugin: LoadedPlugin, method: string, args: number[]): void {
+    const { context } = plugin;
+    const guest = context.getProp(context.global, "__yaak_guest");
+    const fn = context.getProp(guest, method);
+    const argHandles = args.map((a) => context.newNumber(a));
+    try {
+      const called = context.callFunction(fn, guest, ...argHandles);
+      if (called.error != null) {
+        this.onLog({
+          pluginRefId: plugin.pluginRefId,
+          level: "error",
+          message: String(this.toError(plugin, called.error.consume(context.dump.bind(context)))),
+        });
+      } else {
+        called.value.dispose();
+      }
+    } finally {
+      for (const handle of argHandles) handle.dispose();
+      fn.dispose();
+      guest.dispose();
+    }
+  }
+
+  private toError(plugin: LoadedPlugin, dumped: unknown): Error {
+    if (dumped != null && typeof dumped === "object") {
+      const { message, name, stack } = dumped as Record<string, string | undefined>;
+      const error = new Error(message ?? JSON.stringify(dumped));
+      if (name != null) error.name = name;
+      if (stack != null) error.stack = `${name ?? "Error"}: ${message ?? ""}\n${stack}`;
+      return error;
+    }
+    // An interrupted plugin surfaces as `null` with no error object.
+    if (dumped == null) {
+      return new Error(
+        `Plugin \`${plugin.pluginRefId}\` was stopped after running for ` +
+          `${SYNC_BUDGET_MS / 1000}s without yielding`,
+      );
+    }
+    return new Error(typeof dumped === "string" ? dumped : JSON.stringify(dumped));
+  }
+}
@@ -0,0 +1,137 @@
+/**
+ * A tab's handle on its sandbox. `onHostRequest` is the entire answer to "what
+ * can a plugin do here?", and this package deliberately has no opinion on it.
+ */
+
+import type { FromSandbox, ToSandbox } from "./protocol";
+
+
+/** Answers one `ctx` call: JSON envelope in, JSON reply out. */
+export type HostRequestHandler = (envelope: string) => Promise<string>;
+
+export interface PluginSandboxOptions {
+  onHostRequest: HostRequestHandler;
+  onLog?: (log: { pluginRefId: string; level: string; message: string }) => void;
+}
+
+export interface PluginSummary {
+  templateFunctions: string[];
+  authentication: string | null;
+  importer: boolean;
+  filter: boolean;
+  themes: number;
+  httpRequestActions: number;
+  workspaceActions: number;
+  folderActions: number;
+  grpcRequestActions: number;
+  websocketRequestActions: number;
+}
+
+type Pending = { resolve: (value: unknown) => void; reject: (reason: Error) => void };
+
+export class PluginSandbox {
+  private readonly worker: Worker;
+  private readonly pending = new Map<number, Pending>();
+  private readonly options: PluginSandboxOptions;
+  private nextId = 1;
+
+  constructor(options: PluginSandboxOptions) {
+    this.options = options;
+
+    // Written inline because that exact syntax is what the bundler
+    // pattern-matches; hoisted into a variable it ships as raw TypeScript.
+    this.worker = new Worker(new URL("./worker.ts", import.meta.url), {
+      type: "module",
+      name: "yaak-plugins",
+    });
+    this.worker.onmessage = (e: MessageEvent<FromSandbox>) => this.receive(e.data);
+    this.worker.onerror = () => this.failEverything("The plugin sandbox failed to start");
+  }
+
+  load(pluginRefId: string, source: string): Promise<PluginSummary> {
+    return this.request<PluginSummary>((id) => ({ type: "load", id, pluginRefId, source }));
+  }
+
+  unload(pluginRefId: string): Promise<void> {
+    return this.request<void>((id) => ({ type: "unload", id, pluginRefId }));
+  }
+
+  async dispatch<T>(
+    pluginRefId: string,
+    context: unknown,
+    payload: unknown,
+  ): Promise<T & { type: string }> {
+    const envelope = JSON.stringify({ context, payload });
+    const reply = await this.request<string>((id) => ({
+      type: "dispatch",
+      id,
+      pluginRefId,
+      envelope,
+    }));
+    const parsed = JSON.parse(reply) as { type: string; error?: string };
+    if (parsed.type === "error_response") {
+      throw new Error(parsed.error || "Plugin failed");
+    }
+    return parsed as T & { type: string };
+  }
+
+  /** `terminate()`, not a polite shutdown: the reason to call this is a plugin that won't stop. */
+  dispose(): void {
+    this.worker.terminate();
+    this.failEverything("The plugin sandbox was shut down");
+  }
+
+  /* ------------------------------ internals ------------------------------- */
+
+  private request<T>(build: (id: number) => ToSandbox): Promise<T> {
+    const id = this.nextId++;
+    return new Promise<T>((resolve, reject) => {
+      this.pending.set(id, { resolve: resolve as (v: unknown) => void, reject });
+      this.worker.postMessage(build(id));
+    });
+  }
+
+  private receive(message: FromSandbox): void {
+    switch (message.type) {
+      case "result": {
+        const p = this.pending.get(message.id);
+        this.pending.delete(message.id);
+        p?.resolve(message.result);
+        return;
+      }
+      case "error": {
+        const p = this.pending.get(message.id);
+        this.pending.delete(message.id);
+        p?.reject(new Error(message.message));
+        return;
+      }
+      case "log":
+        this.options.onLog?.(message);
+        return;
+      case "host_call":
+        void this.answer(message.id, message.envelope);
+        return;
+    }
+  }
+
+  private async answer(id: number, envelope: string): Promise<void> {
+    let reply: ToSandbox;
+    try {
+      reply = { type: "host_result", id, reply: await this.options.onHostRequest(envelope) };
+    } catch (err) {
+      reply = {
+        type: "host_result",
+        id,
+        error: err instanceof Error ? err.message : String(err),
+      };
+    }
+    this.worker.postMessage(reply);
+  }
+
+  private failEverything(message: string): void {
+    for (const [id, p] of this.pending) {
+      this.pending.delete(id);
+      p.reject(new Error(message));
+    }
+  }
+}
@@ -0,0 +1,21 @@
+/**
+ * Two request/reply flows in opposite directions. Payloads are JSON strings
+ * rather than objects because they must be strings to cross into QuickJS
+ * anyway, so structured-cloning them first would only be undone.
+ */
+
+/** Tab → worker */
+export type ToSandbox =
+  | { type: "load"; id: number; pluginRefId: string; source: string }
+  | { type: "unload"; id: number; pluginRefId: string }
+  | { type: "dispatch"; id: number; pluginRefId: string; envelope: string }
+  /** The tab's answer to a `host_call`. */
+  | { type: "host_result"; id: number; reply?: string; error?: string };
+
+/** Worker → tab */
+export type FromSandbox =
+  | { type: "result"; id: number; result: unknown }
+  | { type: "error"; id: number; message: string }
+  /** A plugin wants something only the tab can provide. */
+  | { type: "host_call"; id: number; envelope: string }
+  | { type: "log"; pluginRefId: string; level: string; message: string };
@@ -0,0 +1,68 @@
+/// <reference lib="webworker" />
+
+/**
+ * A dedicated worker owned by the tab, deliberately not the SharedWorker that
+ * owns the database. Reasons and the cost are in the README.
+ */
+
+import { PluginSandboxHost } from "./host/sandbox";
+import type { FromSandbox, ToSandbox } from "./protocol";
+
+const scope = self as unknown as DedicatedWorkerGlobalScope;
+
+function send(message: FromSandbox): void {
+  scope.postMessage(message);
+}
+
+const pendingHostCalls = new Map<number, (reply: string | Error) => void>();
+let nextHostCallId = 1;
+
+const host = new PluginSandboxHost(
+  (envelope) =>
+    new Promise<string>((resolve, reject) => {
+      const id = nextHostCallId++;
+      pendingHostCalls.set(id, (reply) => (reply instanceof Error ? reject(reply) : resolve(reply)));
+      send({ type: "host_call", id, envelope });
+    }),
+  (log) => send({ type: "log", ...log }),
+);
+
+async function handle(message: ToSandbox): Promise<void> {
+  if (message.type === "host_result") {
+    const settle = pendingHostCalls.get(message.id);
+    pendingHostCalls.delete(message.id);
+    settle?.(message.error != null ? new Error(message.error) : (message.reply ?? "{}"));
+    return;
+  }
+
+  try {
+    switch (message.type) {
+      case "load":
+        send({
+          type: "result",
+          id: message.id,
+          result: await host.load(message.pluginRefId, message.source),
+        });
+        return;
+      case "unload":
+        host.unload(message.pluginRefId);
+        send({ type: "result", id: message.id, result: null });
+        return;
+      case "dispatch":
+        send({
+          type: "result",
+          id: message.id,
+          result: await host.dispatch(message.pluginRefId, message.envelope),
+        });
+        return;
+    }
+  } catch (err) {
+    send({
+      type: "error",
+      id: message.id,
+      message: err instanceof Error ? err.message : String(err),
+    });
+  }
+}
+
+scope.onmessage = (e: MessageEvent<ToSandbox>) => void handle(e.data);
@@ -5,7 +5,7 @@ import { forwardRef } from "react";
 import { Icon } from "./Icon";
 import { LoadingIcon } from "./LoadingIcon";

-type ButtonVariant = "border" | "solid" | "input";
+type ButtonVariant = "border" | "solid";
 type ButtonSize = "2xs" | "xs" | "sm" | "md" | "auto";

 export type ButtonProps = Omit<HTMLAttributes<HTMLButtonElement>, "color" | "onChange"> & {
@@ -88,9 +88,6 @@ export const Button = forwardRef<HTMLButtonElement, ButtonProps>(function Button
          resolvedColor !== "custom" &&
          "border-border-subtle text-text-subtle enabled:hocus:border-border " +
            "enabled:hocus:bg-surface-highlight enabled:hocus:text-text outline-border-subtler",
-        // Chrome of a form input rather than a button: no hover state, and colors resolve from the
-        // surrounding x-theme-input rather than a button theme.
-        variant === "input" && "border-border text-text",
      )}
      disabled={isDisabled}
      onClick={onClick}
@@ -11,8 +11,7 @@
  },
  "scripts": {
    "build": "yaakcli build",
-    "dev": "yaakcli dev",
-    "test": "vp test --run tests"
+    "dev": "yaakcli dev"
  },
  "dependencies": {
    "oauth-1.0a": "^2.2.6"
@@ -161,7 +161,7 @@ export const plugin: PluginDefinition = {
      if (values.timestamp) requestData.data.oauth_timestamp = String(values.timestamp);
      if (values.verifier) requestData.data.oauth_verifier = String(values.verifier);

-      let token: OAuth.Token | { key: string } | { secret: string } | undefined;
+      let token: OAuth.Token | { key: string } | undefined;

      if (pkSigs.includes(signatureMethod)) {
        token = {
@@ -172,10 +172,6 @@ export const plugin: PluginDefinition = {
        token = { key: String(values.tokenKey), secret: String(values.tokenSecret) };
      } else if (values.tokenKey) {
        token = { key: String(values.tokenKey) };
-      } else if (values.tokenSecret) {
-        // The secret still joins the signing key without an access token;
-        // leaving `key` out keeps oauth_token out of the header entirely
-        token = { secret: String(values.tokenSecret) };
      }

      const authParams = oauth.authorize(requestData, token as OAuth.Token | undefined);
@@ -206,10 +202,7 @@ function hashFunction(signatureMethod: SigMethod) {
      return (base: string, privateKey: string) =>
        crypto.createSign("RSA-SHA512").update(base).sign(privateKey, "base64");
    case signatures.PLAINTEXT:
-      // RFC 5849 3.4.4: the PLAINTEXT signature IS the signing key,
-      // `encoded(consumer secret)&encoded(token secret)`. Returning the base
-      // string put the whole percent-encoded request into oauth_signature.
-      return (_base: string, key: string) => key;
+      return (base: string) => base;
    default:
      return (base: string, key: string) =>
        crypto.createHmac("sha1", key).update(base).digest("base64");
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Gregory Schier	19c753c433	Merge branch 'main' into claude/serene-dewdney-4c1527	2026-08-20 09:06:44 -07:00
Gregory Schier	252b151fcb	Follow the yaak-web to yaak-wasm rename Rebased onto main after #572 merged. The wasm crate moved to crates/yaak-wasm and crates-server/yaak-web is now the server, so the render_template export, the regenerated pkg/ and the proxy/server wording move with them.	2026-08-18 15:26:10 -07:00
Gregory Schier	85ba3e6852	Cut comments back to the non-obvious Rationale that explains a decision rather than the code below it belongs in the sandbox README or the PR, not in a header paragraph on every file.	2026-08-18 15:23:10 -07:00
Gregory Schier	20c0efc2a5	Build ctx once and share it between both plugin runtimes The sandbox's context builder was a near-copy of the Node runtime's. Both now come from createPluginContext in @yaakapp-internal/lib, with each runtime supplying only a transport. The two places hosts genuinely differ are optional transport methods: `stream` (a window reporting navigation until it closes) and `form` (a prompt that re-renders as values change). The sandbox has neither, so openUrl refuses and a form is drawn once from its defaults.	2026-08-18 15:22:49 -07:00
Gregory Schier	f8d6dfbdaa	Run plugins in a QuickJS sandbox in the browser Adds packages/plugin-sandbox: QuickJS-ng compiled to wasm, running in a dedicated worker, with a runtime shell inside it that loads a plugin bundle and answers the same InternalEventPayload events the Node runtime answers. Plugins are unmodified. Wires the browser host's template function, authentication, cURL import and template render commands to it, and relaxes TemplateCallback's Send bound on wasm32 so the engine's renderer can call back out to a plugin.	2026-08-18 15:22:49 -07:00