@ekrist1/vulse 0.1.6-alpha.3 → 0.1.7-alpha.4

package/src/server/email.ts

@@ -0,0 +1,17 @@
+export interface EmailEnv {
+  EMAIL_FROM?: string
+  EMAIL_API_TOKEN?: string
+}
+
+export async function sendEmail(
+  env: EmailEnv,
+  input: { to: string; subject: string; body: string },
+): Promise<'sent' | 'logged'> {
+  if (!env.EMAIL_FROM || !env.EMAIL_API_TOKEN) {
+    console.log(`[vulse-email] to=${input.to} subject=${input.subject}\n${input.body}`)
+    return 'logged'
+  }
+  // Placeholder: real Email Workers integration documented in README.
+  console.log(`[vulse-email] to=${input.to} subject=${input.subject}`)
+  return 'sent'
+}

package/src/server/endpoints/api-auth.ts

@@ -0,0 +1,10 @@
+import type { APIRoute } from 'astro'
+import { withRuntime } from './with-runtime.js'
+
+export const ALL: APIRoute = async ({ request }) => {
+  const rt = await withRuntime(request)
+  return rt.auth.handler(request)
+}
+
+export const GET = ALL
+export const POST = ALL

package/src/server/endpoints/api-vulse-blueprints.ts

@@ -0,0 +1,23 @@
+import type { APIRoute } from 'astro'
+import { withRuntime } from './with-runtime.js'
+
+export const GET: APIRoute = async ({ params, request }) => {
+  const rt = await withRuntime(request)
+  if (params.handle) return rt.routes.blueprints.get(request, params as Record<string, string>)
+  return rt.routes.blueprints.list(request)
+}
+
+export const POST: APIRoute = async ({ request }) => {
+  const rt = await withRuntime(request)
+  return rt.routes.blueprints.create(request)
+}
+
+export const PATCH: APIRoute = async ({ params, request }) => {
+  const rt = await withRuntime(request)
+  return rt.routes.blueprints.update(request, params as Record<string, string>)
+}
+
+export const DELETE: APIRoute = async ({ params, request }) => {
+  const rt = await withRuntime(request)
+  return rt.routes.blueprints.delete(request, params as Record<string, string>)
+}

package/src/server/endpoints/api-vulse-entries-locales.ts

@@ -0,0 +1,12 @@
+import type { APIRoute } from 'astro'
+import { withRuntime } from './with-runtime.js'
+
+export const GET: APIRoute = async ({ params, request }) => {
+  const rt = await withRuntime(request)
+  return rt.routes.entries.listLocales(request, params as Record<string, string>)
+}
+
+export const POST: APIRoute = async ({ params, request }) => {
+  const rt = await withRuntime(request)
+  return rt.routes.entries.createLocale(request, params as Record<string, string>)
+}

package/src/server/endpoints/api-vulse-entries-move.ts

@@ -0,0 +1,7 @@
+import type { APIRoute } from 'astro'
+import { withRuntime } from './with-runtime.js'
+
+export const PATCH: APIRoute = async ({ params, request }) => {
+  const rt = await withRuntime(request)
+  return rt.routes.entries.move(request, params as Record<string, string>)
+}

package/src/server/endpoints/api-vulse-entries-publish.ts

@@ -0,0 +1,7 @@
+import type { APIRoute } from 'astro'
+import { withRuntime } from './with-runtime.js'
+
+export const POST: APIRoute = async ({ params, request }) => {
+  const rt = await withRuntime(request)
+  return rt.routes.entries.publish(request, params as Record<string, string>)
+}

package/src/server/endpoints/api-vulse-entries-tree.ts

@@ -0,0 +1,7 @@
+import type { APIRoute } from 'astro'
+import { withRuntime } from './with-runtime.js'
+
+export const GET: APIRoute = async ({ params, request }) => {
+  const rt = await withRuntime(request)
+  return rt.routes.entries.tree(request, params as Record<string, string>)
+}

package/src/server/endpoints/api-vulse-entries.ts

