create-windy 0.3.4 → 0.3.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-windy",
-  "version": "0.3.4",
+  "version": "0.3.6",
   "description": "创建单组织、单租户、私有部署优先的 Windy 企业 Dashboard Starter",
   "type": "module",
   "bin": {

package/template/.windy-template.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 1,
-  "templateCommit": "57da45729531a977f6cf1018797d2e1f2afb4e41",
-  "generatorVersion": "0.3.4",
+  "templateCommit": "5be88a688b54b87cf58a753535efb875ee3058e4",
+  "generatorVersion": "0.3.6",
   "modules": [
     {
       "name": "system",

package/template/AGENTS.md

@@ -47,6 +47,10 @@
 - 定制 404、500、维护中或网络异常页时，只修改 project-owned 的
   `apps/web/src/app/error-pages.ts`，并把业务 SFC 放在 `apps/web/src/app/`；
   保留四个类型化注册项，不要为换视觉修改 Router、HTTP 核心或平台默认错误页。
+- 新增业务管理页面时，在业务 Module Manifest 注册 Feature、Permission、菜单和
+  Admin Route，再把 Vue 页面绑定到 project-owned 的
+  `apps/web/src/app/business-routes.ts`；不要修改 Router 或 AppSidebar。导航来自
+  服务端 Manifest 快照，接入见 `docs/development/business-web-routes.md`。
 - 业务 Agent Operation 开启 Provider 出网时，必须在 Manifest 同时声明最小
   `providerDataPolicy.inputFields` JSON Pointer allowlist 与
   `envelopeFields`；raw input 会在进入 `prepare` 前裁剪并执行 DLP。接入与升级

package/template/README.md

@@ -60,9 +60,9 @@ Skill 完成该能力”。Skill 只指导开发流程；Feature、Permission、
 运行时事实仍以 Module Manifest 与平台 Registry 为准。
 
 当前组合未包含 `system.agent`，MCP Server、Agent Tool Host 和相关文档已被
-物理裁剪。若项目尚可重新生成，请在创建时增加 `--module system.agent` 或使用
-`--all-modules`；部署后的通用 `module add` 尚未交付，不要手工复制 MCP Adapter
-或另建授权链。仓库 Skill 仍可用于普通业务模块开发。
+物理裁剪。创建时可增加 `--module system.agent` 或使用 `--all-modules`；已部署
+项目使用 `bun run windy module add system.agent`，不要手工复制 MCP Adapter 或
+另建授权链。仓库 Skill 仍可用于普通业务模块开发。
 
 
 
@@ -99,8 +99,8 @@ create-windy 在本机 `.env` 中随机生成的 `WINDY_BOOTSTRAP_ADMIN_PASSWORD
 | 法律许可 | `UNLICENSED` |
 
 平台当前注册的全部模块如下。H0 表示 profile 锁定核心；H2 表示创建时可以物理包含或
-排除，并已有生成、类型检查、测试和构建证据。H2 不代表项目部署后已经支持无损安装、
-升级或卸载；那需要 H3 的生命周期命令与数据处置证据。
+排除；H3 还具备部署期安装、更新、数据保留卸载和重装证据。通用生命周期命令会保守
+处理所有目录模块，但只有通过完整 H3 回归的模块才标记为 H3。
 
 | Module Key | 当前项目 | 热插拔可靠度 | 说明 |
 | ---------- | -------- | ------------ | ---- |
@@ -119,14 +119,17 @@ create-windy 在本机 `.env` 中随机生成的 `WINDY_BOOTSTRAP_ADMIN_PASSWORD
 | `system.bulk-data` | 未包含 | H2 | 批量导入导出与结果留存。 |
 | `system.search` | 未包含 | H2 | 权限感知搜索与 Provider 聚合。 |
 | `system.data-governance` | 未包含 | H2 | 敏感字段、明文访问和治理导出。 |
-| `work-order` | 未包含 | H2 | 可替换的业务模块接入示例。 |
+| `work-order` | 未包含 | H3 | 可替换的业务模块接入示例。 |
 
 项目自有业务模块以 `apps/server/src/installed-business-modules.ts` 装配的 Module Manifest
-为准；shared-scaffold README 不复制项目业务 Key，避免平台升级固化产品命名。
+为准；对应 Vue 页面在 project-owned 的
+`apps/web/src/app/business-routes.ts` 注册，侧栏继续从服务端 Manifest 快照生成。
+不要为增加业务页面修改 shared-scaffold Router 或 AppSidebar。shared-scaffold README
+不复制项目业务 Key，避免平台升级固化产品命名。
 
 精确生成来源和选择记录在 `.windy/generation.json`。当前版本已提供可回滚的
-`windy update`；通用 `module add/remove` 尚未交付，不要把 Feature Flag 关闭当成
-模块已经卸载。
+`windy update` 与 `windy module list/add/update/remove`。Feature Flag 关闭仍不
+等于模块卸载。
 
 ## 常用命令
 
@@ -142,6 +145,9 @@ bun run build
 bun run windy doctor
 bun run windy update --check
 bun run windy update --dry-run
+bun run windy module list
+bun run windy module add work-order --dry-run
+bun run windy module remove work-order --dry-run
 bun run windy reconcile --to <精确目标版本>
 bun run lint
 bun run format
@@ -178,8 +184,9 @@ create-windy 默认建立 `main` 分支并创建 `chore: initialize project` 首
 没有配置 Git 用户身份，文件会保留在暂存区；配置身份后手动提交即可。
 
 当前已交付的 Windy 更新器会根据 Project Lock 和文件所有权，从 npm 历史 artifact
-重建 Base 并执行三方合并；它不连接私有源仓库，也不会静默覆盖项目代码。部署期通用
-`module add/update/remove` 尚未交付。
+重建 Base 并执行三方合并；它不连接私有源仓库，也不会静默覆盖项目代码。模块
+生命周期命令复用同一计划、事务、验证与恢复边界；卸载默认保留数据库数据，并要求
+显式确认数据处置计划。
 
 ## License
 

package/template/apps/server/src/application-services.ts

@@ -199,6 +199,20 @@ export async function createApplicationServices(
         resolveCurrentSystemActor(input.systemRepositories, actorId),
       );
     });
+  const moduleGovernedExportRenderers = input.moduleHosts.governedResources.flatMap(
+    ({ moduleName, registration }) => {
+      const policy = input.moduleHosts
+        .manifestOf(moduleName)
+        .dataPolicies?.find(({ key }) => key === registration.policyKey);
+      if (!policy) {
+        throw new Error(`模块数据治理策略不存在：${registration.policyKey}`);
+      }
+      return (registration.export?.renderers ?? []).map((renderer) => ({
+        resourceType: policy.resourceType,
+        renderer,
+      }));
+    },
+  );
   const governedExports = new GovernedExportJobRuntime(
     governedExportRequests,
     services.durable.service,
@@ -224,6 +238,8 @@ export async function createApplicationServices(
       features: input.foundation.features,
       runtime: input.runtime,
     }),
+    undefined,
+    moduleGovernedExportRenderers,
   );
   const governedExportService = new GovernedExportService(
     governedExportRequests,

package/template/apps/server/src/data-governance/export/authorization-port.test.ts

@@ -9,7 +9,10 @@ import { createServerRuntime } from "../../runtime.js";
 import { createSystemRepositories } from "../../system/seed.js";
 import { SystemGovernedExportAuthorization } from "./authorization-port.js";
 import { captureGovernedExportScope } from "./scope-snapshot.js";
-import type { GovernedExportRequest } from "./types.js";
+import {
+  legacyGovernedExportRendererSnapshot,
+  type GovernedExportRequest,
+} from "./types.js";
 
 const actor: RequestActor = {
   id: "test-bootstrap",
@@ -109,6 +112,7 @@ function exportRequest(
     scopeSnapshot,
     scopeHash,
     querySnapshot: { includeDeleted: false },
+    renderer: legacyGovernedExportRendererSnapshot,
     status: "queued",
     approvalRequired: false,
     expiresAt: "2027-01-01T00:00:00.000Z",

package/template/apps/server/src/data-governance/export/drizzle-repository.integration.test.ts

@@ -4,6 +4,7 @@ import { drizzle } from "drizzle-orm/node-postgres";
 import { migrate } from "drizzle-orm/node-postgres/migrator";
 import { Pool } from "pg";
 import { DrizzleGovernedExportRepository } from "./drizzle-repository.js";
+import { legacyGovernedExportRendererSnapshot } from "./types.js";
 
 const databaseUrl = process.env.GOVERNED_EXPORT_TEST_DATABASE_URL;
 const describePostgres = databaseUrl ? describe : describe.skip;
@@ -49,6 +50,7 @@ describePostgres("PostgreSQL governed export repository", () => {
       },
       scopeHash: "a".repeat(64),
       querySnapshot: { includeDeleted: false },
+      renderer: legacyGovernedExportRendererSnapshot,
       approvalRequired: false,
       expiresAt: "2026-07-17T02:00:00.000Z",
     };

package/template/apps/server/src/data-governance/export/drizzle-repository.ts

@@ -86,6 +86,7 @@ function mapRequest(row: Row): GovernedExportRequest {
     fieldKeys: [...row.fieldKeys],
     scopeSnapshot: structuredClone(row.scopeSnapshot),
     querySnapshot: structuredClone(row.querySnapshot),
+    renderer: structuredClone(row.renderer),
     status: row.status as GovernedExportRequest["status"],
     approvalRequired: row.approvalRequired,
     approvalId: row.approvalId || undefined,

package/template/apps/server/src/data-governance/export/job-runtime.test.ts

@@ -15,6 +15,7 @@ import type { GovernedExportAuthorizationPort } from "./authorization-port.js";
 import { InMemoryGovernedExportRepository } from "./repository.js";
 import { captureGovernedExportScope } from "./scope-snapshot.js";
 import type { GovernedExportSource } from "./source.js";
+import { legacyGovernedExportRendererSnapshot } from "./types.js";
 
 const base = new Date("2026-07-16T03:00:00.000Z");
 const canary = "sensitive-canary-13800138000";
@@ -271,8 +272,8 @@ describe("governed export job runtime", () => {
       }),
     ]);
   });
