create-windy 0.3.4 → 0.3.6

package/template/apps/server/src/jobs/artifact-service.test.ts

@@ -1,13 +1,13 @@
 import { describe, expect, test } from "bun:test";
 import { MemoryBlobStore } from "@southwind-ai/storage";
 import { DurableArtifactService } from "./artifact-service.js";
-import { InMemoryDurableJobRepository } from "./repository.js";
+import { InMemoryDurableExecutionRepository } from "./in-memory-execution.js";
 import { DurableJobService } from "./service.js";
 
 describe("DurableArtifactService", () => {
   test("只有 Owner 或 manage 权限可读取且过期后统一拒绝", async () => {
     let now = new Date("2026-07-16T00:00:00.000Z");
-    const repository = new InMemoryDurableJobRepository();
+    const repository = new InMemoryDurableExecutionRepository();
     const jobs = new DurableJobService(repository, () => now);
     const submitted = await jobs.submit({
       handlerKey: "test.artifact",
@@ -70,6 +70,18 @@ describe("DurableArtifactService", () => {
     ).rejects.toMatchObject({
       code: "ARTIFACT_EXPIRED",
     });
+
+    now = new Date("2026-07-16T12:00:00.000Z");
+    await repository.requestCancel({
+      jobId: submitted.job.id,
+      expectedStatus: "queued",
+      now,
+    });
+    await expect(
+      service.open(submitted.job.id, "result", "owner-1"),
+    ).rejects.toMatchObject({
+      code: "ARTIFACT_JOB_CANCELLED",
+    });
   });
 });
 

package/template/apps/server/src/jobs/artifact-service.ts

@@ -5,6 +5,7 @@ import type { DurableJobRepository } from "./repository.js";
 export type DurableArtifactErrorCode =
   | "ARTIFACT_NOT_FOUND"
   | "ARTIFACT_FORBIDDEN"
+  | "ARTIFACT_JOB_CANCELLED"
   | "ARTIFACT_EXPIRED"
   | "ARTIFACT_CONTENT_MISSING";
 
@@ -54,6 +55,15 @@ export class DurableArtifactService {
     if (artifact.ownerId !== actorId && !allowManage) {
       throw new DurableArtifactError("ARTIFACT_FORBIDDEN", "无权访问任务产物");
     }
+    if (
+      snapshot?.job.status === "cancelled" ||
+      snapshot?.job.cancelRequestedAt
+    ) {
+      throw new DurableArtifactError(
+        "ARTIFACT_JOB_CANCELLED",
+        "已取消任务的产物不可访问",
+      );
+    }
     if (artifact.expiresAt && artifact.expiresAt <= this.now().toISOString()) {
       throw new DurableArtifactError("ARTIFACT_EXPIRED", "任务产物已过期");
     }

package/template/apps/server/src/jobs/drizzle-execution-repository.ts

@@ -11,6 +11,8 @@ import { and, eq, max, notInArray } from "drizzle-orm";
 import type { NodePgDatabase } from "drizzle-orm/node-postgres";
 import type {
   ClaimDurableJob,
+  CancelDurableJob,
+  DurableJobControlResult,
   DurableExecutionRepository,
   FailDurableJob,
   LeaseResult,
@@ -220,24 +222,21 @@ export class DrizzleDurableExecutionRepository implements DurableExecutionReposi
     });
   }
 
-  async requestCancel(jobId: string, now: Date) {
-    return this.db.transaction(async (tx) => {
-      const [job] = await tx
-        .select()
-        .from(durableJobs)
-        .where(eq(durableJobs.id, jobId))
-        .for("update")
-        .limit(1);
-      if (!job || !["queued", "running"].includes(job.status)) return false;
-      if (job.status === "queued") await cancelRemaining(tx, job.id, now);
-      else {
-        await tx
-          .update(durableJobs)
-          .set({ cancelRequestedAt: now, updatedAt: now })
-          .where(eq(durableJobs.id, job.id));
-      }
-      return true;
-    });
+  requestCancel(
+    input: CancelDurableJob,
+  ): Promise<DurableJobControlResult>;
+  requestCancel(jobId: string, now: Date): Promise<boolean>;
+  async requestCancel(
+    input: CancelDurableJob | string,
+    now?: Date,
+  ) {
+    const legacy = typeof input === "string";
+    const result = await this.recovery.requestCancel(
+      legacy ? { jobId: input, now: now! } : input,
+    );
+    return legacy
+      ? ["changed", "unchanged"].includes(result.outcome)
+      : result;
   }
 
   sweepExpired(now: Date, retryDelayMs: number) {

package/template/apps/server/src/jobs/drizzle-execution.integration.test.ts

@@ -180,7 +180,20 @@ describePostgres("PostgreSQL durable execution", () => {
     const execution = new DrizzleDurableExecutionRepository(drizzle(pool));
     const claim = await execution.claim(claimInput("worker-a", base, 10_000));
     if (!claim) throw new Error("任务未领取");
-    expect(await execution.requestCancel(submitted.job.id, base)).toBe(true);
+    const running = await service.get(submitted.job.id);
+    if (!running) throw new Error("运行任务不存在");
+    const cancelInput = {
+      jobId: submitted.job.id,
+      expectedStatus: running.job.status,
+      expectedVersion: running.job.updatedAt,
+      now: base,
+    } as const;
+    expect(await execution.requestCancel(cancelInput)).toEqual({
+      outcome: "changed",
+    });
+    expect(await execution.requestCancel(cancelInput)).toEqual({
+      outcome: "unchanged",
+    });
     expect(await execution.heartbeat(claim, base, 10_000)).toMatchObject({
       ok: true,
       cancelRequested: true,
@@ -190,11 +203,16 @@ describePostgres("PostgreSQL durable execution", () => {
     ).toBe(1);
     expect((await service.get(submitted.job.id))?.job.status).toBe("cancelled");
 
+    const cancelled = await service.get(submitted.job.id);
+    if (!cancelled) throw new Error("取消任务不存在");
     const recovery = {
       jobId: submitted.job.id,
       requestedBy: "ops_user",
       reason: "确认下游依赖已经恢复",
       idempotencyKey: "pg-recovery-1",
+      expectedAttempt: 1,
+      expectedStatus: "cancelled" as const,
+      expectedVersion: cancelled.job.updatedAt,
       now: new Date(base.getTime() + 2_000),
     };
     const results = await Promise.all([

package/template/apps/server/src/jobs/drizzle-mappers.ts

@@ -90,10 +90,12 @@ export function mapProgress(
 export function mapArtifact(
   row: typeof durableJobArtifacts.$inferSelect,
 ): DurableJobArtifact {
+  const { metadata, ...artifact } = row;
   return {
-    ...row,
+    ...artifact,
     stageId: row.stageId ?? undefined,
     artifactRef: artifactRef(row.artifactRef),
+    ...(metadata ? { metadata } : {}),
     expiresAt: iso(row.expiresAt),
     createdAt: row.createdAt.toISOString(),
   };

package/template/apps/server/src/jobs/drizzle-recovery-repository.ts

@@ -6,14 +6,48 @@ import {
   durableJobStages,
   durableJobs,
 } from "@southwind-ai/database";
-import { and, eq, lte, notInArray, or } from "drizzle-orm";
+import { and, eq, lte, max, notInArray, or } from "drizzle-orm";
 import type { NodePgDatabase } from "drizzle-orm/node-postgres";
-import type { ManualJobRecovery } from "./execution-repository.js";
+import type {
+  CancelDurableJob,
+  ManualJobRecovery,
+} from "./execution-repository.js";
 import { mapRecovery } from "./drizzle-mappers.js";
 
 export class DrizzleDurableRecoveryRepository {
   constructor(private readonly db: NodePgDatabase) {}
 
+  async requestCancel(input: CancelDurableJob) {
+    return this.db.transaction(async (tx) => {
+      const [job] = await tx
+        .select()
+        .from(durableJobs)
+        .where(eq(durableJobs.id, input.jobId))
+        .for("update")
+        .limit(1);
+      if (!job) return { outcome: "not-found" } as const;
+      if (job.status === "cancelled" || job.cancelRequestedAt) {
+        return { outcome: "unchanged" } as const;
+      }
+      if (
+        !["queued", "running"].includes(job.status) ||
+        (input.expectedStatus && job.status !== input.expectedStatus) ||
+        (input.expectedVersion &&
+          job.updatedAt.toISOString() !== input.expectedVersion)
+      ) {
+        return { outcome: "conflict" } as const;
+      }
+      if (job.status === "queued") await cancelRemaining(tx, job.id, input.now);
+      else {
+        await tx
+          .update(durableJobs)
+          .set({ cancelRequestedAt: input.now, updatedAt: input.now })
+          .where(eq(durableJobs.id, job.id));
+      }
+      return { outcome: "changed" } as const;
+    });
+  }
+
   async sweepExpired(now: Date, retryDelayMs: number) {
     return this.db.transaction(async (tx) => {
       const rows = await tx
@@ -139,6 +173,19 @@ export class DrizzleDurableRecoveryRepository {
       if (!["failed", "cancelled"].includes(job.status)) {
         throw new Error("只有失败或已取消任务可以人工恢复");
       }
+      const [{ attempt = 0 } = { attempt: 0 }] = await tx
+        .select({ attempt: max(durableJobStages.currentAttempt) })
+        .from(durableJobStages)
+        .where(eq(durableJobStages.jobId, job.id));
+      if (
+        (input.expectedStatus && job.status !== input.expectedStatus) ||
+        (input.expectedVersion &&
+          job.updatedAt.toISOString() !== input.expectedVersion) ||
+        (input.expectedAttempt !== undefined &&
+          (attempt || 0) !== input.expectedAttempt)
+      ) {
+        throw new Error("任务状态已变化");
+      }
       const [activeLease] = await tx
         .select({ id: durableJobLeases.id })
         .from(durableJobLeases)

package/template/apps/server/src/jobs/execution-repository.ts

@@ -2,6 +2,7 @@ import type {
   ClaimedDurableJob,
   DurableJobArtifact,
   DurableJobRecovery,
+  DurableJobStatus,
   DurableLeaseIdentity,
 } from "@southwind-ai/jobs";
 
@@ -32,6 +33,9 @@ export interface ManualJobRecovery {
   requestedBy: string;
   reason: string;
   idempotencyKey: string;
+  expectedAttempt?: number;
+  expectedStatus?: DurableJobStatus;
+  expectedVersion?: string;
   now: Date;
 }
 
@@ -40,6 +44,17 @@ export interface ManualJobRecoveryResult {
   recovered: boolean;
 }
 
+export interface CancelDurableJob {
+  jobId: string;
+  expectedStatus?: DurableJobStatus;
+  expectedVersion?: string;
+  now: Date;
+}
+
+export type DurableJobControlResult =
+  | { outcome: "changed" | "unchanged" }
+  | { outcome: "not-found" | "conflict" };
+
 export interface DurableExecutionRepository {
   claim(input: ClaimDurableJob): Promise<ClaimedDurableJob | undefined>;
   heartbeat(
@@ -66,7 +81,9 @@ export interface DurableExecutionRepository {
     failure: FailDurableJob,
     now: Date,
   ): Promise<LeaseResult>;
+  /** @deprecated 兼容平台内部旧调用；模块 Port 必须使用 CAS 输入。 */
   requestCancel(jobId: string, now: Date): Promise<boolean>;
+  requestCancel(input: CancelDurableJob): Promise<DurableJobControlResult>;
   sweepExpired(now: Date, retryDelayMs: number): Promise<number>;
   recover(input: ManualJobRecovery): Promise<ManualJobRecoveryResult>;
 }

package/template/apps/server/src/jobs/in-memory-control.ts

@@ -0,0 +1,135 @@
+import type {
+  DurableJob,
+  DurableJobLease,
+  DurableJobRecovery,
+  DurableJobStage,
+} from "@southwind-ai/jobs";
+import type {
+  CancelDurableJob,
+  ManualJobRecovery,
+} from "./execution-repository.js";
+
+interface InMemoryControlFacts {
+  jobs: Map<string, DurableJob>;
+  stages: Map<string, DurableJobStage>;
+  leases: Map<string, DurableJobLease>;
+  recoveries: Map<string, DurableJobRecovery>;
+}
+
+export function requestInMemoryCancel(
+  facts: InMemoryControlFacts,
+  input: CancelDurableJob,
+) {
+  const job = facts.jobs.get(input.jobId);
+  if (!job) return { outcome: "not-found" } as const;
+  if (job.status === "cancelled" || job.cancelRequestedAt) {
+    return { outcome: "unchanged" } as const;
+  }
+  if (
+    ["succeeded", "failed"].includes(job.status) ||
+    (input.expectedStatus && job.status !== input.expectedStatus) ||
+    (input.expectedVersion && job.updatedAt !== input.expectedVersion)
+  ) {
+    return { outcome: "conflict" } as const;
+  }
+  if (job.status === "queued") cancelInMemoryJob(facts, job, input.now);
+  else {
+    job.cancelRequestedAt = input.now.toISOString();
+    job.updatedAt = input.now.toISOString();
+  }
+  return { outcome: "changed" } as const;
+}
+
+export function recoverInMemoryJob(
+  facts: InMemoryControlFacts,
+  input: ManualJobRecovery,
+) {
+  const existing = [...facts.recoveries.values()].find(
+    (item) =>
+      item.jobId === input.jobId &&
+      item.idempotencyKey === input.idempotencyKey,
+  );
+  if (existing)
+    return { recovery: structuredClone(existing), recovered: false };
+  const job = facts.jobs.get(input.jobId);
+  if (!job) throw new Error("任务不存在");
+  const stages = jobStages(facts, job.id);
+  const currentAttempt = Math.max(
+    0,
+    ...stages.map((stage) => stage.currentAttempt),
+  );
+  if (
+    (input.expectedStatus && job.status !== input.expectedStatus) ||
+    (input.expectedVersion && job.updatedAt !== input.expectedVersion) ||
+    (input.expectedAttempt !== undefined &&
+      currentAttempt !== input.expectedAttempt)
+  )
+    throw new Error("任务状态已变化");
+  if (!["failed", "cancelled"].includes(job.status))
+    throw new Error("只有失败或已取消任务可以人工恢复");
+  if (
+    [...facts.leases.values()].some(
+      (lease) => lease.jobId === job.id && lease.status === "active",
+    )
+  )
+    throw new Error("任务仍有活跃租约，不能人工恢复");
+  const recovery: DurableJobRecovery = {
+    id: Bun.randomUUIDv7(),
+    jobId: job.id,
+    fromStatus: job.status,
+    requestedBy: input.requestedBy,
+    reason: input.reason,
+    idempotencyKey: input.idempotencyKey,
+    createdAt: input.now.toISOString(),
+  };
+  facts.recoveries.set(recovery.id, recovery);
+  for (const stage of stages) {
+    if (stage.status !== "succeeded") {
+      Object.assign(stage, {
+        status: "pending",
+        startedAt: undefined,
+        finishedAt: undefined,
+        updatedAt: input.now.toISOString(),
+      });
+    }
+  }
+  Object.assign(job, {
+    status: "queued",
+    availableAt: input.now.toISOString(),
+    cancelRequestedAt: undefined,
+    finishedAt: undefined,
+    updatedAt: input.now.toISOString(),
+  });
+  return { recovery: structuredClone(recovery), recovered: true };
+}
+
+export function cancelInMemoryJob(
+  facts: Pick<InMemoryControlFacts, "stages">,
+  job: DurableJob,
+  now: Date,
+) {
+  for (const stage of jobStages(facts, job.id)) {
+    if (stage.status !== "succeeded") {
+      Object.assign(stage, {
+        status: "cancelled",
+        finishedAt: now.toISOString(),
+        updatedAt: now.toISOString(),
+      });
+    }
+  }
+  Object.assign(job, {
+    status: "cancelled",
+    cancelRequestedAt: job.cancelRequestedAt || now.toISOString(),
+    finishedAt: now.toISOString(),
+    updatedAt: now.toISOString(),
+  });
+}
+
+function jobStages(
+  facts: Pick<InMemoryControlFacts, "stages">,
+  jobId: string,
+) {
+  return [...facts.stages.values()]
+    .filter((stage) => stage.jobId === jobId)
+    .sort((left, right) => left.ordinal - right.ordinal);
+}

package/template/apps/server/src/jobs/in-memory-execution.ts

@@ -1,5 +1,7 @@
 import type {
+  CancelDurableJob,
   ClaimDurableJob,
+  DurableJobControlResult,
   DurableExecutionRepository,
   FailDurableJob,
   ManualJobRecovery,
@@ -17,6 +19,11 @@ import {
   publishInMemoryArtifact,
   validateInMemoryLease,
 } from "./in-memory-lease.js";
+import {
+  cancelInMemoryJob,
+  recoverInMemoryJob,
+  requestInMemoryCancel,
+} from "./in-memory-control.js";
 
 export class InMemoryDurableExecutionRepository
   extends InMemoryDurableJobRepository
@@ -160,17 +167,22 @@ export class InMemoryDurableExecutionRepository
     );
   }
 
-  async requestCancel(jobId: string, now: Date) {
-    const job = this.jobs.get(jobId);
-    if (!job || ["succeeded", "failed", "cancelled"].includes(job.status)) {
-      return false;
-    }
-    if (job.status === "queued") this.cancelJob(job, now);
-    else {
-      job.cancelRequestedAt = now.toISOString();
-      job.updatedAt = now.toISOString();
-    }
-    return true;
+  requestCancel(
+    input: CancelDurableJob,
+  ): Promise<DurableJobControlResult>;
+  requestCancel(jobId: string, now: Date): Promise<boolean>;
+  async requestCancel(
+    input: CancelDurableJob | string,
+    now?: Date,
+  ) {
+    const legacy = typeof input === "string";
+    const result = requestInMemoryCancel(
+      this.controlFacts(),
+      legacy ? { jobId: input, now: now! } : input,
+    );
+    return legacy
+      ? ["changed", "unchanged"].includes(result.outcome)
+      : result;
   }
 
   async sweepExpired(now: Date, retryDelayMs: number) {
@@ -200,45 +212,7 @@ export class InMemoryDurableExecutionRepository
   }
 
   async recover(input: ManualJobRecovery) {
-    const existing = [...this.recoveries.values()].find(
-      (item) =>
-        item.jobId === input.jobId &&
-        item.idempotencyKey === input.idempotencyKey,
-    );
-    if (existing)
-      return { recovery: structuredClone(existing), recovered: false };
-    const job = this.jobs.get(input.jobId);
-    if (!job || !["failed", "cancelled"].includes(job.status)) {
-      throw new Error("只有失败或已取消任务可以人工恢复");
-    }
-    const recovery = {
-      id: Bun.randomUUIDv7(),
-      jobId: job.id,
-      fromStatus: job.status,
-      requestedBy: input.requestedBy,
-      reason: input.reason,
-      idempotencyKey: input.idempotencyKey,
-      createdAt: input.now.toISOString(),
-    } as const;
-    this.recoveries.set(recovery.id, recovery);
-    for (const stage of this.jobStages(job.id)) {
-      if (stage.status !== "succeeded") {
-        Object.assign(stage, {
-          status: "pending",
-          startedAt: undefined,
-          finishedAt: undefined,
-          updatedAt: input.now.toISOString(),
-        });
-      }
-    }
-    Object.assign(job, {
-      status: "queued",
-      availableAt: input.now.toISOString(),
-      cancelRequestedAt: undefined,
-      finishedAt: undefined,
-      updatedAt: input.now.toISOString(),
-    });
-    return { recovery: structuredClone(recovery), recovered: true };
+    return recoverInMemoryJob(this.controlFacts(), input);
   }
 
   private settleFailure(
@@ -317,20 +291,15 @@ export class InMemoryDurableExecutionRepository
   }
 
   private cancelJob(job: DurableJob, now: Date) {
-    for (const stage of this.jobStages(job.id)) {
-      if (stage.status !== "succeeded") {
-        Object.assign(stage, {
-          status: "cancelled",
-          finishedAt: now.toISOString(),
-          updatedAt: now.toISOString(),
-        });
-      }
-    }
-    Object.assign(job, {
-      status: "cancelled",
-      cancelRequestedAt: job.cancelRequestedAt || now.toISOString(),
-      finishedAt: now.toISOString(),
-      updatedAt: now.toISOString(),
-    });
+    cancelInMemoryJob({ stages: this.stages }, job, now);
+  }
+
+  private controlFacts() {
+    return {
+      jobs: this.jobs,
+      stages: this.stages,
+      leases: this.leases,
+      recoveries: this.recoveries,
+    };
   }
 }

package/template/apps/server/src/jobs/worker.ts

@@ -1,4 +1,5 @@
 import type {
+  CancelDurableJob,
   DurableExecutionRepository,
   LeaseResult,
   ManualJobRecovery,
@@ -35,6 +36,7 @@ export class DurableJobWorker {
   private readonly retryDelayMs: number;
   private readonly now: () => Date;
   private readonly contextualize?: DurableWorkerOptions["contextualize"];
+  private readonly activeRuns = new Map<string, AbortController>();
 
   constructor(
     private readonly repository: DurableExecutionRepository,
@@ -72,8 +74,20 @@ export class DurableJobWorker {
     return this.execute(claim, handler);
   }
 
-  cancel(jobId: string) {
-    return this.repository.requestCancel(jobId, this.now());
+  async cancel(jobId: string) {
+    const result = await this.controlCancel({ jobId });
+    return ["changed", "unchanged"].includes(result.outcome);
+  }
+
+  async controlCancel(input: Omit<CancelDurableJob, "now">) {
+    const result = await this.repository.requestCancel({
+      ...input,
+      now: this.now(),
+    });
+    if (["changed", "unchanged"].includes(result.outcome)) {
+      this.activeRuns.get(input.jobId)?.abort("cancelled");
+    }
+    return result;
   }
 
   recover(input: Omit<ManualJobRecovery, "now">) {
@@ -91,6 +105,7 @@ export class DurableJobWorker {
     handler: RegisteredDurableHandler,
   ): Promise<DurableRunResult> {
     const abort = new AbortController();
+    this.activeRuns.set(claim.jobId, abort);
     const identity = identityOf(claim);
     let rejectControl: (error: Error) => void = () => undefined;
     const control = new Promise<never>((_, reject) => {
@@ -181,7 +196,13 @@ export class DurableJobWorker {
       if (error instanceof LeaseLostError) {
         return { status: "lease-lost", jobId: claim.jobId };
       }
-      const failure = classifyFailure(error, this.now(), this.retryDelayMs);
+      const failure = classifyFailure(
+        abort.signal.reason === "cancelled"
+          ? new JobCancelledError("任务已请求取消")
+          : error,
+        this.now(),
+        this.retryDelayMs,
+      );
       const result = await this.repository.fail(identity, failure, this.now());
       if (!result.ok) return { status: "lease-lost", jobId: claim.jobId };
       return {
@@ -189,6 +210,9 @@ export class DurableJobWorker {
         jobId: claim.jobId,
       };
     } finally {
+      if (this.activeRuns.get(claim.jobId) === abort) {
+        this.activeRuns.delete(claim.jobId);
+      }
       clearInterval(interval);
       clearTimeout(timeout);
     }

package/template/apps/server/src/module-host/governed-export-route-support.ts

@@ -22,6 +22,19 @@ export function exportTarget(
     fieldKeys: policy.fields.map(({ fieldKey }) => fieldKey),
     approvalRequired: registration.export?.approvalRequired,
     retentionSeconds: registration.export?.retentionSeconds,
+    ...(registration.export?.renderers
+      ? {
+          renderers: registration.export.renderers.map((renderer) => ({
+            formatKey: renderer.formatKey,
+            templateKey: renderer.templateKey,
+            templateVersion: renderer.templateVersion,
+            inputSchemaKey: renderer.inputSchemaKey,
+            contentType: renderer.contentType,
+            filenameExtension: renderer.filenameExtension,
+            ...renderer.limits,
+          })),
+        }
+      : {}),
   };
 }
 
@@ -29,16 +42,23 @@ export function parseCreate(
   body: unknown,
   registration: ModuleGovernedResourceRegistration,
 ) {
-  const value = strictObject(body, ["idempotencyKey", "reason", "query"]);
+  const value = strictObject(body, [
+    "idempotencyKey",
+    "reason",
+    "query",
+    "formatKey",
+  ]);
   try {
     const query = registration.export!.validateQuery(value.query ?? {});
     if (!isJsonValue(query) || JSON.stringify(query).length > 64_000) {
       throw new Error("invalid query");
     }
+    const formatKey = optionalString(value.formatKey);
     return {
       idempotencyKey: requiredString(value.idempotencyKey),
       reason: requiredString(value.reason),
       query,
+      ...(formatKey === undefined ? {} : { formatKey }),
     };
   } catch (error) {
     if (error instanceof GovernedExportServiceError) throw error;
@@ -115,6 +135,9 @@ export function project(request: GovernedExportRequest) {
     expiresAt: request.expiresAt,
     createdAt: request.createdAt,
     updatedAt: request.updatedAt,
+    formatKey: request.renderer.formatKey,
+    templateKey: request.renderer.templateKey,
+    templateVersion: request.renderer.templateVersion,
   };
 }
 
@@ -146,7 +169,3 @@ export function requirePolicy(
 export function stripApiPrefix(path: string) {
   return path.slice("/api".length);
 }
-
-export function filename(resourceType: string) {
-  return `governed-${resourceType.replaceAll(/[^a-zA-Z0-9_-]/g, "-")}.ndjson`;
-}