@jant/core 0.5.1 → 0.5.2

package/dist/index.js

@@ -1,5 +1,5 @@
 import { _ as url_exports } from "./url-umUptr5z.js";
-import { A as NAV_ITEM_TYPES, C as toPostView, D as MAX_MEDIA_ATTACHMENTS, E as FORMATS, M as STATUSES, N as TEXT_ATTACHMENT_CONTENT_FORMATS, O as MAX_PINNED_POSTS, S as toNavItemViews, T as toSearchResultView, _ as createMediaContext, b as toMediaView, f as defaultFeedRenderer, j as SORT_ORDERS, k as MEDIA_KINDS, t as createApp, v as toArchiveGroups, w as toPostViews, x as toNavItemView, y as toArchiveGroupsWithMedia } from "./app-D_ke5q_u.js";
+import { A as NAV_ITEM_TYPES, C as toPostView, D as MAX_MEDIA_ATTACHMENTS, E as FORMATS, M as STATUSES, N as TEXT_ATTACHMENT_CONTENT_FORMATS, O as MAX_PINNED_POSTS, S as toNavItemViews, T as toSearchResultView, _ as createMediaContext, b as toMediaView, f as defaultFeedRenderer, j as SORT_ORDERS, k as MEDIA_KINDS, t as createApp, v as toArchiveGroups, w as toPostViews, x as toNavItemView, y as toArchiveGroupsWithMedia } from "./app-CPVwpmb3.js";
 import { T as time_exports, a as markdown_exports } from "./export-I9XFTWyO.js";
 import "./env-CgaH9Mut.js";
 import "./github-sync-DBAwA3H9.js";

package/dist/node.js

@@ -1,5 +1,5 @@
 import "./url-umUptr5z.js";
-import { F as BUILTIN_COLOR_THEMES, I as getPublicAssetBasePath, L as isAssetPath, P as buildThemeStyle, a as resolveDatabaseDialect, c as resolveConfig, d as getFontThemeCssVariables, g as schema_exports, h as createNodeDatabase, i as createSiteService, l as BUILTIN_FONT_THEMES, m as sqliteSchemaBundle, n as createNodeCliRuntime, o as getHostBasedStartupConfigurationIssues, p as pgSchemaBundle, r as createNodeRequestRuntime, s as createStorageDriver, t as createApp, u as getCjkSerifCssVariables } from "./app-D_ke5q_u.js";
+import { F as BUILTIN_COLOR_THEMES, I as getPublicAssetBasePath, L as isAssetPath, P as buildThemeStyle, a as resolveDatabaseDialect, c as resolveConfig, d as getFontThemeCssVariables, g as schema_exports, h as createNodeDatabase, i as createSiteService, l as BUILTIN_FONT_THEMES, m as sqliteSchemaBundle, n as createNodeCliRuntime, o as getHostBasedStartupConfigurationIssues, p as pgSchemaBundle, r as createNodeRequestRuntime, s as createStorageDriver, t as createApp, u as getCjkSerifCssVariables } from "./app-CPVwpmb3.js";
 import { t as createExportService } from "./export-I9XFTWyO.js";
 import { b as getSiteResolutionMode, i as getConfiguredSingleSitePathPrefix, l as getEnvString, r as getConfiguredSingleSiteOrigin, x as shouldTrustProxy, y as getPort } from "./env-CgaH9Mut.js";
 import "./github-sync-DBAwA3H9.js";