@@ -0,0 +1,23 @@
+import type { APIRoute } from 'astro'
+import { withRuntime } from './with-runtime.js'
+
+export const GET: APIRoute = async ({ params, request }) => {
+  const rt = await withRuntime(request)
+  if (params.id) return rt.routes.entries.findById(request, params as Record<string, string>)
+  return rt.routes.entries.list(request, params as Record<string, string>)
+}
+
+export const POST: APIRoute = async ({ params, request }) => {
+  const rt = await withRuntime(request)
+  return rt.routes.entries.create(request, params as Record<string, string>)
+}
+
+export const PUT: APIRoute = async ({ params, request }) => {
+  const rt = await withRuntime(request)
+  return rt.routes.entries.update(request, params as Record<string, string>)
+}
+
+export const DELETE: APIRoute = async ({ params, request }) => {
+  const rt = await withRuntime(request)
+  return rt.routes.entries.delete(request, params as Record<string, string>)
+}

package/src/server/endpoints/api-vulse-form-handle.ts

@@ -0,0 +1,30 @@
+import type { APIRoute } from 'astro'
+import { withRuntime } from './with-runtime.js'
+
+export const GET: APIRoute = async ({ params, request }) => {
+  const rt = await withRuntime(request)
+  if (params.id) return rt.routes.forms.getSubmission(request, params as Record<string, string>)
+  if (params.handle && request.url.includes('/submissions')) {
+    return rt.routes.forms.listSubmissions(request, params as Record<string, string>)
+  }
+  return rt.routes.forms.get(request, params as Record<string, string>)
+}
+
+export const PUT: APIRoute = async ({ params, request }) => {
+  const rt = await withRuntime(request)
+  return rt.routes.forms.update(request, params as Record<string, string>)
+}
+
+export const DELETE: APIRoute = async ({ params, request }) => {
+  const rt = await withRuntime(request)
+  if (params.id) return rt.routes.forms.deleteSubmission(request, params as Record<string, string>)
+  return rt.routes.forms.delete(request, params as Record<string, string>)
+}
+
+export const POST: APIRoute = async ({ params, request }) => {
+  const rt = await withRuntime(request)
+  if (request.url.includes('/submissions/delete')) {
+    return rt.routes.forms.bulkDeleteSubmissions(request, params as Record<string, string>)
+  }
+  return new Response('Not found', { status: 404 })
+}

package/src/server/endpoints/api-vulse-form-public.ts

@@ -0,0 +1,7 @@
+import type { APIRoute } from 'astro'
+import { withRuntime } from './with-runtime.js'
+
+export const GET: APIRoute = async ({ params, request }) => {
+  const rt = await withRuntime(request)
+  return rt.routes.formSubmit.public(request, params as Record<string, string>)
+}

package/src/server/endpoints/api-vulse-form-submit.ts

@@ -0,0 +1,7 @@
+import type { APIRoute } from 'astro'
+import { withRuntime } from './with-runtime.js'
+
+export const POST: APIRoute = async ({ params, request }) => {
+  const rt = await withRuntime(request)
+  return rt.routes.formSubmit.submit(request, params as Record<string, string>)
+}

package/src/server/endpoints/api-vulse-form-upload.ts

@@ -0,0 +1,7 @@
+import type { APIRoute } from 'astro'
+import { withRuntime } from './with-runtime.js'
+
+export const POST: APIRoute = async ({ params, request }) => {
+  const rt = await withRuntime(request)
+  return rt.routes.formUpload.upload(request, params as Record<string, string>)
+}

package/src/server/endpoints/api-vulse-forms.ts

@@ -0,0 +1,12 @@
+import type { APIRoute } from 'astro'
+import { withRuntime } from './with-runtime.js'
+
+export const GET: APIRoute = async ({ request }) => {
+  const rt = await withRuntime(request)
+  return rt.routes.forms.list(request)
+}
+
+export const POST: APIRoute = async ({ request }) => {
+  const rt = await withRuntime(request)
+  return rt.routes.forms.create(request)
+}

package/src/server/endpoints/api-vulse-globals-handle.ts

@@ -0,0 +1,20 @@
+import type { APIRoute } from 'astro'
+import { withRuntime } from './with-runtime.js'
+
+export const GET: APIRoute = async ({ params, request }) => {
+  const rt = await withRuntime(request)
+  if (!params.handle) return new Response('Not found', { status: 404 })
+  return rt.routes.globals.get(request, params as Record<string, string>)
+}
+
+export const PUT: APIRoute = async ({ params, request }) => {
+  const rt = await withRuntime(request)
+  if (!params.handle) return new Response('Not found', { status: 404 })
+  return rt.routes.globals.update(request, params as Record<string, string>)
+}
+
+export const DELETE: APIRoute = async ({ params, request }) => {
+  const rt = await withRuntime(request)
+  if (!params.handle) return new Response('Not found', { status: 404 })
+  return rt.routes.globals.delete(request, params as Record<string, string>)
+}

