@agent-native/core 0.154.0 → 0.154.2

package/corpus/README.md

@@ -31,4 +31,4 @@ rg -n "defineAction|useActionQuery" node_modules/@agent-native/core/corpus
 
 ## Generated Counts
 
-- template files: 8201
+- template files: 8208

package/corpus/templates/analytics/changelog/2026-08-12-feature-flags-can-be-managed-across-apps-whose-workspace-rec.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-08-12
+---
+
+Feature flags can be managed across apps whose workspace records use different local IDs

package/corpus/templates/analytics/changelog/2026-08-12-kept-feature-flag-details-readable-by-stacking-rollout-contr.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-08-12
+---
+
+Kept feature flag details readable by stacking rollout controls at narrow widths.

package/corpus/templates/analytics/scripts/preview-dashboard-report.ts

@@ -19,7 +19,8 @@
  */
 
 import { mkdir, writeFile } from "node:fs/promises";
-import { join } from "node:path";
+import path, { join } from "node:path";
+import { pathToFileURL } from "node:url";
 
 import { runWithRequestContext } from "@agent-native/core/server/request-context";
 import { eq } from "drizzle-orm";
@@ -215,7 +216,17 @@ async function renderPreview(
   if (rendered.degradedPanelIds.length) process.exitCode = 1;
 }
 
-main().catch((err) => {
-  console.error("[preview] failed:", err);
-  process.exit(1);
-});
+function isDirectRun(): boolean {
+  const entrypoint = process.argv[1];
+  return Boolean(
+    entrypoint &&
+    import.meta.url === pathToFileURL(path.resolve(entrypoint)).href,
+  );
+}
+
+if (isDirectRun()) {
+  main().catch((err) => {
+    console.error("[preview] failed:", err);
+    process.exit(1);
+  });
+}

package/corpus/templates/analytics/server/lib/workspace-feature-flags.ts

@@ -2,6 +2,7 @@ import { randomUUID } from "node:crypto";
 
 import { signA2AToken } from "@agent-native/core/a2a";
 import { fetchOrgApps, type OrgApp } from "@agent-native/core/mcp";
+import { getOrgDomain } from "@agent-native/core/org";
 
 import type { AnalyticsAdminContext } from "./db-admin-connections.js";
 