@@ -474,7 +474,7 @@ async function createNodeRequestHandler(options) {
 async function start(env = process.env, app) {
 	const handler = await createNodeRequestHandler({
 		env,
-		app: async () => app ?? (await import("./app-BpyntjN7.js")).createApp()
+		app: async () => app ?? (await import("./app-Z83YzveI.js")).createApp()
 	});
 	const hostname = resolveHost(env);
 	const port = resolvePort(env);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jant/core",
-  "version": "0.5.1",
+  "version": "0.5.2",
   "description": "A modern, open-source microblogging platform built on Cloudflare Workers",
   "type": "module",
   "exports": {

package/src/client/__tests__/slash-discovery.test.ts

@@ -0,0 +1,150 @@
+// @vitest-environment happy-dom
+
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import {
+  __testOnly,
+  hideSlashCommandHint,
+  markSlashCommandDiscovered,
+  scheduleSlashCommandHint,
+} from "../slash-discovery.js";
+
+function createEditorHost(discovered = false): HTMLElement {
+  document.body.innerHTML = `
+    <jant-compose-editor data-slash-command-discovered="${discovered ? "true" : "false"}">
+      <div class="compose-tiptap-body"></div>
+      <span class="compose-slash-discovery-hint" aria-hidden="true">Type / for commands</span>
+    </jant-compose-editor>
+  `;
+
+  return document.querySelector<HTMLElement>(
+    "jant-compose-editor",
+  ) as HTMLElement;
+}
+
+describe("slash discovery", () => {
+  beforeEach(() => {
+    vi.restoreAllMocks();
+    vi.useFakeTimers();
+    globalThis.localStorage.clear();
+    __testOnly.reset();
+    vi.stubGlobal("matchMedia", vi.fn().mockReturnValue({ matches: true }));
+    vi.stubGlobal("fetch", vi.fn().mockResolvedValue({ ok: true }));
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.unstubAllGlobals();
+  });
+
+  it("shows the hint after the delay and records one exposure per page", () => {
+    const host = createEditorHost();
+
+    scheduleSlashCommandHint(host);
+    vi.advanceTimersByTime(__testOnly.SLASH_HINT_DELAY_MS);
+
+    expect(host.classList.contains(__testOnly.SLASH_HINT_VISIBLE_CLASS)).toBe(
+      true,
+    );
+    expect(__testOnly.readState()).toMatchObject({
+      shownCount: 1,
+      completed: false,
+    });
+
+    // No auto-fade — the hint stays visible until something explicitly hides it.
+    vi.advanceTimersByTime(5000);
+    expect(host.classList.contains(__testOnly.SLASH_HINT_VISIBLE_CLASS)).toBe(
+      true,
+    );
+
+    hideSlashCommandHint(host);
+    expect(host.classList.contains(__testOnly.SLASH_HINT_VISIBLE_CLASS)).toBe(
+      false,
+    );
+
+    // Refocusing during the same page load shows the hint again
+    // without bumping the persisted shownCount.
+    scheduleSlashCommandHint(host);
+    vi.advanceTimersByTime(__testOnly.SLASH_HINT_DELAY_MS);
+
+    expect(host.classList.contains(__testOnly.SLASH_HINT_VISIBLE_CLASS)).toBe(
+      true,
+    );
+    expect(__testOnly.readState().shownCount).toBe(1);
+  });
+
+  it("hides the hint immediately when called", () => {
+    const host = createEditorHost();
+
+    scheduleSlashCommandHint(host);
+    vi.advanceTimersByTime(__testOnly.SLASH_HINT_DELAY_MS);
+    expect(host.classList.contains(__testOnly.SLASH_HINT_VISIBLE_CLASS)).toBe(
+      true,
+    );
+
+    hideSlashCommandHint(host);
+    expect(host.classList.contains(__testOnly.SLASH_HINT_VISIBLE_CLASS)).toBe(
+      false,
+    );
+  });
+
+  it("does not show the hint after the local max has been reached", () => {
+    const host = createEditorHost();
+    globalThis.localStorage.setItem(
+      __testOnly.SLASH_DISCOVERY_STORAGE_KEY,
+      JSON.stringify({
+        shownCount: __testOnly.SLASH_HINT_MAX_SHOW_COUNT,
+        completed: false,
+      }),
+    );
+
+    scheduleSlashCommandHint(host);
+    vi.advanceTimersByTime(__testOnly.SLASH_HINT_DELAY_MS);
+
+    expect(host.classList.contains(__testOnly.SLASH_HINT_VISIBLE_CLASS)).toBe(
+      false,
+    );
+  });
+
+  it("does not show the hint when the DB flag is already set", () => {
+    const host = createEditorHost(true);
+
+    scheduleSlashCommandHint(host);
+    vi.advanceTimersByTime(__testOnly.SLASH_HINT_DELAY_MS);
+
+    expect(host.classList.contains(__testOnly.SLASH_HINT_VISIBLE_CLASS)).toBe(
+      false,
+    );
+  });
+
+  it("does not show the hint on mobile widths", () => {
+    vi.stubGlobal("matchMedia", vi.fn().mockReturnValue({ matches: false }));
+    const host = createEditorHost();
+
+    scheduleSlashCommandHint(host);
+    vi.advanceTimersByTime(__testOnly.SLASH_HINT_DELAY_MS);
+
+    expect(host.classList.contains(__testOnly.SLASH_HINT_VISIBLE_CLASS)).toBe(
+      false,
+    );
+  });
+
+  it("marks the slash command as completed locally and syncs to the server", async () => {
+    const host = createEditorHost();
+
+    markSlashCommandDiscovered();
+    await Promise.resolve();
+
+    expect(__testOnly.readState()).toMatchObject({
+      shownCount: __testOnly.SLASH_HINT_MAX_SHOW_COUNT,
+      completed: true,
+    });
+    expect(host.dataset.slashCommandDiscovered).toBe("true");
+    expect(globalThis.fetch).toHaveBeenCalledWith(
+      __testOnly.SLASH_DISCOVERY_API_PATH,
+      expect.objectContaining({
+        method: "POST",
+        credentials: "same-origin",
+      }),
+    );
+  });
+});

package/src/client/components/__tests__/jant-compose-dialog.test.ts

@@ -230,6 +230,7 @@ const labels: ComposeLabels = {
   showMore: "Show more",
   showLess: "Show less",
   newThread: "New Thread",
+  slashHint: "Type / for commands",
   collectionFormLabels: {
     titleLabel: "Title",
     titlePlaceholder: "My Collection",

package/src/client/components/__tests__/jant-compose-editor.test.ts

@@ -264,6 +264,7 @@ const labels: ComposeLabels = {
   showMore: "Show more",
   showLess: "Show less",
   newThread: "New Thread",
+  slashHint: "Type / for commands",
   collectionFormLabels: {
     titleLabel: "Title",
     titlePlaceholder: "My Collection",

package/src/client/components/compose-types.ts

@@ -214,6 +214,7 @@ export interface ComposeLabels {
   showMore: string;
   showLess: string;
   newThread: string;
+  slashHint: string;
   collectionFormLabels: CollectionFormLabels;
 }
 

package/src/client/components/jant-compose-dialog.ts

@@ -534,6 +534,10 @@ export class JantComposeDialog extends LitElement {
     pageMode: { type: Boolean, attribute: "page-mode" },
     closeHref: { type: String, attribute: "close-href" },
     autoRestoreDraft: { type: Boolean, attribute: "auto-restore-draft" },
+    slashCommandDiscovered: {
+      type: Boolean,
+      attribute: "slash-command-discovered",
+    },
     _format: { state: true },
     _status: { state: true },
     _loading: { state: true },
@@ -578,6 +582,7 @@ export class JantComposeDialog extends LitElement {
   declare pageMode: boolean;
   declare closeHref: string;
   declare autoRestoreDraft: boolean;
+  declare slashCommandDiscovered: boolean;
   declare _format: ComposeFormat;
   declare _status: "published" | "draft";
   declare _loading: boolean;
@@ -665,6 +670,7 @@ export class JantComposeDialog extends LitElement {
     this.pageMode = false;
     this.closeHref = "/";
     this.autoRestoreDraft = false;
+    this.slashCommandDiscovered = false;
     this._format = "note";
     this._status = "published";
     this._loading = false;
@@ -5283,6 +5289,7 @@ export class JantComposeDialog extends LitElement {
           .uploadMaxFileSize=${this.uploadMaxFileSize}
           .threadItem=${true}
           .removable=${showRemove}
+          .slashCommandDiscovered=${this.slashCommandDiscovered}
           data-thread-id=${item.id}
         ></jant-compose-editor>
       </div>
@@ -5387,6 +5394,7 @@ export class JantComposeDialog extends LitElement {
       .format=${this._format}
       .labels=${this.labels}
       .uploadMaxFileSize=${this.uploadMaxFileSize}
+      .slashCommandDiscovered=${this.slashCommandDiscovered}
     ></jant-compose-editor>`;
 
     return html`

package/src/client/components/jant-compose-editor.ts

@@ -48,6 +48,11 @@ import {
 } from "../tiptap/inline-image-upload.js";
 import { isSafeAbsoluteUrl } from "../../lib/url.js";
 import { randomUUID } from "../random-uuid.js";
+import {
+  hideSlashCommandHint,
+  markSlashCommandDiscovered,
+  scheduleSlashCommandHint,
+} from "../slash-discovery.js";
 
 interface ComposeFilePickerCloseDetail {
   cancelled: boolean;
@@ -172,6 +177,7 @@ export class JantComposeEditor extends LitElement {
     uploadMaxFileSize: { type: Number },
     threadItem: { type: Boolean, attribute: "thread-item" },
     removable: { type: Boolean },
+    slashCommandDiscovered: { type: Boolean },
     _title: { state: true },
     _bodyJson: { state: true },
     _url: { state: true },
@@ -196,6 +202,7 @@ export class JantComposeEditor extends LitElement {
   declare uploadMaxFileSize: number;
   declare threadItem: boolean;
   declare removable: boolean;
+  declare slashCommandDiscovered: boolean;
   declare _title: string;
   declare _bodyJson: JSONContent | null;
   declare _url: string;
@@ -242,6 +249,7 @@ export class JantComposeEditor extends LitElement {
     this.uploadMaxFileSize = 500;
     this.threadItem = false;
     this.removable = false;
+    this.slashCommandDiscovered = false;
     this._title = "";
     this._bodyJson = null;
     this._url = "";
@@ -264,6 +272,10 @@ export class JantComposeEditor extends LitElement {
   connectedCallback() {
     super.connectedCallback();
     document.addEventListener("jant:slash-image", this._onSlashImage);
+    document.addEventListener(
+      "jant:slash-command-discovered",
+      this._onSlashCommandDiscovered,
+    );
   }
 
   disconnectedCallback() {
@@ -274,13 +286,22 @@ export class JantComposeEditor extends LitElement {
     this.#sortable?.destroy();
     this.#sortable = null;
     document.removeEventListener("jant:slash-image", this._onSlashImage);
+    document.removeEventListener(
+      "jant:slash-command-discovered",
+      this._onSlashCommandDiscovered,
+    );
     document.removeEventListener("click", this._onDocClickBound);
+    hideSlashCommandHint(this);
     this._emojiContainer?.remove();
     this._emojiPickerEl = null;
     this._filePickerCleanup?.();
     this._filePickerCleanup = null;
   }
 
+  private _onSlashCommandDiscovered = () => {
+    markSlashCommandDiscovered();
+  };
+
   private _onSlashImage = () => {
     // Skip when fullscreen is open — it has its own handler
     if (document.querySelector(".compose-fullscreen-dialog[open]")) return;
@@ -686,6 +707,10 @@ export class JantComposeEditor extends LitElement {
     const container = this.querySelector<HTMLElement>(".compose-tiptap-body");
     if (!container || this._editor) return;
 
+    this.dataset.slashCommandDiscovered = this.slashCommandDiscovered
+      ? "true"
+      : "false";
+
     this._editor = createTiptapEditor({
       element: container,
       placeholder:
@@ -697,9 +722,13 @@ export class JantComposeEditor extends LitElement {
       onUpdate: (json) => {
         this._bodyJson = json;
         this._ensureScrollBuffer();
+        hideSlashCommandHint(this);
       },
       onFocus: () => {
         this._lastFocusedField = null;
+        if (this._editor?.isEmpty) {
+          scheduleSlashCommandHint(this);
+        }
       },
       onSelectionUpdate: (selection) => {
         this._lastEditorSelection = selection;
@@ -1655,7 +1684,12 @@ export class JantComposeEditor extends LitElement {
               </div>
             `
           : nothing}
-        <div class="compose-tiptap-body"></div>
+        <div class="compose-tiptap-wrap">
+          <div class="compose-tiptap-body"></div>
+          <span class="compose-slash-discovery-hint" aria-hidden="true">
+            ${this.labels.slashHint}
+          </span>
+        </div>
       </div>
     `;
   }
@@ -1723,9 +1757,14 @@ export class JantComposeEditor extends LitElement {
             </p>`
           : nothing}
         <div class="compose-divider"></div>
-        <div
-          class="compose-tiptap-body compose-tiptap-thoughts compose-tiptap-link"
-        ></div>
+        <div class="compose-tiptap-wrap">
+          <div
+            class="compose-tiptap-body compose-tiptap-thoughts compose-tiptap-link"
+          ></div>
+          <span class="compose-slash-discovery-hint" aria-hidden="true">
+            ${this.labels.slashHint}
+          </span>
+        </div>
       </div>
     `;
   }
@@ -1789,9 +1828,14 @@ export class JantComposeEditor extends LitElement {
           class="compose-divider compose-divider-quote"
           aria-hidden="true"
         ></div>
-        <div
-          class="compose-tiptap-body compose-tiptap-thoughts compose-tiptap-thoughts-quote"
-        ></div>
+        <div class="compose-tiptap-wrap">
+          <div
+            class="compose-tiptap-body compose-tiptap-thoughts compose-tiptap-thoughts-quote"
+          ></div>
+          <span class="compose-slash-discovery-hint" aria-hidden="true">
+            ${this.labels.slashHint}
+          </span>
+        </div>
       </div>
     `;
   }

package/src/client/slash-discovery-bridge.ts

@@ -0,0 +1,9 @@
+import { initSlashCommandDiscovery } from "./slash-discovery.js";
+
+if (document.readyState === "loading") {
+  document.addEventListener("DOMContentLoaded", () => {
+    initSlashCommandDiscovery();
+  });
+} else {
+  initSlashCommandDiscovery();
+}

package/src/client/slash-discovery.ts

@@ -0,0 +1,200 @@
+/**
+ * Slash Command Discovery
+ *
+ * Surfaces a small "Type / for commands" hint over the TipTap compose editor on
+ * first focus. Mirrors the compose-open-shortcut pattern:
+ *  - localStorage tracks shownCount + completed for fast read on subsequent visits
+ *  - DB (synced once via POST) is the durable cross-device "user has used this" flag
+ *  - The DB flag is hydrated server-side onto the editor host as
+ *    `data-slash-command-discovered="true"`
+ */
+
+const SLASH_DISCOVERY_STORAGE_KEY = "jant.slashCommandDiscovery";
+const SLASH_DISCOVERY_API_PATH = "/api/settings/discovery/slash-command";
+const SLASH_HINT_DELAY_MS = 600;
+const SLASH_HINT_MAX_SHOW_COUNT = 3;
+const SLASH_HINT_VISIBLE_CLASS = "compose-slash-discovery-visible";
+
+interface SlashDiscoveryState {
+  shownCount: number;
+  completed: boolean;
+}
+
+let exposureRecordedThisSession = false;
+let showTimer: ReturnType<typeof setTimeout> | null = null;
+let activeHost: HTMLElement | null = null;
+
+function canUseLocalStorage(): boolean {
+  try {
+    return typeof globalThis.localStorage !== "undefined";
+  } catch {
+    return false;
+  }
+}
+
+function readState(): SlashDiscoveryState {
+  if (!canUseLocalStorage()) {
+    return { shownCount: 0, completed: false };
+  }
+
+  const raw = globalThis.localStorage.getItem(SLASH_DISCOVERY_STORAGE_KEY);
+  if (!raw) {
+    return { shownCount: 0, completed: false };
+  }
+
+  try {
+    const parsed = JSON.parse(raw) as Partial<SlashDiscoveryState>;
+    return {
+      shownCount:
+        typeof parsed.shownCount === "number" && parsed.shownCount >= 0
+          ? parsed.shownCount
+          : 0,
+      completed: parsed.completed === true,
+    };
+  } catch {
+    globalThis.localStorage.removeItem(SLASH_DISCOVERY_STORAGE_KEY);
+    return { shownCount: 0, completed: false };
+  }
+}
+
+function writeState(state: SlashDiscoveryState): void {
+  if (!canUseLocalStorage()) return;
+
+  try {
+    globalThis.localStorage.setItem(
+      SLASH_DISCOVERY_STORAGE_KEY,
+      JSON.stringify(state),
+    );
+  } catch {
+    // Storage unavailable — skip persistence for this page load.
+  }
+}
+
+function clearShowTimer() {
+  if (showTimer !== null) {
+    clearTimeout(showTimer);
+    showTimer = null;
+  }
+}
+
+function isDesktopEligible(): boolean {
+  return (
+    typeof globalThis.matchMedia === "function" &&
+    globalThis.matchMedia("(min-width: 700px)").matches
+  );
+}
+
+function isCompletedOnHost(host: HTMLElement): boolean {
+  if (readState().completed) return true;
+  return host.dataset.slashCommandDiscovered === "true";
+}
+
+function markHostsCompleted() {
+  document
+    .querySelectorAll<HTMLElement>("jant-compose-editor")
+    .forEach((host) => {
+      host.dataset.slashCommandDiscovered = "true";
+      host.classList.remove(SLASH_HINT_VISIBLE_CLASS);
+    });
+}
+
+function recordExposure(): void {
+  const state = readState();
+  if (state.completed || exposureRecordedThisSession) return;
+  if (state.shownCount >= SLASH_HINT_MAX_SHOW_COUNT) return;
+
+  exposureRecordedThisSession = true;
+  writeState({ ...state, shownCount: state.shownCount + 1 });
+}
+
+function canShowHint(host: HTMLElement): boolean {
+  if (!isDesktopEligible()) return false;
+  if (isCompletedOnHost(host)) return false;
+
+  const state = readState();
+  return (
+    state.shownCount < SLASH_HINT_MAX_SHOW_COUNT || exposureRecordedThisSession
+  );
+}
+
+export function hideSlashCommandHint(host?: HTMLElement | null): void {
+  clearShowTimer();
+
+  if (host) {
+    host.classList.remove(SLASH_HINT_VISIBLE_CLASS);
+  } else if (activeHost) {
+    activeHost.classList.remove(SLASH_HINT_VISIBLE_CLASS);
+  }
+
+  if (!host || host === activeHost) {
+    activeHost = null;
+  }
+}
+
+function showHint(host: HTMLElement): void {
+  if (!canShowHint(host)) return;
+
+  hideSlashCommandHint(activeHost);
+  activeHost = host;
+  host.classList.add(SLASH_HINT_VISIBLE_CLASS);
+  recordExposure();
+}
+
+export function scheduleSlashCommandHint(host: HTMLElement): void {
+  if (!canShowHint(host)) return;
+  if (host.classList.contains(SLASH_HINT_VISIBLE_CLASS)) return;
+
+  clearShowTimer();
+  showTimer = setTimeout(() => {
+    showHint(host);
+  }, SLASH_HINT_DELAY_MS);
+}
+
+export function markSlashCommandDiscovered(): void {
+  const state = readState();
+  if (!state.completed) {
+    writeState({
+      shownCount: Math.max(state.shownCount, SLASH_HINT_MAX_SHOW_COUNT),
+      completed: true,
+    });
+  }
+
+  markHostsCompleted();
+  hideSlashCommandHint(activeHost);
+
+  if (typeof globalThis.fetch === "function") {
+    void globalThis
+      .fetch(SLASH_DISCOVERY_API_PATH, {
+        method: "POST",
+        headers: { Accept: "application/json" },
+        credentials: "same-origin",
+      })
+      .catch(() => {
+        // Keep the local completed state even if the sync request fails.
+      });
+  }
+}
+
+/**
+ * Initialize once on DOMContentLoaded. The actual scheduling is driven by
+ * the compose editor on focus, so this is a no-op placeholder kept for parity
+ * with `compose-discovery-bridge` (and to give future call sites a hook).
+ */
+export function initSlashCommandDiscovery(): void {
+  // Intentionally empty — the editor host calls scheduleSlashCommandHint /
+  // hideSlashCommandHint directly on focus / update.
+}
+
+export const __testOnly = {
+  SLASH_DISCOVERY_API_PATH,
+  SLASH_DISCOVERY_STORAGE_KEY,
+  SLASH_HINT_DELAY_MS,
+  SLASH_HINT_MAX_SHOW_COUNT,
+  SLASH_HINT_VISIBLE_CLASS,
+  readState,
+  reset() {
+    exposureRecordedThisSession = false;
+    clearShowTimer();
+    activeHost = null;
+  },
+};

package/src/client/tiptap/slash-commands.ts

@@ -641,6 +641,11 @@ export const SlashCommands = Extension.create({
               editorRef = props.editor;
               currentRange = props.range;
               renderPopup(props.items, (index) => props.command({ index }));
+              document.dispatchEvent(
+                new CustomEvent("jant:slash-command-discovered", {
+                  bubbles: true,
+                }),
+              );
 
               // Append inside the closest dialog (top-layer) or body
               const editorEl = getEditorElement(props.editor);

package/src/client-auth.ts

@@ -14,6 +14,7 @@ import "./client/components/jant-compose-editor.js";
 import "./client/components/jant-compose-fullscreen.js";
 import "./client/compose-bridge.js";
 import "./client/compose-discovery-bridge.js";
+import "./client/slash-discovery-bridge.js";
 import "./client/compose-shortcuts.js";
 import "./client/components/jant-settings-general.js";
 import "./client/components/jant-settings-avatar.js";

package/src/i18n/locales/public/en.po

@@ -2131,6 +2131,11 @@ msgstr "Transparent square"
 msgid "Tune color in a real reading context"
 msgstr "Tune color in a real reading context"
 
+#. @context: First-use hint shown over the compose editor to surface the slash command menu
+#: src/ui/compose/ComposeDialog.tsx
+msgid "Type / for commands"
+msgstr "Type / for commands"
+
 #. @context: Compose quote text placeholder
 #: src/ui/compose/ComposeDialog.tsx
 msgid "Type the quote..."