package/src/server/endpoints/api-vulse-globals-public-handle.ts

@@ -0,0 +1,7 @@
+import type { APIRoute } from 'astro'
+import { withRuntime } from './with-runtime.js'
+
+export const GET: APIRoute = async ({ params, request }) => {
+  const rt = await withRuntime(request)
+  return rt.routes.globalsPublic.get(request, params as Record<string, string>)
+}

package/src/server/endpoints/api-vulse-globals-public.ts

@@ -0,0 +1,7 @@
+import type { APIRoute } from 'astro'
+import { withRuntime } from './with-runtime.js'
+
+export const GET: APIRoute = async ({ request }) => {
+  const rt = await withRuntime(request)
+  return rt.routes.globalsPublic.list()
+}

package/src/server/endpoints/api-vulse-globals-value.ts

@@ -0,0 +1,8 @@
+import type { APIRoute } from 'astro'
+import { withRuntime } from './with-runtime.js'
+
+export const PUT: APIRoute = async ({ params, request }) => {
+  const rt = await withRuntime(request)
+  if (!params.handle) return new Response('Not found', { status: 404 })
+  return rt.routes.globals.updateValue(request, params as Record<string, string>)
+}

package/src/server/endpoints/api-vulse-globals.ts

@@ -0,0 +1,12 @@
+import type { APIRoute } from 'astro'
+import { withRuntime } from './with-runtime.js'
+
+export const GET: APIRoute = async ({ request }) => {
+  const rt = await withRuntime(request)
+  return rt.routes.globals.list(request)
+}
+
+export const POST: APIRoute = async ({ request }) => {
+  const rt = await withRuntime(request)
+  return rt.routes.globals.create(request)
+}

package/src/server/endpoints/api-vulse-media-file.ts

@@ -0,0 +1,7 @@
+import type { APIRoute } from 'astro'
+import { withRuntime } from './with-runtime.js'
+
+export const GET: APIRoute = async ({ params, request }) => {
+  const rt = await withRuntime(request)
+  return rt.routes.media.file(request, params as Record<string, string>)
+}

package/src/server/endpoints/api-vulse-media-id.ts

@@ -0,0 +1,12 @@
+import type { APIRoute } from 'astro'
+import { withRuntime } from './with-runtime.js'
+
+export const DELETE: APIRoute = async ({ params, request }) => {
+  const rt = await withRuntime(request)
+  return rt.routes.media.delete(request, params as Record<string, string>)
+}
+
+export const PATCH: APIRoute = async ({ params, request }) => {
+  const rt = await withRuntime(request)
+  return rt.routes.media.updateAlt(request, params as Record<string, string>)
+}

package/src/server/endpoints/api-vulse-media.ts

@@ -0,0 +1,12 @@
+import type { APIRoute } from 'astro'
+import { withRuntime } from './with-runtime.js'
+
+export const GET: APIRoute = async ({ request }) => {
+  const rt = await withRuntime(request)
+  return rt.routes.media.list(request)
+}
+
+export const POST: APIRoute = async ({ request }) => {
+  const rt = await withRuntime(request)
+  return rt.routes.media.upload(request)
+}

package/src/server/endpoints/api-vulse-preview-bridge.ts

@@ -0,0 +1,11 @@
+import type { APIRoute } from 'astro'
+import { livePreviewBridgeSource } from '../assets/live-preview-bridge.content.js'
+
+export const GET: APIRoute = async () => {
+  return new Response(livePreviewBridgeSource, {
+    headers: {
+      'Content-Type': 'application/javascript; charset=utf-8',
+      'Cache-Control': 'public, max-age=3600',
+    },
+  })
+}

package/src/server/endpoints/api-vulse-preview-sessions-id.ts

@@ -0,0 +1,10 @@
+import type { APIRoute } from 'astro'
+import { withRuntime } from './with-runtime.js'
+
+export const ALL: APIRoute = async ({ request, params }) => {
+  const rt = await withRuntime(request)
+  const id = params.id!
+  if (request.method === 'PUT') return rt.routes.previewSessions.update(request, { id })
+  if (request.method === 'DELETE') return rt.routes.previewSessions.remove(request, { id })
+  return new Response('Method Not Allowed', { status: 405 })
+}