@@ -31,11 +32,11 @@ export interface WorkspaceFeatureFlagsResult {
 }
 
 export interface WorkspaceFeatureFlagMutationResult {
-  contractVersion: 1;
+  contractVersion: 2;
   status: "ready";
   key: string;
   rules: Record<string, unknown>;
-  scope: { orgId: string | null };
+  scope: { orgId: string | null; orgDomain: string | null };
 }
 
 export interface WorkspaceFeatureFlagMutationInput {
@@ -66,14 +67,14 @@ export function validateWorkspaceFeatureFlagMutation(
   body: unknown,
   expected: {
     key: string;
-    orgId: string;
+    orgDomain: string;
     rules?: Record<string, unknown>;
     enabledForEmail?: string;
   },
 ): WorkspaceFeatureFlagMutationResult {
   const payload = body as Partial<WorkspaceFeatureFlagMutationResult> | null;
   const valid =
-    payload?.contractVersion === 1 &&
+    payload?.contractVersion === 2 &&
     payload.status === "ready" &&
     payload.key === expected.key &&
     !!payload.rules &&
@@ -81,7 +82,7 @@ export function validateWorkspaceFeatureFlagMutation(
     !Array.isArray(payload.rules) &&
     !!payload.scope &&
     typeof payload.scope === "object" &&
-    payload.scope.orgId === expected.orgId;
+    payload.scope.orgDomain === expected.orgDomain;
   if (!valid)
     throw new Error(
       "The target app returned an unsupported or unverified feature flag mutation response.",
@@ -152,13 +153,43 @@ async function delegatedToken(
   admin: AnalyticsAdminContext,
   origin: string,
   scope: "flags:read" | "flags:write",
+  resolvedOrgDomain?: string,
 ): Promise<string> {
-  return signA2AToken(admin.userEmail, undefined, undefined, {
-    expiresIn: "120s",
-    preferGlobalSecret: true,
-    audience: origin,
-    extraClaims: { org_id: admin.orgId, scope, jti: randomUUID() },
-  });
+  try {
+    const orgDomain =
+      resolvedOrgDomain ??
+      (await getOrgDomain(admin.orgId))?.trim().toLowerCase();
+    if (!orgDomain) throw new TargetCallFailure("token-generation");
+    return await signA2AToken(admin.userEmail, orgDomain, undefined, {
+      expiresIn: "120s",
+      preferGlobalSecret: true,
+      audience: origin,
+      extraClaims: { org_id: admin.orgId, scope, jti: randomUUID() },
+    });
+  } catch {
+    throw new TargetCallFailure("token-generation");
+  }
+}
+
+type TargetFailureReason = "token-generation" | "timeout" | "network";
+
+class TargetCallFailure extends Error {
+  constructor(readonly reason: TargetFailureReason) {
+    super(`Feature flag target call failed: ${reason}`);
+    this.name = "TargetCallFailure";
+  }
+}
+
+export function classifyWorkspaceFeatureFlagTargetFailure(
+  error: unknown,
+): TargetFailureReason {
+  if (error instanceof TargetCallFailure) return error.reason;
+  if (
+    error instanceof Error &&
+    (error.name === "TimeoutError" || error.name === "AbortError")
+  )
+    return "timeout";
+  return "network";
 }
 
 async function callTarget(
@@ -166,25 +197,34 @@ async function callTarget(
   admin: AnalyticsAdminContext,
   action: "list-feature-flags" | "set-feature-flag",
   body: Record<string, unknown>,
+  orgDomain?: string,
 ): Promise<{ status: number; body: unknown }> {
   const origin = targetOrigin(app);
   const token = await delegatedToken(
     admin,
     origin,
     action === "list-feature-flags" ? "flags:read" : "flags:write",
+    orgDomain,
   );
-  const response = await fetch(`${origin}/_agent-native/actions/${action}`, {
-    method: action === "list-feature-flags" ? "GET" : "POST",
-    headers: {
-      Authorization: `Bearer ${token}`,
-      Accept: "application/json",
-      ...(action === "set-feature-flag"
-        ? { "Content-Type": "application/json" }
-        : {}),
-    },
-    ...(action === "set-feature-flag" ? { body: JSON.stringify(body) } : {}),
-    signal: AbortSignal.timeout(TARGET_TIMEOUT_MS),
-  });
+  let response: Response;
+  try {
+    response = await fetch(`${origin}/_agent-native/actions/${action}`, {
+      method: action === "list-feature-flags" ? "GET" : "POST",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        Accept: "application/json",
+        ...(action === "set-feature-flag"
+          ? { "Content-Type": "application/json" }
+          : {}),
+      },
+      ...(action === "set-feature-flag" ? { body: JSON.stringify(body) } : {}),
+      signal: AbortSignal.timeout(TARGET_TIMEOUT_MS),
+    });
+  } catch (error) {
+    throw new TargetCallFailure(
+      classifyWorkspaceFeatureFlagTargetFailure(error),
+    );
+  }
   let parsed: unknown = null;
   try {
     parsed = await response.json();
@@ -209,7 +249,7 @@ export function classifyWorkspaceFeatureFlagList(
   if (result.status === 404 || result.status === 405)
     return { ...base, state: "unsupported" };
   if (result.status < 200 || result.status >= 300)
-    return { ...base, state: "unknown-legacy" };
+    return { ...base, state: "unknown-legacy", reason: "target-execution" };
   const payload = result.body as {
     flags?: unknown;
     canManage?: unknown;
@@ -254,7 +294,11 @@ async function mapBounded<T, R>(
 export async function listWorkspaceFeatureFlags(
   admin: AnalyticsAdminContext,
 ): Promise<WorkspaceFeatureFlagsResult> {
-  const apps = await fetchOrgApps({ serviceOrgId: admin.orgId });
+  const apps = await fetchOrgApps({
+    selfId: "analytics",
+    includeDirectoryApp: true,
+    serviceOrgId: admin.orgId,
+  });
   if (apps.length === 0) return { directoryStatus: "unavailable", apps: [] };
   const entries = await mapBounded(apps, async (app) => {
     try {
@@ -262,13 +306,14 @@ export async function listWorkspaceFeatureFlags(
         app,
         await callTarget(app, admin, "list-feature-flags", {}),
       );
-    } catch {
+    } catch (error) {
       return {
         appId: app.id,
         appName: app.name,
         appOrigin: targetOrigin(app),
         state: "unreachable" as const,
         flags: [],
+        reason: classifyWorkspaceFeatureFlagTargetFailure(error),
       };
     }
   });
@@ -279,14 +324,31 @@ export async function setWorkspaceFeatureFlag(
   admin: AnalyticsAdminContext,
   input: WorkspaceFeatureFlagMutationInput,
 ): Promise<WorkspaceFeatureFlagMutationResult> {
-  const apps = await fetchOrgApps({ serviceOrgId: admin.orgId });
+  const apps = await fetchOrgApps({
+    selfId: "analytics",
+    includeDirectoryApp: true,
+    serviceOrgId: admin.orgId,
+  });
   const app = apps.find((candidate) => candidate.id === input.appId);
   if (!app)
     throw new Error(
       "The requested app is not available in this organization directory.",
     );
   const targetInput = workspaceFeatureFlagTargetInput(input);
-  const result = await callTarget(app, admin, "set-feature-flag", targetInput);
+  let orgDomain: string | undefined;
+  try {
+    orgDomain = (await getOrgDomain(admin.orgId))?.trim().toLowerCase();
+  } catch {
+    throw new TargetCallFailure("token-generation");
+  }
+  if (!orgDomain) throw new TargetCallFailure("token-generation");
+  const result = await callTarget(
+    app,
+    admin,
+    "set-feature-flag",
+    targetInput,
+    orgDomain,
+  );
   if (result.status === 401 || result.status === 403)
     throw new Error("The target app denied this delegated flag operation.");
   if (result.status === 404 || result.status === 405)
@@ -297,7 +359,7 @@ export async function setWorkspaceFeatureFlag(
     );
   return validateWorkspaceFeatureFlagMutation(result.body, {
     key: input.key,
-    orgId: admin.orgId,
+    orgDomain,
     ...(input.operation === "replace-rules" && input.rules
       ? {
           rules: {
@@ -324,7 +386,11 @@ export async function getWorkspaceFlagTarget(
   admin: AnalyticsAdminContext,
   appId: string,
 ): Promise<FleetFlagApp> {
-  const apps = await fetchOrgApps({ serviceOrgId: admin.orgId });
+  const apps = await fetchOrgApps({
+    selfId: "analytics",
+    includeDirectoryApp: true,
+    serviceOrgId: admin.orgId,
+  });
   const app = apps.find((candidate) => candidate.id === appId);
   if (!app)
     throw new Error(
@@ -335,13 +401,14 @@ export async function getWorkspaceFlagTarget(
       app,
       await callTarget(app, admin, "list-feature-flags", {}),
     );
-  } catch {
+  } catch (error) {
     return {
       appId: app.id,
       appName: app.name,
       appOrigin: targetOrigin(app),
       state: "unreachable",
       flags: [],
+      reason: classifyWorkspaceFeatureFlagTargetFailure(error),
     };
   }
 }

package/corpus/templates/content/actions/resolve-content-landing.ts

@@ -1,15 +1,21 @@
-import { createHash } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 
 import { defineAction } from "@agent-native/core";
-import { readAppState } from "@agent-native/core/application-state";
+import {
+  compareAndSetAppState,
+  listAppState,
+  readAppState,
+} from "@agent-native/core/application-state";
 import { runWithRequestContext } from "@agent-native/core/server";
 import { getRequestUserEmail } from "@agent-native/core/server/request-context";
 import { z } from "zod";
 
 import {
   CONTENT_LAST_LOCATION_STATE_KEY,
+  CONTENT_WELCOME_PAGE_STATE_KEY,
   type ContentLandingResolution,
   type ContentLastLocationState,
+  type ContentWelcomePageState,
 } from "../shared/content-landing.js";
 import { resolveContentDocumentAccess } from "./_content-document-access.js";
 import { normalizeContentSpaceEmail } from "./_content-space-access.js";
@@ -24,12 +30,85 @@ const WELCOME_CONTENT = `Start here with a page that is wholly yours.
 - Use the sidebar to find and organize your work.
 - Ask the agent when you want a hand.`;
 
-function welcomeDocumentId(userEmail: string) {
+function legacyWelcomeDocumentId(userEmail: string, generation: number) {
   const identity = normalizeContentSpaceEmail(userEmail);
-  const digest = createHash("sha256").update(identity).digest("hex");
+  const input = generation === 0 ? identity : `${identity}:${generation}`;
+  const digest = createHash("sha256").update(input).digest("hex");
   return `content_welcome_${digest.slice(0, 32)}`;
 }
 
+function randomWelcomeDocumentId() {
+  return `content_welcome_${randomUUID().replace(/-/g, "")}`;
+}
+
+function welcomeGeneration(state: Record<string, unknown>): number {
+  const candidate = state as ContentWelcomePageState;
+  if (
+    typeof candidate.generation !== "number" ||
+    !Number.isSafeInteger(candidate.generation) ||
+    candidate.generation < 0
+  ) {
+    throw new Error("Content welcome page state has an invalid generation");
+  }
+  return candidate.generation;
+}
+
+function isUniqueConstraintError(error: unknown): boolean {
+  let current: unknown = error;
+  const seen = new Set<unknown>();
+  while (current && typeof current === "object" && !seen.has(current)) {
+    seen.add(current);
+    const candidate = current as {
+      code?: unknown;
+      message?: unknown;
+      cause?: unknown;
+    };
+    const code = String(candidate.code ?? "");
+    const message = String(candidate.message ?? "");
+    if (
+      code === "23505" ||
+      code.includes("SQLITE_CONSTRAINT") ||
+      /unique constraint|unique violation|duplicate key/i.test(message)
+    ) {
+      return true;
+    }
+    current = candidate.cause;
+  }
+  return false;
+}
+
+async function resolveWelcomeState(): Promise<{
+  generation: number;
+  documentId: string | null;
+  expectedValue: Record<string, unknown>;
+}> {
+  while (true) {
+    const entries = await listAppState(CONTENT_WELCOME_PAGE_STATE_KEY);
+    const entry = entries.find(
+      ({ key }) => key === CONTENT_WELCOME_PAGE_STATE_KEY,
+    );
+    if (entry) {
+      if (!entry.value || typeof entry.value !== "object") {
+        throw new Error("Content welcome page state must be an object");
+      }
+      return {
+        generation: welcomeGeneration(entry.value),
+        documentId:
+          typeof entry.value.documentId === "string" && entry.value.documentId
+            ? entry.value.documentId
+            : null,
+        expectedValue: entry.value,
+      };
+    }
+
+    const initial = { generation: 0 };
+    if (
+      await compareAndSetAppState(CONTENT_WELCOME_PAGE_STATE_KEY, null, initial)
+    ) {
+      return { generation: 0, documentId: null, expectedValue: initial };
+    }
+  }
+}
 function savedDocumentId(state: Record<string, unknown> | null): string | null {
   const candidate = state as ContentLastLocationState | null;
   return typeof candidate?.documentId === "string" && candidate.documentId
@@ -44,22 +123,28 @@ async function resolveUsableDocument(documentId: string) {
   return access.resource;
 }
 
-async function resolveWelcomeDocument(userEmail: string) {
-  const documentId = welcomeDocumentId(userEmail);
-  const document = await resolveUsableDocument(documentId);
-  if (!document) return null;
+async function resolveWelcomeDocument(userEmail: string, documentId: string) {
+  const access = await resolveContentDocumentAccess(documentId);
+  const document = access?.resource;
+  if (!document) {
+    return (await isSoftDeletedDatabaseDocument(documentId))
+      ? { status: "unavailable" as const }
+      : { status: "missing" as const };
+  }
+  if (document.trashedAt || (await isSoftDeletedDatabaseDocument(documentId))) {
+    return { status: "unavailable" as const };
+  }
 
   const normalizedEmail = normalizeContentSpaceEmail(userEmail);
   if (
     normalizeContentSpaceEmail(document.ownerEmail) !== normalizedEmail ||
     document.spaceId !== personalContentSpaceId(normalizedEmail) ||
     document.parentId !== null ||
-    document.visibility !== "private" ||
-    document.title !== WELCOME_TITLE
+    document.visibility !== "private"
   ) {
-    return null;
+    return { status: "unavailable" as const };
   }
-  return documentId;
+  return { status: "usable" as const, documentId };
 }
 
 async function resolveWelcome(userEmail: string): Promise<{
@@ -69,27 +154,72 @@ async function resolveWelcome(userEmail: string): Promise<{
     "welcome-created" | "welcome-reused"
   >;
 }> {
-  const existing = await resolveWelcomeDocument(userEmail);
-  if (existing) return { documentId: existing, resolution: "welcome-reused" };
-
-  const documentId = welcomeDocumentId(userEmail);
   const normalizedEmail = normalizeContentSpaceEmail(userEmail);
-  try {
-    await runWithRequestContext({ userEmail: normalizedEmail }, () =>
-      createDocumentAction.run({
-        id: documentId,
-        title: WELCOME_TITLE,
-        content: WELCOME_CONTENT,
-      }),
-    );
-    return { documentId, resolution: "welcome-created" };
-  } catch (error) {
-    // The stable per-user document ID is the cross-request convergence point.
-    // A competing request can own the insert; only reuse it after the complete
-    // personal-page invariant has been rechecked.
-    const raced = await resolveWelcomeDocument(userEmail);
-    if (raced) return { documentId: raced, resolution: "welcome-reused" };
-    throw error;
+  while (true) {
+    const state = await resolveWelcomeState();
+    const documentId =
+      state.documentId ??
+      legacyWelcomeDocumentId(normalizedEmail, state.generation);
+    const existing = await resolveWelcomeDocument(normalizedEmail, documentId);
+    if (existing.status === "usable") {
+      if (!state.documentId) {
+        await compareAndSetAppState(
+          CONTENT_WELCOME_PAGE_STATE_KEY,
+          state.expectedValue,
+          { ...state.expectedValue, documentId },
+        );
+      }
+      return {
+        documentId: existing.documentId,
+        resolution: "welcome-reused",
+      };
+    }
+
+    if (!state.documentId || existing.status === "unavailable") {
+      await compareAndSetAppState(
+        CONTENT_WELCOME_PAGE_STATE_KEY,
+        state.expectedValue,
+        {
+          ...state.expectedValue,
+          generation: state.generation + 1,
+          documentId: randomWelcomeDocumentId(),
+        },
+      );
+      continue;
+    }
+
+    try {
+      await runWithRequestContext({ userEmail: normalizedEmail }, () =>
+        createDocumentAction.run({
+          id: documentId,
+          title: WELCOME_TITLE,
+          content: WELCOME_CONTENT,
+        }),
+      );
+      return { documentId, resolution: "welcome-created" };
+    } catch (error) {
+      const raced = await resolveWelcomeDocument(normalizedEmail, documentId);
+      if (raced.status === "usable") {
+        return {
+          documentId: raced.documentId,
+          resolution: "welcome-reused",
+        };
+      }
+      if (raced.status === "unavailable") continue;
+      if (isUniqueConstraintError(error)) {
+        await compareAndSetAppState(
+          CONTENT_WELCOME_PAGE_STATE_KEY,
+          state.expectedValue,
+          {
+            ...state.expectedValue,
+            generation: state.generation + 1,
+            documentId: randomWelcomeDocumentId(),
+          },
+        );
+        continue;
+      }
+      throw error;
+    }
   }
 }
 

package/corpus/templates/content/shared/content-landing.ts

@@ -1,9 +1,14 @@
 export const CONTENT_LAST_LOCATION_STATE_KEY = "content-last-location-v1";
+export const CONTENT_WELCOME_PAGE_STATE_KEY = "content-welcome-page-v1";
 
 export type ContentLastLocationState = {
   documentId: string;
 };
 
+export type ContentWelcomePageState = {
+  generation: number;
+  documentId?: string;
+};
 export type ContentLandingResolution =
   | "restored"
   | "welcome-created"

package/corpus/templates/dispatch/changelog/2026-08-12-dispatch-now-appears-in-authorized-workspace-app-directories.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-08-12
+---
+
+Dispatch now appears in authorized workspace app directories for fleet-wide administration

package/corpus/templates/dispatch/server/lib/org-apps-directory.ts

@@ -278,14 +278,13 @@ export interface DiscoveredAppLike {
 
 /**
  * Shape the discovered-agent list into the directory response. The input is
- * Dispatch's EXISTING connected-apps registry — `discoverAgents("dispatch")`
+ * Dispatch's EXISTING connected-apps registry — `discoverAgents()`
  * from `@agent-native/core/server/agent-discovery`, the same source
  * `list-connected-agents` and the `call-agent` delegation path use. It is
  * already allow-list-respecting (hidden first-party templates are excluded
  * from `BUILTIN_AGENTS` unless `defaultAgent`), so no second filter is
- * needed here; we only drop entries without a usable absolute http(s) URL
- * and Dispatch itself (a caller does not need to discover the directory it
- * just called).
+ * needed here; we only drop entries without a usable absolute http(s) URL.
+ * Callers that identify themselves may also request self-filtering.
  */
 export function buildOrgAppsResponse(input: {
   org: string;

package/corpus/templates/dispatch/server/plugins/org-apps-directory.ts

@@ -24,7 +24,7 @@
  *
  * APP-LIST SOURCE — Dispatch's existing connected-apps registry.
  * -------------------------------------------------------------
- * Dispatch already has a connected-apps concept: `discoverAgents("dispatch")`
+ * Dispatch already has a connected-apps concept: `discoverAgents()`
  * from `@agent-native/core/server/agent-discovery` (the same source
  * `list-connected-agents` and the `call-agent` delegation path use). It
  * returns the allow-listed first-party apps with their prod URLs PLUS any
@@ -143,7 +143,16 @@ const orgAppsHandler = defineEventHandler(
     const apps: DiscoveredAppLike[] = await runWithRequestContext(
       { userEmail: verified.email, orgId: localOrg.orgId },
       async () => {
-        const discovered = await discoverAgents(SELF_APP_ID);
+        const includeDirectoryApp =
+          getRequestHeader(event, "x-agent-native-include-directory-app") ===
+          "1";
+        const discovered = await discoverAgents(
+          includeDirectoryApp ? undefined : SELF_APP_ID,
+          {
+            preferLocalUrls:
+              process.env.AGENT_NATIVE_PREFER_LOCAL_APP_URLS === "1",
+          },
+        );
         return discovered.map((a) => ({
           id: a.id,
           name: a.name,
@@ -165,7 +174,10 @@ const orgAppsHandler = defineEventHandler(
     const body = buildOrgAppsResponse({
       org: orgLabel,
       apps,
-      selfId: SELF_APP_ID,
+      selfId:
+        getRequestHeader(event, "x-agent-native-include-directory-app") === "1"
+          ? undefined
+          : SELF_APP_ID,
     });
 
     // Short, cacheable, read-only. Private (per-org) so shared caches must

package/corpus/templates/slides/actions/patch-deck.ts

@@ -157,6 +157,14 @@ const AddSlideOp = z.object({
       notes: z.string().optional(),
       layout: z.string().optional(),
       background: z.string().optional(),
+      imageUrl: z.string().optional(),
+      imagePrompt: z.string().optional(),
+      excalidrawData: z.string().optional(),
+      transition: z
+        .enum(["instant", "none", "fade", "slide", "zoom"])
+        .optional(),
+      animations: z.array(z.unknown()).optional(),
+      splitByParagraph: z.boolean().optional(),
     })
     .passthrough(),
 });
@@ -382,7 +390,10 @@ export function applyOperation(deck: any, op: Operation): void {
       // Idempotency: if the slide already exists (duplicate delivery), skip.
       if (slides.some((s: { id: string }) => s.id === slideId)) return;
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      // Copy every provided field: a duplicated or undo-restored slide has to
+      // keep its transition, animations, and image data, not just its text.
       const newSlide: any = {
+        ...fields,
         id: slideId,
         content:
           typeof fields.content === "string"
@@ -391,9 +402,7 @@ export function applyOperation(deck: any, op: Operation): void {
         notes: fields.notes ?? "",
         layout: fields.layout ?? "content",
       };
-      if (fields.background !== undefined) {
-        newSlide.background = fields.background;
-      }
+      delete newSlide.imageLoading;
       const insertAfterIdx = afterSlideId
         ? slides.findIndex((s: { id: string }) => s.id === afterSlideId)
         : -1;