-});
 
+});
 async function createFixture(
   auditWriter?: AuditEventWriter,
   blobStore: BlobStore = new MemoryBlobStore(),
@@ -320,6 +321,7 @@ async function createFixture(
       scopeSnapshot: scope.snapshot,
       scopeHash: scope.hash,
       querySnapshot: { includeDeleted: false },
+      renderer: legacyGovernedExportRendererSnapshot,
       approvalRequired: false,
       expiresAt: "2026-07-17T03:00:00.000Z",
     },

package/template/apps/server/src/data-governance/export/job-runtime.ts

@@ -8,8 +8,11 @@ import type { DurableJobService } from "../../jobs/service.js";
 import type { DurableJobWorker } from "../../jobs/worker.js";
 import type { GovernedExportRepository } from "./repository.js";
 import type { GovernedExportSource } from "./source.js";
-import { createWatermarkedNdjsonStream } from "./ndjson-stream.js";
 import type { GovernedExportRequest } from "./types.js";
+import {
+  createGovernedExportRenderSession,
+  type GovernedExportRendererBinding,
+} from "./renderer-runtime.js";
 import {
   allowGovernedExportExecution,
   type GovernedExportAuthorizationDecision,
@@ -33,6 +36,7 @@ export class GovernedExportJobRuntime {
     ) => Promise<boolean> = async (request) => !request.approvalRequired,
     private readonly authorization: GovernedExportAuthorizationPort = allowGovernedExportExecution,
     private readonly now: () => Date = () => new Date(),
+    private readonly renderers: readonly GovernedExportRendererBinding[] = [],
   ) {
     registry.register({
       key: handlerKey,
@@ -132,20 +136,17 @@ export class GovernedExportJobRuntime {
     } catch {
       throw safeFailure("EXPORT_AUDIT_UNAVAILABLE", true);
     }
-    let stored;
+    let stored: Awaited<ReturnType<BlobStore["put"]>> | undefined;
+    let session;
     try {
-      stored = await this.blobStore.put({
-        body: createWatermarkedNdjsonStream({
+      session = await createGovernedExportRenderSession(
+        {
           request,
           source,
           signal: context.signal,
-          watermark: {
-            actorId: request.requesterId,
-            generatedAt,
-            scopeHash: request.scopeHash,
-            jobId: context.jobId,
-            requestId: request.id,
-          },
+          jobId: context.jobId,
+          generatedAt,
+          heartbeat: context.heartbeat,
           beforePage: async () => {
             const authorization = await this.authorization.evaluate(request);
             if (!authorization.allowed) {
@@ -156,22 +157,43 @@ export class GovernedExportJobRuntime {
             await context.heartbeat();
             await context.progress({ completedUnits: completed });
           },
-        }),
+        },
+        this.renderers,
+      );
+      stored = await this.blobStore.put({
+        body: session.body,
       });
+      session.assertRecordsConsumed();
     } catch (error) {
+      if (stored) await this.blobStore.delete(stored.ref);
       if (error instanceof DurableHandlerError) throw error;
+      if (context.signal.aborted) throw error;
+      throw safeFailure("EXPORT_STREAM_FAILED", isRetryableRenderFailure(error));
+    } finally {
+      session?.dispose();
+    }
+    if (!stored || !session) {
       throw safeFailure("EXPORT_STREAM_FAILED", true);
     }
     try {
       await context.publishArtifact({
         kind: "governed-export",
         artifactRef: stored.ref,
-        filename: `${safeFilename(request.resourceType)}.ndjson`,
-        contentType: "application/x-ndjson",
+        filename: `${safeFilename(request.resourceType)}.${request.renderer.filenameExtension}`,
+        contentType: request.renderer.contentType,
         byteSize: stored.byteSize,
         sha256: stored.contentHash.value,
         ownerId: request.requesterId,
         expiresAt: request.expiresAt,
+        metadata: {
+          formatKey: request.renderer.formatKey,
+          templateKey: request.renderer.templateKey,
+          templateVersion: request.renderer.templateVersion,
+          inputSchemaKey: request.renderer.inputSchemaKey,
+          ...(session?.contentMetadata
+            ? { contentMetadata: session.contentMetadata }
+            : {}),
+        },
       });
     } catch (error) {
       await this.blobStore.delete(stored.ref);
@@ -220,6 +242,11 @@ function generationIntentEvent(
     metadata: {
       policyKey: request.policyKey,
       policyVersion: request.policyVersion,
+      formatKey: request.renderer.formatKey,
+      templateKey: request.renderer.templateKey,
+      templateVersion: request.renderer.templateVersion,
+      inputSchemaKey: request.renderer.inputSchemaKey,
+      contentType: request.renderer.contentType,
       scopeHash: request.scopeHash,
       jobId,
       phase: "intent",
@@ -228,6 +255,18 @@ function generationIntentEvent(
   };
 }
 
+function isRetryableRenderFailure(error: unknown) {
+  const code = error instanceof Error ? error.message : "";
+  return ![
+    "EXPORT_RENDERER_NOT_REGISTERED",
+    "EXPORT_RENDERER_VERSION_DRIFT",
+    "EXPORT_RECORD_LIMIT_EXCEEDED",
+    "EXPORT_OUTPUT_LIMIT_EXCEEDED",
+    "EXPORT_RECORDS_NOT_CONSUMED",
+    "EXPORT_CONTENT_METADATA_TOO_LARGE",
+  ].includes(code);
+}
+
 function authorizationDeniedEvent(
   request: GovernedExportRequest,
   decision: Extract<GovernedExportAuthorizationDecision, { allowed: false }>,

package/template/apps/server/src/data-governance/export/ndjson-stream.ts

@@ -14,6 +14,7 @@ export function createWatermarkedNdjsonStream(input: {
   source: GovernedExportSource;
   watermark: ExportWatermark;
   signal: AbortSignal;
+  maxRecords?: number;
   beforePage(): Promise<void>;
   pageCompleted(completed: number): Promise<void>;
 }) {
@@ -43,6 +44,7 @@ async function* lines(input: {
   source: GovernedExportSource;
   watermark: ExportWatermark;
   signal: AbortSignal;
+  maxRecords?: number;
   beforePage(): Promise<void>;
   pageCompleted(completed: number): Promise<void>;
 }) {
@@ -62,6 +64,12 @@ async function* lines(input: {
       if (result.done) return;
       if (input.signal.aborted) throw new Error("EXPORT_ABORTED");
       for (const record of result.value) {
+        if (
+          input.maxRecords !== undefined &&
+          completed >= input.maxRecords
+        ) {
+          throw new Error("EXPORT_RECORD_LIMIT_EXCEEDED");
+        }
         yield { type: "record", watermark: input.watermark, data: record };
         completed += 1;
       }

package/template/apps/server/src/data-governance/export/postgres-recovery.integration.test.ts

@@ -21,6 +21,7 @@ import {
   createPostgresApiFixture,
   ownerCanaries,
 } from "./postgres-api-fixture.js";
+import { legacyGovernedExportRendererSnapshot } from "./types.js";
 import { captureGovernedExportScope } from "./scope-snapshot.js";
 import type { GovernedExportSource } from "./source.js";
 
@@ -202,6 +203,7 @@ async function exerciseFailureRetry(
       scopeSnapshot: scope.snapshot,
       scopeHash: scope.hash,
       querySnapshot: { includeDeleted: false },
+      renderer: legacyGovernedExportRendererSnapshot,
       approvalRequired: false,
       expiresAt: new Date(
         fixture.clock.current.getTime() + 86_400_000,

package/template/apps/server/src/data-governance/export/renderer-job-runtime.test.ts

@@ -0,0 +1,235 @@
+import { describe, expect, test } from "bun:test";
+import { DurableHandlerRegistry } from "@southwind-ai/jobs";
+import type { ModuleGovernedExportRendererRegistration } from "@southwind-ai/server-sdk";
+import { MemoryBlobStore } from "@southwind-ai/storage";
+import { buildScopeContext } from "../../data-access/context.js";
+import { InMemoryDurableExecutionRepository } from "../../jobs/in-memory-execution.js";
+import { DurableJobService } from "../../jobs/service.js";
+import { DurableJobWorker } from "../../jobs/worker.js";
+import { createServerRuntime } from "../../runtime.js";
+import { GovernedExportJobRuntime } from "./job-runtime.js";
+import { InMemoryGovernedExportRepository } from "./repository.js";
+import { captureGovernedExportScope } from "./scope-snapshot.js";
+import type { GovernedExportSource } from "./source.js";
+import type { GovernedExportRendererSnapshot } from "./types.js";
+
+const now = new Date("2026-07-27T01:00:00.000Z");
+
+describe("governed export renderer runtime", () => {
+  test("Renderer 消费逐页记录与水印并发布受控格式、模板和内容元数据", async () => {
+    for (const [formatKey, contentType] of formats) {
+      const renderer = reportRenderer(formatKey, contentType, 1024);
+      const fixture = await setup(renderer, true);
+      const job = await fixture.runtime.submit(fixture.request);
+
+      expect(await fixture.runtime.runNext(`${formatKey}-worker`)).toMatchObject({
+        status: "succeeded",
+      });
+      const artifact = (await fixture.jobs.get(job.id))?.artifacts[0];
+      if (!artifact) throw new Error("Renderer artifact 未发布");
+      expect(artifact).toMatchObject({
+        filename: `governed-people-report.${formatKey}`,
+        contentType,
+        metadata: {
+          formatKey,
+          templateKey: `reports.official.${formatKey}`,
+          templateVersion: "2026.07",
+          inputSchemaKey: "reports.official.input.v1",
+          contentMetadata: { sourceCount: 2 },
+        },
+      });
+      const blob = await fixture.blobs.open(artifact.artifactRef);
+      if (!blob) throw new Error("Renderer Blob 不存在");
+      const content = await new Response(blob.body).text();
+      expect(content).toContain("source:evidence-1");
+      expect(content).toContain(fixture.request.scopeHash);
+      expect(content).toContain(job.id);
+      expect(fixture.authorizationChecks()).toBe(4);
+    }
+  });
+
+  test("未绑定 Renderer 与输出超限 fail closed 且不保留半成品", async () => {
+    const renderer = reportRenderer("pdf", "application/pdf", 4);
+    for (const registered of [false, true]) {
+      const fixture = await setup(renderer, registered);
+      const job = await fixture.runtime.submit(fixture.request);
+      expect(await fixture.runtime.runNext("failed-renderer-worker")).toMatchObject(
+        { status: "failed" },
+      );
+      expect(fixture.blobs.size).toBe(0);
+      expect((await fixture.jobs.get(job.id))?.artifacts).toEqual([]);
+    }
+  });
+
+  test("Durable Job 取消经 heartbeat 传播到 Renderer AbortSignal", async () => {
+    let enter: () => void = () => undefined;
+    let resume: () => void = () => undefined;
+    const entered = new Promise<void>((resolve) => {
+      enter = resolve;
+    });
+    const resumed = new Promise<void>((resolve) => {
+      resume = resolve;
+    });
+    let aborted = false;
+    const renderer: ModuleGovernedExportRendererRegistration = {
+      ...reportRenderer("pdf", "application/pdf", 1024),
+      async render(_input, context) {
+        enter();
+        await resumed;
+        try {
+          await context.heartbeat();
+        } catch (error) {
+          aborted = context.signal.aborted;
+          throw error;
+        }
+        throw new Error("取消未传播");
+      },
+    };
+    const fixture = await setup(renderer, true);
+    const job = await fixture.runtime.submit(fixture.request);
+    const running = fixture.runtime.runNext("cancel-renderer-worker");
+    await entered;
+    await fixture.runtime.cancel(job.id);
+    resume();
+
+    expect(await running).toMatchObject({ status: "cancelled" });
+    expect(aborted).toBe(true);
+    expect(fixture.blobs.size).toBe(0);
+    expect((await fixture.jobs.get(job.id))?.artifacts).toEqual([]);
+  });
+});
+
+async function setup(
+  renderer: ModuleGovernedExportRendererRegistration,
+  registered: boolean,
+) {
+  const requests = new InMemoryGovernedExportRepository();
+  const facts = new InMemoryDurableExecutionRepository();
+  const jobs = new DurableJobService(facts, () => now);
+  const registry = new DurableHandlerRegistry();
+  const worker = new DurableJobWorker(facts, registry, { now: () => now });
+  const blobs = new MemoryBlobStore();
+  const server = createServerRuntime();
+  let authorizationChecks = 0;
+  const source: GovernedExportSource = {
+    resourceType: "people.report",
+    async *pages() {
+      yield [{ id: "evidence-1", reference: "source-a" }];
+      yield [{ id: "evidence-2", reference: "source-b" }];
+    },
+  };
+  const scope = captureGovernedExportScope(
+    buildScopeContext("reviewer-1", "dept-1", [
+      {
+        id: "role-reviewer",
+        code: "reviewer",
+        dataScope: "department",
+        departmentIds: [],
+      },
+    ]),
+  );
+  const created = await requests.create(
+    {
+      id: Bun.randomUUIDv7(),
+      resourceType: "people.report",
+      policyKey: "people.report.fields",
+      policyVersion: "1",
+      fieldKeys: ["content"],
+      requesterId: "reviewer-1",
+      requesterName: "复核员",
+      idempotencyKey: Bun.randomUUIDv7(),
+      requestFingerprint: "a".repeat(64),
+      reason: "生成正式复核报告",
+      scopeSnapshot: scope.snapshot,
+      scopeHash: scope.hash,
+      querySnapshot: {},
+      renderer: snapshot(renderer),
+      approvalRequired: true,
+      approvalId: "approval-1",
+      expiresAt: "2026-07-28T01:00:00.000Z",
+    },
+    now,
+  );
+  return {
+    request: created.request,
+    runtime: new GovernedExportJobRuntime(
+      requests,
+      jobs,
+      worker,
+      registry,
+      blobs,
+      server.auditSink,
+      [source],
+      async () => true,
+      {
+        evaluate: async () => {
+          authorizationChecks += 1;
+          return { allowed: true };
+        },
+      },
+      () => now,
+      registered ? [{ resourceType: source.resourceType, renderer }] : [],
+    ),
+    jobs,
+    blobs,
+    authorizationChecks: () => authorizationChecks,
+  };
+}
+
+function reportRenderer(
+  formatKey: string,
+  contentType: string,
+  maxOutputBytes: number,
+): ModuleGovernedExportRendererRegistration {
+  return {
+    formatKey,
+    templateKey: `reports.official.${formatKey}`,
+    templateVersion: "2026.07",
+    inputSchemaKey: "reports.official.input.v1",
+    contentType,
+    filenameExtension: formatKey,
+    limits: { maxRecords: 10, maxOutputBytes, timeoutSeconds: 10 },
+    async render(input) {
+      const sources: string[] = [];
+      for await (const record of input.records) {
+        sources.push(`source:${String(record.id)}`);
+      }
+      return {
+        body: new Response(
+          [
+            `watermark:${input.watermark.scopeHash}:${input.watermark.jobId}`,
+            ...sources,
+          ].join("\n"),
+        ).body!,
+        contentMetadata: { sourceCount: sources.length },
+      };
+    },
+  };
+}
+
+const formats = [
+  ["ndjson", "application/x-ndjson"],
+  ["pdf", "application/pdf"],
+  [
+    "docx",
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  ],
+  [
+    "xlsx",
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  ],
+] as const;
+
+function snapshot(
+  renderer: ModuleGovernedExportRendererRegistration,
+): GovernedExportRendererSnapshot {
+  return {
+    formatKey: renderer.formatKey,
+    templateKey: renderer.templateKey,
+    templateVersion: renderer.templateVersion,
+    inputSchemaKey: renderer.inputSchemaKey,
+    contentType: renderer.contentType,
+    filenameExtension: renderer.filenameExtension,
+    ...renderer.limits,
+  };
+}