package/src/server/endpoints/api-vulse-preview-sessions.ts

@@ -0,0 +1,7 @@
+import type { APIRoute } from 'astro'
+import { withRuntime } from './with-runtime.js'
+
+export const POST: APIRoute = async ({ request }) => {
+  const rt = await withRuntime(request)
+  return rt.routes.previewSessions.create(request)
+}

package/src/server/endpoints/api-vulse-preview-start.ts

@@ -0,0 +1,7 @@
+import type { APIRoute } from 'astro'
+import { withRuntime } from './with-runtime.js'
+
+export const GET: APIRoute = async ({ request }) => {
+  const rt = await withRuntime(request)
+  return rt.routes.preview.start(request)
+}

package/src/server/endpoints/api-vulse-preview-stop.ts

@@ -0,0 +1,7 @@
+import type { APIRoute } from 'astro'
+import { withRuntime } from './with-runtime.js'
+
+export const GET: APIRoute = async ({ request }) => {
+  const rt = await withRuntime(request)
+  return rt.routes.preview.stop(request)
+}

package/src/server/endpoints/api-vulse-revisions-restore.ts

@@ -0,0 +1,7 @@
+import type { APIRoute } from 'astro'
+import { withRuntime } from './with-runtime.js'
+
+export const POST: APIRoute = async ({ params, request }) => {
+  const rt = await withRuntime(request)
+  return rt.routes.revisions.restore(request, params as Record<string, string>)
+}

package/src/server/endpoints/api-vulse-revisions.ts

@@ -0,0 +1,7 @@
+import type { APIRoute } from 'astro'
+import { withRuntime } from './with-runtime.js'
+
+export const GET: APIRoute = async ({ params, request }) => {
+  const rt = await withRuntime(request)
+  return rt.routes.revisions.list(request, params as Record<string, string>)
+}

package/src/server/endpoints/api-vulse-search.ts

@@ -0,0 +1,7 @@
+import type { APIRoute } from 'astro'
+import { withRuntime } from './with-runtime.js'
+
+export const POST: APIRoute = async ({ request }) => {
+  const rt = await withRuntime(request)
+  return rt.routes.search.query(request)
+}

package/src/server/endpoints/api-vulse-sets.ts

@@ -0,0 +1,23 @@
+import type { APIRoute } from 'astro'
+import { withRuntime } from './with-runtime.js'
+
+export const GET: APIRoute = async ({ params, request }) => {
+  const rt = await withRuntime(request)
+  if (params.handle) return rt.routes.sets.get(request, params as Record<string, string>)
+  return rt.routes.sets.list(request)
+}
+
+export const POST: APIRoute = async ({ request }) => {
+  const rt = await withRuntime(request)
+  return rt.routes.sets.create(request)
+}
+
+export const PATCH: APIRoute = async ({ params, request }) => {
+  const rt = await withRuntime(request)
+  return rt.routes.sets.update(request, params as Record<string, string>)
+}
+
+export const DELETE: APIRoute = async ({ params, request }) => {
+  const rt = await withRuntime(request)
+  return rt.routes.sets.delete(request, params as Record<string, string>)
+}

package/src/server/endpoints/api-vulse-settings.ts

@@ -0,0 +1,12 @@
+import type { APIRoute } from 'astro'
+import { withRuntime } from './with-runtime.js'
+
+export const GET: APIRoute = async ({ request }) => {
+  const rt = await withRuntime(request)
+  return rt.routes.settings.list(request)
+}
+
+export const PUT: APIRoute = async ({ params, request }) => {
+  const rt = await withRuntime(request)
+  return rt.routes.settings.set(request, params as Record<string, string>)
+}

package/src/server/endpoints/api-vulse-users-id.ts

@@ -0,0 +1,12 @@
+import type { APIRoute } from 'astro'
+import { withRuntime } from './with-runtime.js'
+
+export const GET: APIRoute = async ({ params, request }) => {
+  const rt = await withRuntime(request)
+  return rt.routes.users.get(request, params as Record<string, string>)
+}
+
+export const PATCH: APIRoute = async ({ params, request }) => {
+  const rt = await withRuntime(request)
+  return rt.routes.users.update(request, params as Record<string, string>)
+}

