@useatlas/create 0.0.6 → 0.0.7

package/templates/nextjs-standalone/src/lib/discord/store.ts

@@ -0,0 +1,225 @@
+/**
+ * Discord installation storage.
+ *
+ * Stores per-guild authorization records in the internal database.
+ * In the platform OAuth flow, app credentials (DISCORD_CLIENT_ID, etc.) are
+ * platform-level env vars. In BYOT mode, bot credentials (token, application
+ * ID, public key) are stored per-guild so workspace admins can connect without
+ * platform-level env vars.
+ */
+
+import { hasInternalDB, internalQuery } from "@atlas/api/lib/db/internal";
+import { createLogger } from "@atlas/api/lib/logger";
+import type { DiscordInstallation, DiscordInstallationWithSecret } from "@atlas/api/lib/integrations/types";
+
+export type { DiscordInstallation, DiscordInstallationWithSecret } from "@atlas/api/lib/integrations/types";
+
+const log = createLogger("discord-store");
+
+// ---------------------------------------------------------------------------
+// Shared row parser
+// ---------------------------------------------------------------------------
+
+/**
+ * Parse a DB row into a DiscordInstallationWithSecret, validating required fields.
+ * Returns null and logs a warning if the row is malformed.
+ */
+function parseInstallationRow(
+  row: Record<string, unknown>,
+  context: Record<string, unknown>,
+): DiscordInstallationWithSecret | null {
+  const guildIdVal = row.guild_id;
+  if (typeof guildIdVal !== "string") {
+    log.warn(context, "Invalid Discord installation record in database");
+    return null;
+  }
+  return {
+    guild_id: guildIdVal,
+    org_id: typeof row.org_id === "string" ? row.org_id : null,
+    guild_name: typeof row.guild_name === "string" ? row.guild_name : null,
+    bot_token: typeof row.bot_token === "string" ? row.bot_token : null,
+    application_id: typeof row.application_id === "string" ? row.application_id : null,
+    public_key: typeof row.public_key === "string" ? row.public_key : null,
+    installed_at: typeof row.installed_at === "string" ? row.installed_at : new Date().toISOString(),
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Read operations
+// ---------------------------------------------------------------------------
+
+/**
+ * Get the Discord installation for a guild. Checks internal DB first, then
+ * falls back to env-based detection (DISCORD_CLIENT_ID set = single-guild mode).
+ */
+export async function getDiscordInstallation(
+  guildId: string,
+): Promise<DiscordInstallationWithSecret | null> {
+  if (hasInternalDB()) {
+    try {
+      const rows = await internalQuery<Record<string, unknown>>(
+        "SELECT guild_id, org_id, guild_name, bot_token, application_id, public_key, installed_at::text FROM discord_installations WHERE guild_id = $1",
+        [guildId],
+      );
+      if (rows.length > 0) {
+        return parseInstallationRow(rows[0], { guildId });
+      }
+      return null;
+    } catch (err) {
+      log.error(
+        { err: err instanceof Error ? err.message : String(err), guildId },
+        "Failed to query discord_installations",
+      );
+      throw err;
+    }
+  }
+
+  // Single-guild mode: no internal DB configured, use env var presence
+  const envClientId = process.env.DISCORD_CLIENT_ID;
+  if (envClientId) {
+    return {
+      guild_id: guildId,
+      org_id: null,
+      guild_name: null,
+      bot_token: null,
+      application_id: null,
+      public_key: null,
+      installed_at: new Date().toISOString(),
+    };
+  }
+
+  return null;
+}
+
+/**
+ * Get the Discord installation for an org. Returns null if not found or
+ * if no internal database is configured (org-scoped lookups require a DB).
+ */
+export async function getDiscordInstallationByOrg(
+  orgId: string,
+): Promise<DiscordInstallation | null> {
+  if (!hasInternalDB()) {
+    return null;
+  }
+
+  try {
+    const rows = await internalQuery<Record<string, unknown>>(
+      "SELECT guild_id, org_id, guild_name, bot_token, application_id, public_key, installed_at::text FROM discord_installations WHERE org_id = $1",
+      [orgId],
+    );
+    if (rows.length > 0) {
+      const full = parseInstallationRow(rows[0], { orgId });
+      if (!full) return null;
+      const { bot_token: _, ...pub } = full;
+      return pub;
+    }
+    return null;
+  } catch (err) {
+    log.error(
+      { err: err instanceof Error ? err.message : String(err), orgId },
+      "Failed to query discord_installations by org",
+    );
+    throw err;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Write operations
+// ---------------------------------------------------------------------------
+
+/**
+ * Save or update a Discord installation (OAuth2 callback or BYOT credential submission).
+ * Throws if the guild is already bound to a different organization (hijack protection).
+ * Throws if the database write fails.
+ */
+export async function saveDiscordInstallation(
+  guildId: string,
+  opts?: { orgId?: string; guildName?: string; botToken?: string; applicationId?: string; publicKey?: string },
+): Promise<void> {
+  if (!hasInternalDB()) {
+    throw new Error("Cannot save Discord installation — no internal database configured");
+  }
+
+  const orgId = opts?.orgId ?? null;
+  const guildName = opts?.guildName ?? null;
+  const botToken = opts?.botToken ?? null;
+  const applicationId = opts?.applicationId ?? null;
+  const publicKey = opts?.publicKey ?? null;
+
+  try {
+    // Atomic upsert with hijack protection — the WHERE clause rejects rows
+    // bound to a different org in one statement (no TOCTOU race).
+    const rows = await internalQuery<{ guild_id: string }>(
+      `INSERT INTO discord_installations (guild_id, org_id, guild_name, bot_token, application_id, public_key)
+       VALUES ($1, $2, $3, $4, $5, $6)
+       ON CONFLICT (guild_id) DO UPDATE SET
+         org_id = COALESCE($2, discord_installations.org_id),
+         guild_name = COALESCE($3, discord_installations.guild_name),
+         bot_token = COALESCE($4, discord_installations.bot_token),
+         application_id = COALESCE($5, discord_installations.application_id),
+         public_key = COALESCE($6, discord_installations.public_key),
+         installed_at = now()
+       WHERE discord_installations.org_id IS NULL OR discord_installations.org_id = $2
+       RETURNING guild_id`,
+      [guildId, orgId, guildName, botToken, applicationId, publicKey],
+    );
+
+    if (rows.length === 0) {
+      throw new Error(
+        `Guild ${guildId} is already bound to a different organization. ` +
+        `Disconnect the existing installation first.`,
+      );
+    }
+  } catch (err) {
+    log.error(
+      { err: err instanceof Error ? err.message : String(err), guildId },
+      "Failed to save discord_installations",
+    );
+    throw err;
+  }
+}
+
+/**
+ * Remove a Discord installation by guild ID.
+ * Throws if no internal DB or if the query fails.
+ */
+export async function deleteDiscordInstallation(guildId: string): Promise<void> {
+  if (!hasInternalDB()) {
+    throw new Error("Cannot delete Discord installation — no internal database configured");
+  }
+
+  try {
+    await internalQuery("DELETE FROM discord_installations WHERE guild_id = $1", [guildId]);
+  } catch (err) {
+    log.error(
+      { err: err instanceof Error ? err.message : String(err), guildId },
+      "Failed to delete discord_installations",
+    );
+    throw err;
+  }
+}
+
+/**
+ * Remove the Discord installation for an org.
+ * Returns true if a row was deleted, false if no matching row found.
+ * Throws if no internal DB or if the query fails.
+ */
+export async function deleteDiscordInstallationByOrg(orgId: string): Promise<boolean> {
+  if (!hasInternalDB()) {
+    throw new Error("Cannot delete Discord installation — no internal database configured");
+  }
+
+  try {
+    const rows = await internalQuery<{ guild_id: string }>(
+      "DELETE FROM discord_installations WHERE org_id = $1 RETURNING guild_id",
+      [orgId],
+    );
+    return rows.length > 0;
+  } catch (err) {
+    log.error(
+      { err: err instanceof Error ? err.message : String(err), orgId },
+      "Failed to delete discord_installations by org",
+    );
+    throw err;
+  }
+}

package/templates/nextjs-standalone/src/lib/effect/ai.ts

@@ -0,0 +1,243 @@
+/**
+ * AI Model as Effect Service (P10a).
+ *
+ * Wraps the existing Vercel AI SDK LanguageModel from providers.ts
+ * in an Effect Context.Tag so it can be yielded from Effect programs.
+ *
+ * This is a bridge layer — the model is still created by providers.ts
+ * and uses Vercel AI SDK under the hood. P10c will migrate to native
+ * @effect/ai AiLanguageModel.
+ *
+ * In SaaS mode, the model is re-resolved on a short TTL (5s) from settings
+ * so that ATLAS_PROVIDER / ATLAS_MODEL changes take effect without restart.
+ *
+ * @example
+ * ```ts
+ * import { AtlasAiModel } from "@atlas/api/lib/effect";
+ *
+ * const program = Effect.gen(function* () {
+ *   const { model, providerType } = yield* AtlasAiModel;
+ *   // Use model with Vercel AI SDK's streamText/generateText
+ *   return providerType;
+ * });
+ * ```
+ */
+
+import { Context, Effect, Layer } from "effect";
+import type { LanguageModel } from "ai";
+import { createLogger } from "@atlas/api/lib/logger";
+
+const log = createLogger("effect:ai");
+
+// Re-export the ProviderType from providers.ts for convenience
+type ProviderType = import("@atlas/api/lib/providers").ProviderType;
+
+// ── Service interface ────────────────────────────────────────────────
+
+/**
+ * Atlas AI model service — provides the configured LLM.
+ *
+ * The model is a Vercel AI SDK LanguageModel (bridge pattern).
+ * `providerType` is used for cache control and prompt formatting decisions.
+ */
+export interface AtlasAiModelShape {
+  /** The configured LLM instance (Vercel AI SDK LanguageModel). */
+  readonly model: LanguageModel;
+  /** Provider type for cache control and system prompt formatting. */
+  readonly providerType: ProviderType;
+  /** Model ID string (e.g. "claude-opus-4-6", "gpt-4o"). */
+  readonly modelId: string;
+}
+
+// ── Context.Tag ──────────────────────────────────────────────────────
+
+export class AtlasAiModel extends Context.Tag("AtlasAiModel")<
+  AtlasAiModel,
+  AtlasAiModelShape
+>() {}
+
+// ── Live Layer ───────────────────────────────────────────────────────
+
+/**
+ * Resolve model from current settings. Used at boot and on a short TTL (5s) in SaaS mode.
+ *
+ * Uses `getModelForConfig()` to build the model from explicit provider/model values,
+ * avoiding process.env mutation.
+ */
+function resolveModelFromSettings(): { model: LanguageModel; providerType: ProviderType; modelId: string } {
+  // Read settings — in SaaS mode these may have been changed via admin UI
+  // eslint-disable-next-line @typescript-eslint/no-require-imports -- lazy import avoids circular dependency
+  const { getSettingAuto } = require("@atlas/api/lib/settings") as {
+    getSettingAuto: (key: string) => string | undefined;
+  };
+  // eslint-disable-next-line @typescript-eslint/no-require-imports -- lazy import avoids circular dependency
+  const { getModelForConfig } = require("@atlas/api/lib/providers") as {
+    getModelForConfig: (provider?: string, model?: string) => { model: LanguageModel; providerType: ProviderType; modelId: string };
+  };
+
+  const providerSetting = getSettingAuto("ATLAS_PROVIDER");
+  const modelSetting = getSettingAuto("ATLAS_MODEL");
+
+  return getModelForConfig(providerSetting, modelSetting);
+}
+
+/**
+ * Create the Live layer for AtlasAiModel.
+ *
+ * Reads ATLAS_PROVIDER and ATLAS_MODEL from env vars via providers.ts.
+ * Fails the Layer if the provider is misconfigured.
+ *
+ * In SaaS mode, the service uses getter properties that re-resolve the
+ * model from settings on access (with a 5s TTL cache), so admin changes
+ * take effect without a server restart.
+ */
+export const AtlasAiModelLive: Layer.Layer<AtlasAiModel, Error> = Layer.effect(
+  AtlasAiModel,
+  Effect.gen(function* () {
+    // Boot-time resolution — validates config is valid at startup
+    const bootModel = yield* Effect.tryPromise({
+      try: async () => resolveModelFromSettings(),
+      catch: (err) =>
+        new Error(
+          `AI model initialization failed: ${err instanceof Error ? err.message : String(err)}`,
+        ),
+    });
+
+    log.info({ provider: bootModel.providerType, model: bootModel.modelId }, "AI model configured");
+
+    // Check if SaaS mode — if so, return a service that resolves dynamically
+    let saas = false;
+    try {
+      // eslint-disable-next-line @typescript-eslint/no-require-imports -- lazy import avoids circular dependency
+      const { getConfig } = require("@atlas/api/lib/config") as {
+        getConfig: () => { deployMode?: string } | null;
+      };
+      saas = getConfig()?.deployMode === "saas";
+    } catch (err) {
+      // intentionally ignored: config may not be ready during Layer construction
+      log.debug({ err: err instanceof Error ? err.message : String(err) }, "SaaS mode detection failed — using static model");
+    }
+
+    if (saas) {
+      // In SaaS mode, cache the resolved model with a short TTL so we don't
+      // create a new SDK client on every single streamText call.
+      let cached = bootModel;
+      let cachedAt = Date.now();
+      const TTL = 5_000;
+
+      const dynamicService: AtlasAiModelShape = {
+        get model() {
+          const now = Date.now();
+          if (now - cachedAt > TTL) {
+            try {
+              cached = resolveModelFromSettings();
+              cachedAt = now;
+            } catch (err) {
+              log.warn(
+                { err: err instanceof Error ? err.message : String(err) },
+                "Failed to re-resolve AI model — using cached model",
+              );
+            }
+          }
+          return cached.model;
+        },
+        get providerType() {
+          return cached.providerType;
+        },
+        get modelId() {
+          return cached.modelId;
+        },
+      };
+      return dynamicService satisfies AtlasAiModelShape;
+    }
+
+    return bootModel satisfies AtlasAiModelShape;
+  }),
+);
+
+/**
+ * Create a Live layer for a workspace-level model configuration.
+ *
+ * Enterprise workspaces can override the platform default with their
+ * own provider/model/API key. This Layer reads from workspace config
+ * instead of env vars.
+ */
+export function makeWorkspaceAiModelLayer(config: {
+  provider: import("@useatlas/types").ModelConfigProvider;
+  model: string;
+  apiKey: string;
+  baseUrl: string | null;
+}): Layer.Layer<AtlasAiModel, Error> {
+  return Layer.effect(
+    AtlasAiModel,
+    Effect.gen(function* () {
+      const { model, providerType } = yield* Effect.tryPromise({
+        try: async () => {
+          const { getModelFromWorkspaceConfig, getWorkspaceProviderType } =
+            await import("@atlas/api/lib/providers");
+          const model = getModelFromWorkspaceConfig(config);
+          const providerType = getWorkspaceProviderType(config.provider);
+          return { model, providerType };
+        },
+        catch: (err) =>
+          new Error(
+            `Workspace AI model initialization failed: ${err instanceof Error ? err.message : String(err)}`,
+          ),
+      });
+
+      return {
+        model,
+        providerType,
+        modelId: config.model,
+      } satisfies AtlasAiModelShape;
+    }),
+  );
+}
+
+// ── Test helper ──────────────────────────────────────────────────────
+
+/**
+ * Create a test Layer for AtlasAiModel.
+ *
+ * Provides a mock model that can be used in tests without requiring
+ * real API keys or network access.
+ *
+ * @example
+ * ```ts
+ * const TestLayer = createAiModelTestLayer({
+ *   providerType: "anthropic",
+ *   modelId: "test-model",
+ * });
+ *
+ * const result = await Effect.runPromise(
+ *   Effect.gen(function* () {
+ *     const { providerType } = yield* AtlasAiModel;
+ *     return providerType;
+ *   }).pipe(Effect.provide(TestLayer)),
+ * );
+ * ```
+ */
+export function createAiModelTestLayer(
+  partial: Partial<AtlasAiModelShape> = {},
+): Layer.Layer<AtlasAiModel> {
+  const mockModel = {
+    modelId: partial.modelId ?? "test-model",
+    provider: "test-provider",
+    specificationVersion: "v1",
+    defaultObjectGenerationMode: undefined,
+    supportsImageUrls: false,
+    supportsStructuredOutputs: false,
+    doGenerate: async () => {
+      throw new Error("Mock model: doGenerate not implemented");
+    },
+    doStream: async () => {
+      throw new Error("Mock model: doStream not implemented");
+    },
+  } as unknown as LanguageModel;
+
+  return Layer.succeed(AtlasAiModel, {
+    model: partial.model ?? mockModel,
+    providerType: partial.providerType ?? "anthropic",
+    modelId: partial.modelId ?? "test-model",
+  });
+}

package/templates/nextjs-standalone/src/lib/effect/errors.ts

@@ -0,0 +1,234 @@
+/**
+ * Tagged error types for the Effect.ts migration.
+ *
+ * Each error class uses `Data.TaggedError` so that Effect's `catchTag` and
+ * `catchTags` can discriminate on the `_tag` field. The field set on each
+ * error carries the context needed for logging and HTTP response mapping.
+ *
+ * Categories match the existing error shapes in the codebase:
+ *   - SQL validation (4-layer pipeline in tools/sql.ts)
+ *   - Connection (connection.ts registry)
+ *   - Query execution (DB errors from pg/mysql2)
+ *   - Rate limiting (source-rate-limit.ts)
+ *   - RLS (row-level security injection)
+ *   - Enterprise (feature gates and approval workflows)
+ *   - Plugin (hook and validator errors)
+ *   - Action (timeout in action handler)
+ */
+
+import { Data } from "effect";
+
+// ── SQL Validation ──────────────────────────────────────────────────
+
+/** Empty or whitespace-only SQL input. */
+export class EmptyQueryError extends Data.TaggedError("EmptyQueryError")<{
+  readonly message: string;
+}> {}
+
+/** DML/DDL keyword detected by regex guard (layer 1). */
+export class ForbiddenPatternError extends Data.TaggedError("ForbiddenPatternError")<{
+  readonly message: string;
+  readonly pattern: string;
+  readonly sql: string;
+}> {}
+
+/** AST parse failure, multiple statements, or non-SELECT (layer 2). */
+export class ParseError extends Data.TaggedError("ParseError")<{
+  readonly message: string;
+  readonly sql: string;
+  readonly detail?: string;
+}> {}
+
+/** Table not in the semantic-layer whitelist (layer 3). */
+export class WhitelistError extends Data.TaggedError("WhitelistError")<{
+  readonly message: string;
+  readonly table: string;
+  readonly allowed: ReadonlyArray<string>;
+}> {}
+
+// ── Connection ──────────────────────────────────────────────────────
+
+/** Connection ID not found in the ConnectionRegistry. */
+export class ConnectionNotFoundError extends Data.TaggedError("ConnectionNotFoundError")<{
+  readonly message: string;
+  readonly connectionId: string;
+  readonly available: ReadonlyArray<string>;
+}> {}
+
+/** Org pool would exceed maxTotalConnections. */
+export class PoolExhaustedError extends Data.TaggedError("PoolExhaustedError")<{
+  readonly message: string;
+  readonly current: number;
+  readonly max: number;
+}> {}
+
+/** No analytics datasource URL configured. */
+export class NoDatasourceError extends Data.TaggedError("NoDatasourceError")<{
+  readonly message: string;
+}> {}
+
+// ── Query Execution ─────────────────────────────────────────────────
+
+/** Statement timeout exceeded. */
+export class QueryTimeoutError extends Data.TaggedError("QueryTimeoutError")<{
+  readonly message: string;
+  readonly sql: string;
+  readonly timeoutMs: number;
+}> {}
+
+/** Database returned an error during query execution. */
+export class QueryExecutionError extends Data.TaggedError("QueryExecutionError")<{
+  readonly message: string;
+  readonly hint?: string;
+  readonly position?: string;
+}> {}
+
+// ── Rate Limiting ───────────────────────────────────────────────────
+
+/** QPM (queries per minute) limit exceeded for a datasource. */
+export class RateLimitExceededError extends Data.TaggedError("RateLimitExceededError")<{
+  readonly message: string;
+  readonly sourceId: string;
+  readonly limit: number;
+  readonly retryAfterMs?: number;
+}> {}
+
+/** Concurrent query limit reached for a datasource. */
+export class ConcurrencyLimitError extends Data.TaggedError("ConcurrencyLimitError")<{
+  readonly message: string;
+  readonly sourceId: string;
+  readonly limit: number;
+}> {}
+
+// ── Row-Level Security ──────────────────────────────────────────────
+
+/** RLS processing failed (table extraction, filter resolution, or injection). */
+export class RLSError extends Data.TaggedError("RLSError")<{
+  readonly message: string;
+  readonly phase: "extraction" | "filter" | "injection";
+}> {}
+
+// ── Enterprise ──────────────────────────────────────────────────────
+
+/** Enterprise feature not available (ee module missing or disabled). */
+export class EnterpriseGateError extends Data.TaggedError("EnterpriseGateError")<{
+  readonly message: string;
+  readonly feature: string;
+}> {}
+
+/** Query requires approval before execution. */
+export class ApprovalRequiredError extends Data.TaggedError("ApprovalRequiredError")<{
+  readonly message: string;
+  readonly rules: ReadonlyArray<string>;
+}> {}
+
+// ── Plugin ──────────────────────────────────────────────────────────
+
+/** Plugin beforeQuery hook rejected the query. */
+export class PluginRejectedError extends Data.TaggedError("PluginRejectedError")<{
+  readonly message: string;
+  readonly connectionId: string;
+}> {}
+
+/** Custom validator threw an exception or returned invalid shape. */
+export class CustomValidatorError extends Data.TaggedError("CustomValidatorError")<{
+  readonly message: string;
+  readonly connectionId: string;
+}> {}
+
+// ── Action ──────────────────────────────────────────────────────────
+
+/** Action execution timed out. */
+export class ActionTimeoutError extends Data.TaggedError("ActionTimeoutError")<{
+  readonly message: string;
+  readonly timeoutMs: number;
+}> {}
+
+// ── Scheduler ──────────────────────────────────────────────────────
+
+/** Scheduled task execution timed out. */
+export class SchedulerTaskTimeoutError extends Data.TaggedError("SchedulerTaskTimeoutError")<{
+  readonly message: string;
+  readonly taskId: string;
+  readonly timeoutMs: number;
+}> {}
+
+/** Scheduled task execution failed. */
+export class SchedulerExecutionError extends Data.TaggedError("SchedulerExecutionError")<{
+  readonly message: string;
+  readonly taskId: string;
+  readonly runId?: string;
+}> {}
+
+/** Delivery to a recipient channel failed. */
+export class DeliveryError extends Data.TaggedError("DeliveryError")<{
+  readonly message: string;
+  readonly channel: string;
+  readonly recipient: string;
+  /** When true, this error is permanent and should not be retried. */
+  readonly permanent: boolean;
+}> {}
+
+// ── Union type ──────────────────────────────────────────────────────
+
+/** Union of all known Atlas error types for exhaustive matching. */
+export type AtlasError =
+  | EmptyQueryError
+  | ForbiddenPatternError
+  | ParseError
+  | WhitelistError
+  | ConnectionNotFoundError
+  | PoolExhaustedError
+  | NoDatasourceError
+  | QueryTimeoutError
+  | QueryExecutionError
+  | RateLimitExceededError
+  | ConcurrencyLimitError
+  | RLSError
+  | EnterpriseGateError
+  | ApprovalRequiredError
+  | PluginRejectedError
+  | CustomValidatorError
+  | ActionTimeoutError
+  | SchedulerTaskTimeoutError
+  | SchedulerExecutionError
+  | DeliveryError;
+
+/** Discriminant union of all known `_tag` values — derived from `AtlasError`. */
+export type AtlasErrorTag = AtlasError["_tag"];
+
+/**
+ * Compile-time verified list of all known `_tag` values.
+ *
+ * The `satisfies` clause ensures this array stays in sync with `AtlasErrorTag`:
+ * adding a new error variant to the `AtlasError` union without updating this
+ * list causes a type error. Used by `hono.ts` to build the `ATLAS_ERROR_TAGS`
+ * set for runtime error classification.
+ */
+export const ATLAS_ERROR_TAG_LIST = [
+  "EmptyQueryError",
+  "ForbiddenPatternError",
+  "ParseError",
+  "WhitelistError",
+  "ConnectionNotFoundError",
+  "PoolExhaustedError",
+  "NoDatasourceError",
+  "QueryTimeoutError",
+  "QueryExecutionError",
+  "RateLimitExceededError",
+  "ConcurrencyLimitError",
+  "RLSError",
+  "EnterpriseGateError",
+  "ApprovalRequiredError",
+  "PluginRejectedError",
+  "CustomValidatorError",
+  "ActionTimeoutError",
+  "SchedulerTaskTimeoutError",
+  "SchedulerExecutionError",
+  "DeliveryError",
+] as const satisfies readonly AtlasErrorTag[];
+
+/** Compile-time check: every `AtlasErrorTag` must appear in the list. */
+type _AssertComplete = AtlasErrorTag extends (typeof ATLAS_ERROR_TAG_LIST)[number] ? true : never;
+const _assertComplete: _AssertComplete = true;
+void _assertComplete;