package/src/server/endpoints/api-vulse-users-reset-password.ts

@@ -0,0 +1,7 @@
+import type { APIRoute } from 'astro'
+import { withRuntime } from './with-runtime.js'
+
+export const POST: APIRoute = async ({ params, request }) => {
+  const rt = await withRuntime(request)
+  return rt.routes.users.resetPassword(request, params as Record<string, string>)
+}

package/src/server/endpoints/api-vulse-users-role.ts

@@ -0,0 +1,9 @@
+import type { APIRoute } from 'astro'
+import { withRuntime } from './with-runtime.js'
+
+export const POST: APIRoute = async ({ params, request }) => {
+  const rt = await withRuntime(request)
+  return rt.routes.users.setRole(request, params as Record<string, string>)
+}
+
+export const PUT: APIRoute = POST

package/src/server/endpoints/api-vulse-users.ts

@@ -0,0 +1,7 @@
+import type { APIRoute } from 'astro'
+import { withRuntime } from './with-runtime.js'
+
+export const GET: APIRoute = async ({ request }) => {
+  const rt = await withRuntime(request)
+  return rt.routes.users.list(request)
+}

package/src/server/endpoints/with-runtime.ts

@@ -0,0 +1,11 @@
+import { getRuntimeEnv } from '../env.js'
+import { createDb } from '../../core/db.js'
+import { registryForRequest } from '../../core/blueprints/load.js'
+import { getRuntime } from '../runtime.js'
+
+export async function withRuntime(request: Request) {
+  const env = getRuntimeEnv()
+  const db = createDb(env.DB)
+  const registry = await registryForRequest(db)
+  return getRuntime(env, registry, new URL(request.url).origin)
+}

package/src/server/env.ts

@@ -0,0 +1,23 @@
+import { env as cfEnv } from 'cloudflare:workers'
+
+export interface RuntimeEnv {
+  DB: D1Database
+  BUCKET?: R2Bucket
+  FORM_QUEUE?: Queue
+  BETTER_AUTH_SECRET: string
+  BETTER_AUTH_URL?: string
+  VULSE_PREVIEW_SECRET?: string
+  /** When `"true"`, enables public sign-up (overrides DB setting). Useful for local playgrounds. */
+  VULSE_ALLOW_MEMBER_SIGNUP?: string
+  CF_IMAGES_ACCOUNT_HASH?: string
+  CF_IMAGES_TOKEN?: string
+  EMAIL_FROM?: string
+  EMAIL_API_TOKEN?: string
+}
+
+export function getRuntimeEnv(): RuntimeEnv {
+  const env = cfEnv as RuntimeEnv
+  if (!env.DB) throw new Error('Vulse: D1 binding "DB" is missing. Add it to wrangler.toml.')
+  if (!env.BETTER_AUTH_SECRET) throw new Error('Vulse: BETTER_AUTH_SECRET missing from wrangler.toml [vars].')
+  return env
+}

package/src/server/envelope.ts

@@ -0,0 +1,21 @@
+import { VulseError } from '../core/errors.js'
+
+export interface OkEnvelope<T> { ok: true; data: T }
+export interface FailEnvelope { ok: false; error: { code: string; message: string; details?: unknown } }
+
+export function ok<T>(data: T, init?: ResponseInit): Response {
+  return Response.json({ ok: true, data } satisfies OkEnvelope<T>, init)
+}
+
+export function fail(err: unknown): Response {
+  if (VulseError.isVulseError(err)) {
+    return Response.json({
+      ok: false,
+      error: { code: err.code, message: err.message, ...(err.details ? { details: err.details } : {}) },
+    } satisfies FailEnvelope, { status: err.status })
+  }
+  console.error('[vulse] internal error:', err)
+  return Response.json({
+    ok: false, error: { code: 'INTERNAL', message: 'Internal server error' },
+  } satisfies FailEnvelope, { status: 500 })
+}

package/src/server/forms/email.ts

@@ -0,0 +1,11 @@
+import { sendEmail, type EmailEnv } from '../email.js'
+
+export type FormEmailEnv = EmailEnv
+
+export async function sendFormEmail(
+  env: FormEmailEnv,
+  input: { to: string; subject: string; body: string },
+): Promise<void> {
+  const result = await sendEmail(env, input)
+  if (result === 'logged') throw new Error('email_not_configured')
+}

package/src/server/forms/process-submission.ts

@@ -0,0 +1,95 @@
+import { createDb } from '../../core/db.js'
+import { FormsRepo, SubmissionsRepo } from '../../core/repos/forms.js'
+import { renderTemplate } from './templates.js'
+import { sendFormEmail } from './email.js'
+import { sendFormWebhook } from './webhook.js'
+import type { FormProcessMessage } from './queue.js'
+import type { FormEmailEnv } from './email.js'
+import { runFormAfterProcessHooks, runFormBeforeProcessHooks } from '../plugins.js'
+
+export interface ProcessEnv extends FormEmailEnv {
+  DB: D1Database
+}
+
+export async function processSubmission(env: ProcessEnv, submissionId: string): Promise<void> {
+  const db = createDb(env.DB)
+  const forms = new FormsRepo(db)
+  const submissions = new SubmissionsRepo(db)
+  const submission = await submissions.findById(submissionId)
+  if (!submission) return
+
+  const formRow = await forms.findByHandle(submission.formHandle)
+  if (!formRow) {
+    await submissions.updateStatus(submissionId, 'failed', 'form_not_found')
+    return
+  }
+
+  const def = formRow.definition
+  const ctx = { form: def, submission, payload: submission.payload }
+
+  try {
+    await runFormBeforeProcessHooks(ctx, env as unknown as Record<string, unknown>)
+
+    const notifyEmails = def.settings.notifyEmails ?? []
+    for (const email of notifyEmails) {
+      const body = renderTemplate(
+        'New submission for {{form.label}}\n\n{{email}}',
+        ctx,
+      )
+      await sendFormEmail(env, { to: email, subject: `New ${def.label} submission`, body })
+    }
+
+    for (const action of def.actions) {
+      if (action.type === 'notify') {
+        for (const email of action.emails) {
+          const body = renderTemplate(action.template ?? 'New submission', ctx)
+          await sendFormEmail(env, { to: email, subject: `New ${def.label} submission`, body })
+        }
+      }
+      if (action.type === 'confirmation') {
+        const to = submission.payload[action.toField]
+        if (to && String(to).length > 0) {
+          await sendFormEmail(env, {
+            to: String(to),
+            subject: renderTemplate(action.subject, ctx),
+            body: renderTemplate(action.bodyTemplate, ctx),
+          })
+        }
+      }
+      if (action.type === 'webhook') {
+        await sendFormWebhook(action.url, { form: def, submission, payload: submission.payload }, action.headers ?? {})
+      }
+    }
+
+    const conf = def.settings.confirmationEmail
+    if (conf?.enabled && conf.toField) {
+      const to = submission.payload[conf.toField]
+      if (to && String(to).length > 0) {
+        await sendFormEmail(env, {
+          to: String(to),
+          subject: renderTemplate(conf.subject, ctx),
+          body: renderTemplate(conf.bodyTemplate, ctx),
+        })
+      }
+    }
+
+    await runFormAfterProcessHooks(ctx, env as unknown as Record<string, unknown>)
+
+    await submissions.updateStatus(submissionId, 'processed')
+  } catch (err) {
+    const message = err instanceof Error ? err.message : 'process_failed'
+    await submissions.updateStatus(submissionId, 'failed', message)
+  }
+}
+
+export async function vulseFormQueue(
+  batch: MessageBatch<FormProcessMessage>,
+  env: ProcessEnv,
+): Promise<void> {
+  for (const msg of batch.messages) {
+    if (msg.body.type === 'process_submission') {
+      await processSubmission(env, msg.body.submissionId)
+    }
+    msg.ack()
+  }
+}

package/src/server/forms/queue.ts

@@ -0,0 +1,25 @@
+export interface FormProcessMessage {
+  type: 'process_submission'
+  submissionId: string
+}
+
+const pending = new Set<string>()
+
+export async function enqueueFormProcess(queue: Queue | undefined, submissionId: string): Promise<void> {
+  const msg: FormProcessMessage = { type: 'process_submission', submissionId }
+  if (queue) {
+    await queue.send(msg)
+    return
+  }
+  pending.add(submissionId)
+}
+
+export function drainPendingProcess(): string[] {
+  const ids = [...pending]
+  pending.clear()
+  return ids
+}
+
+export function __testResetPending(): void {
+  pending.clear()
+}