create-windy 0.5.1 → 0.6.0

package/template/apps/server/src/ai-output-artifact/service-completion.ts

@@ -0,0 +1,60 @@
+import type { StorageRuntime } from "../storage/runtime.js";
+import type {
+  AiOutputArtifactRecord,
+  AiOutputArtifactScope,
+} from "./contracts.js";
+import type { AiOutputArtifactRepository } from "./repository.js";
+import {
+  outputConflict,
+  outputNotReady,
+  outputStorageError,
+} from "./service-support.js";
+import type { AiOutputArtifactStorageWriterFactory } from "./storage-writer.js";
+import { purgeCompletedOutputUpload } from "./storage-recovery.js";
+
+export async function completeOutputArtifact(
+  options: {
+    readonly repository: AiOutputArtifactRepository;
+    readonly storage: StorageRuntime;
+    readonly writers: AiOutputArtifactStorageWriterFactory;
+    readonly now: () => Date;
+  },
+  scope: AiOutputArtifactScope,
+  artifact: AiOutputArtifactRecord,
+  signal: AbortSignal,
+) {
+  if (artifact.status === "completed") return artifact;
+  if (artifact.status !== "uploading" || !artifact.uploadSessionId) {
+    throw outputNotReady();
+  }
+  let file;
+  try {
+    file = await options.writers
+      .create(scope, signal)
+      .completeUpload(artifact.uploadSessionId);
+  } catch (error) {
+    throw outputStorageError(error);
+  }
+  const completed = await options.repository.completeArtifact(
+    artifact.artifactId,
+    artifact.generation,
+    file,
+    options.now().toISOString(),
+  );
+  if (completed) return completed;
+
+  const purged = await purgeCompletedOutputUpload(
+    options.storage,
+    scope,
+    artifact,
+    signal,
+  ).catch(() => false);
+  await options.repository.transitionArtifact(
+    artifact.artifactId,
+    artifact.generation,
+    ["uploading"],
+    purged ? "aborted" : "cleanup-pending",
+    options.now().toISOString(),
+  );
+  throw outputConflict();
+}

package/template/apps/server/src/ai-output-artifact/service-grants.test.ts

@@ -0,0 +1,169 @@
+import { describe, expect, test } from "bun:test";
+import { createOutputArtifactFixture } from "./test-support.js";
+
+describe("AI Output Artifact grant handoff", () => {
+  test("pre-ACK rollback 保留空 open scope，不可写且可用下一 credential 重试", async () => {
+    const fixture = createOutputArtifactFixture();
+    const first = await fixture.prepare("grant-pre-ack");
+    const scopeId = first.scope.scopeId;
+
+    expect(first).toMatchObject({
+      descriptor: { grantGeneration: 1 },
+      scope: {
+        revision: 1,
+        grantSequence: 1,
+        pendingGrantGeneration: 1,
+      },
+    });
+    expect(first.scope).not.toHaveProperty("grantHash");
+    await expect(
+      fixture.service.requireWritable(scopeId, first.grant!),
+    ).rejects.toMatchObject({ code: "OUTPUT_ARTIFACT_FORBIDDEN" });
+
+    expect(
+      await fixture.service.rollbackPendingGrant(
+        scopeId,
+        first.descriptor!.grantGeneration,
+        first.grant!,
+      ),
+    ).toBe("rolled-back");
+    const empty = await fixture.repository.getScope(scopeId);
+    expect(empty).toMatchObject({
+      status: "open",
+      revision: 2,
+      grantSequence: 1,
+    });
+    expect(empty).not.toHaveProperty("grantHash");
+    expect(empty?.pendingGrantHash).toBeUndefined();
+    await expect(
+      fixture.service.requireWritable(scopeId, first.grant!),
+    ).rejects.toMatchObject({ code: "OUTPUT_ARTIFACT_FORBIDDEN" });
+
+    const retry = await fixture.prepare("grant-pre-ack");
+    expect(retry.scope.revision).toBe(3);
+    expect(retry.descriptor?.grantGeneration).toBe(2);
+    await expect(
+      fixture.service.acceptGrant(scopeId, 1, first.grant!),
+    ).rejects.toMatchObject({ code: "OUTPUT_ARTIFACT_FORBIDDEN" });
+    const accepted = await fixture.service.acceptGrant(
+      scopeId,
+      retry.descriptor!.grantGeneration,
+      retry.grant!,
+    );
+    const duplicate = await fixture.service.acceptGrant(
+      scopeId,
+      retry.descriptor!.grantGeneration,
+      retry.grant!,
+    );
+    expect(accepted).toMatchObject({
+      activeGrantGeneration: 2,
+      grantSequence: 2,
+    });
+    expect(duplicate.revision).toBe(accepted.revision);
+    await expect(
+      fixture.service.requireWritable(scopeId, retry.grant!),
+    ).resolves.toMatchObject({ activeGrantGeneration: 2 });
+  });
+
+  test("空 open scope 无重试时按 scope TTL 清理", async () => {
+    const fixture = createOutputArtifactFixture();
+    const prepared = await fixture.prepare("grant-empty-cleanup");
+    await fixture.service.rollbackPendingGrant(
+      prepared.scope.scopeId,
+      prepared.descriptor!.grantGeneration,
+      prepared.grant!,
+    );
+    fixture.setNow(
+      new Date(Date.parse(prepared.scope.scopeExpiresAt) + 1).toISOString(),
+    );
+
+    expect(await fixture.cleanup.cleanupExpired()).toMatchObject({
+      inspected: 1,
+      cleaned: 1,
+      pending: 0,
+    });
+    expect(
+      await fixture.repository.getScope(prepared.scope.scopeId),
+    ).toMatchObject({ status: "cleaned" });
+    await expect(
+      fixture.service.requireWritable(prepared.scope.scopeId, prepared.grant!),
+    ).rejects.toMatchObject({ code: "OUTPUT_ARTIFACT_FORBIDDEN" });
+  });
+
+  test("并发 replay、pending lease、迟到与重复 ACK 均按 credential generation 隔离", async () => {
+    const fixture = createOutputArtifactFixture();
+    const attempts = await Promise.allSettled([
+      fixture.prepare("grant-concurrent"),
+      fixture.prepare("grant-concurrent"),
+    ]);
+    expect(
+      attempts.filter(({ status }) => status === "fulfilled"),
+    ).toHaveLength(1);
+    const first = attempts.find(
+      (
+        result,
+      ): result is PromiseFulfilledResult<
+        Awaited<ReturnType<typeof fixture.prepare>>
+      > => result.status === "fulfilled",
+    )!.value;
+    expect(first.descriptor?.grantGeneration).toBe(1);
+
+    fixture.setNow(
+      new Date(
+        Date.parse(first.scope.pendingGrantExpiresAt!) + 1,
+      ).toISOString(),
+    );
+    const replacement = await fixture.prepare("grant-concurrent");
+    expect(replacement.descriptor?.grantGeneration).toBe(2);
+    await expect(
+      fixture.service.acceptGrant(
+        first.scope.scopeId,
+        first.descriptor!.grantGeneration,
+        first.grant!,
+      ),
+    ).rejects.toMatchObject({ code: "OUTPUT_ARTIFACT_FORBIDDEN" });
+    const accepted = await fixture.service.acceptGrant(
+      first.scope.scopeId,
+      replacement.descriptor!.grantGeneration,
+      replacement.grant!,
+    );
+    const duplicate = await fixture.service.acceptGrant(
+      first.scope.scopeId,
+      replacement.descriptor!.grantGeneration,
+      replacement.grant!,
+    );
+    expect(accepted.activeGrantGeneration).toBe(2);
+    expect(duplicate.revision).toBe(accepted.revision);
+  });
+
+  test("seal 与 cancel 都清除 pending，迟到 ACK 不能复活 credential", async () => {
+    for (const terminal of ["seal", "cancel"] as const) {
+      const fixture = createOutputArtifactFixture();
+      const current = await fixture.begin(`grant-terminal-${terminal}`);
+      const pending = await fixture.prepare(`grant-terminal-${terminal}`);
+      expect(pending.descriptor?.grantGeneration).toBe(2);
+
+      if (terminal === "seal") {
+        await fixture.service.sealScope(current.scope.scopeId, current.grant!);
+      } else {
+        expect(
+          await fixture.cleanup.abortAuthorized(
+            fixture.service,
+            current.scope.scopeId,
+            current.grant!,
+          ),
+        ).toBe(true);
+      }
+      const closed = await fixture.repository.getScope(current.scope.scopeId);
+      expect(closed?.status).toBe(terminal === "seal" ? "sealed" : "aborted");
+      expect(closed?.pendingGrantHash).toBeUndefined();
+      await expect(
+        fixture.service.acceptGrant(
+          current.scope.scopeId,
+          pending.descriptor!.grantGeneration,
+          pending.grant!,
+        ),
+      ).rejects.toMatchObject({ code: "OUTPUT_ARTIFACT_FORBIDDEN" });
+    }
+  });
+});

package/template/apps/server/src/ai-output-artifact/service-grants.ts

@@ -0,0 +1,217 @@
+import type {
+  AiOutputArtifactReferenceV1,
+  AiOutputArtifactScope,
+  AiOutputArtifactSinkDescriptorV1,
+} from "./contracts.js";
+import {
+  createAiOutputArtifactGrant,
+  hashAiOutputArtifactGrant,
+  matchesAiOutputArtifactGrant,
+} from "./grant.js";
+import type { AiOutputArtifactRepository } from "./repository.js";
+import {
+  newAiOutputScope,
+  type BeginAiOutputArtifactScopeInput,
+} from "./service-input.js";
+import {
+  outputArtifactReference,
+  outputConflict,
+  outputForbidden,
+  outputSinkDescriptor,
+} from "./service-support.js";
+import type { AiOutputArtifactReferenceCodec } from "./reference-codec.js";
+
+const pendingGrantLeaseMs = 15_000;
+
+interface GrantDependencies {
+  readonly repository: AiOutputArtifactRepository;
+  readonly references: AiOutputArtifactReferenceCodec;
+  readonly now: () => Date;
+}
+
+export interface PreparedOutputScope {
+  readonly scope: AiOutputArtifactScope;
+  readonly descriptor?: AiOutputArtifactSinkDescriptorV1;
+  readonly grant?: string;
+  readonly references?: readonly AiOutputArtifactReferenceV1[];
+  readonly created: boolean;
+  readonly replayed: boolean;
+}
+
+export async function prepareOutputScope(
+  dependencies: GrantDependencies,
+  input: BeginAiOutputArtifactScopeInput,
+): Promise<PreparedOutputScope> {
+  const now = dependencies.now();
+  const grant = createAiOutputArtifactGrant();
+  const pendingExpiresAt = pendingLeaseExpiry(now, input.policy.scopeTtlMs);
+  const candidate = newAiOutputScope(input, grant.hash, pendingExpiresAt, now);
+  const result = await dependencies.repository.createOrGetScope(candidate);
+  if (result.scope.fingerprint !== candidate.fingerprint) {
+    throw outputConflict();
+  }
+  if (result.created) {
+    return prepared(result.scope, grant.token, true, false);
+  }
+  if (result.scope.status === "sealed") {
+    return sealedReplay(dependencies, result.scope);
+  }
+  const nowIso = now.toISOString();
+  if (
+    result.scope.status !== "open" ||
+    result.scope.scopeExpiresAt <= nowIso ||
+    (result.scope.pendingGrantExpiresAt &&
+      result.scope.pendingGrantExpiresAt > nowIso)
+  ) {
+    throw outputConflict();
+  }
+  const nextPendingExpiry = new Date(
+    Math.min(
+      now.getTime() + pendingGrantLeaseMs,
+      Date.parse(result.scope.scopeExpiresAt),
+    ),
+  ).toISOString();
+  const preparedScope = await dependencies.repository.prepareGrant(
+    result.scope.scopeId,
+    result.scope.revision,
+    grant.hash,
+    nextPendingExpiry,
+    nowIso,
+  );
+  if (!preparedScope) throw outputConflict();
+  return prepared(preparedScope, grant.token, false, true);
+}
+
+export async function acceptOutputGrant(
+  dependencies: GrantDependencies,
+  scopeId: string,
+  generation: number,
+  token: string,
+): Promise<AiOutputArtifactScope> {
+  const current = await dependencies.repository.getScope(scopeId);
+  if (isActiveGrant(current, generation, token)) return current!;
+  const now = dependencies.now().toISOString();
+  if (
+    !current ||
+    current.status !== "open" ||
+    current.pendingGrantGeneration !== generation ||
+    !current.pendingGrantHash ||
+    !matchesAiOutputArtifactGrant(token, current.pendingGrantHash) ||
+    !current.pendingGrantExpiresAt ||
+    current.pendingGrantExpiresAt <= now
+  ) {
+    throw outputForbidden();
+  }
+  const promoted = await dependencies.repository.promoteGrant(
+    scopeId,
+    current.revision,
+    generation,
+    hashAiOutputArtifactGrant(token),
+    now,
+  );
+  if (promoted) return promoted;
+  const raced = await dependencies.repository.getScope(scopeId);
+  if (isActiveGrant(raced, generation, token)) return raced!;
+  throw outputConflict();
+}
+
+export async function confirmOutputGrant(
+  dependencies: GrantDependencies,
+  scopeId: string,
+  generation: number,
+  token: string,
+): Promise<boolean> {
+  return isActiveGrant(
+    await dependencies.repository.getScope(scopeId),
+    generation,
+    token,
+  );
+}
+
+export async function rollbackPendingOutputGrant(
+  dependencies: GrantDependencies,
+  scopeId: string,
+  generation: number,
+  token: string,
+): Promise<"rolled-back" | "promoted" | "superseded"> {
+  const current = await dependencies.repository.getScope(scopeId);
+  if (isActiveGrant(current, generation, token)) return "promoted";
+  if (
+    current?.status === "open" &&
+    current.pendingGrantGeneration === generation &&
+    current.pendingGrantHash &&
+    matchesAiOutputArtifactGrant(token, current.pendingGrantHash)
+  ) {
+    const rolledBack = await dependencies.repository.rollbackGrant(
+      scopeId,
+      current.revision,
+      generation,
+      hashAiOutputArtifactGrant(token),
+      dependencies.now().toISOString(),
+    );
+    if (rolledBack) return "rolled-back";
+  }
+  const raced = await dependencies.repository.getScope(scopeId);
+  return isActiveGrant(raced, generation, token) ? "promoted" : "superseded";
+}
+
+function prepared(
+  scope: AiOutputArtifactScope,
+  grant: string,
+  created: boolean,
+  replayed: boolean,
+): PreparedOutputScope {
+  return {
+    scope,
+    descriptor: outputSinkDescriptor(scope),
+    grant,
+    created,
+    replayed,
+  };
+}
+
+async function sealedReplay(
+  dependencies: GrantDependencies,
+  scope: AiOutputArtifactScope,
+): Promise<PreparedOutputScope> {
+  if (
+    !scope.grantHash ||
+    !scope.activeGrantGeneration ||
+    scope.refExpiresAt <= dependencies.now().toISOString()
+  ) {
+    throw outputConflict();
+  }
+  const artifacts = await dependencies.repository.listArtifacts(scope.scopeId);
+  if (artifacts.some(({ status }) => status !== "completed")) {
+    throw outputConflict();
+  }
+  return {
+    scope,
+    descriptor: outputSinkDescriptor(scope),
+    references: artifacts.map((artifact) =>
+      outputArtifactReference(scope, artifact, dependencies.references),
+    ),
+    created: false,
+    replayed: true,
+  };
+}
+
+function isActiveGrant(
+  scope: AiOutputArtifactScope | undefined,
+  generation: number,
+  token: string,
+): boolean {
+  return Boolean(
+    scope &&
+    scope.status !== "cleaned" &&
+    scope.activeGrantGeneration === generation &&
+    scope.grantHash &&
+    matchesAiOutputArtifactGrant(token, scope.grantHash),
+  );
+}
+
+function pendingLeaseExpiry(now: Date, scopeTtlMs: number): string {
+  return new Date(
+    Math.min(now.getTime() + pendingGrantLeaseMs, now.getTime() + scopeTtlMs),
+  ).toISOString();
+}

package/template/apps/server/src/ai-output-artifact/service-input.ts

@@ -0,0 +1,175 @@
+import { createHash, randomBytes } from "node:crypto";
+import { parseAiRuntimeDeploymentIdentityV1 } from "@southwind-ai/server-sdk";
+import { captureAuthorizationScope } from "../data-access/scope-snapshot.js";
+import { isServerScopeContext } from "../data-access/context.js";
+import type { RequestGuardContext } from "../guards.js";
+import type { AiOutputArtifactPolicy } from "./policy.js";
+import type {
+  AiOutputArtifactScope,
+  AiOutputRuntimeKind,
+} from "./contracts.js";
+import type { NewAiOutputScope } from "./repository.js";
+
+export interface BeginAiOutputArtifactScopeInput {
+  readonly runId: string;
+  readonly moduleName: string;
+  readonly operationKey: string;
+  readonly runtimeKind: AiOutputRuntimeKind;
+  readonly idempotencyKey: string;
+  readonly invocationDigest: string;
+  readonly dataClassification: AiOutputArtifactScope["dataClassification"];
+  readonly deploymentIdentity: string;
+  readonly releaseDigest: string;
+  readonly offersDigest: string;
+  readonly policy: AiOutputArtifactPolicy;
+  readonly context: RequestGuardContext;
+}
+
+export function newAiOutputScope(
+  input: BeginAiOutputArtifactScopeInput,
+  pendingGrantHash: string,
+  pendingGrantExpiresAt: string,
+  now: Date,
+): NewAiOutputScope {
+  const scopeContext = input.context.actor.scopeContext;
+  if (
+    !/^[A-Za-z0-9][A-Za-z0-9._:-]{0,79}$/.test(input.runId) ||
+    !/^[A-Za-z0-9][A-Za-z0-9._:-]{0,159}$/.test(input.idempotencyKey) ||
+    !/^[a-f0-9]{64}$/.test(input.invocationDigest) ||
+    !/^[A-Za-z0-9._-]{1,128}$/.test(input.context.requestId) ||
+    !isServerScopeContext(scopeContext) ||
+    scopeContext.actorId !== input.context.actor.id ||
+    parseAiRuntimeDeploymentIdentityV1(input.deploymentIdentity) === null ||
+    !digest(input.releaseDigest) ||
+    !digest(input.offersDigest)
+  ) {
+    throw new Error("AI Output Scope 治理上下文无效");
+  }
+  if (
+    input.policy.runtimeKind !== input.runtimeKind ||
+    input.policy.dataClassification !== input.dataClassification
+  ) {
+    throw new Error("AI Output Scope 策略不匹配");
+  }
+  const scope = captureAuthorizationScope(scopeContext);
+  const identity = outputScopeIdentity(input);
+  const idempotencyHash = identity.idempotencyHash;
+  const fingerprint = identity.fingerprint;
+  const createdAt = now.toISOString();
+  return {
+    scopeId: opaque("outscope"),
+    runId: input.runId,
+    requestId: input.context.requestId,
+    actorId: input.context.actor.id,
+    tenantId: scopeContext.tenantId,
+    moduleName: input.moduleName,
+    operationKey: input.operationKey,
+    runtimeKind: input.runtimeKind,
+    outputKind: input.policy.outputKind,
+    purpose: input.policy.purpose,
+    dataClassification: input.dataClassification,
+    idempotencyHash,
+    fingerprint,
+    scopeHash: scope.hash,
+    scopeSnapshot: scope.snapshot,
+    deploymentIdentity: input.deploymentIdentity,
+    releaseDigest: input.releaseDigest,
+    offersDigest: input.offersDigest,
+    policyDigest: input.policy.digest,
+    revision: 1,
+    grantSequence: 1,
+    pendingGrantHash,
+    pendingGrantGeneration: 1,
+    pendingGrantExpiresAt,
+    status: "open",
+    allowedMediaTypes: [...input.policy.allowedMediaTypes],
+    maxArtifactBytes: input.policy.maxArtifactBytes,
+    maxArtifacts: input.policy.maxArtifacts,
+    maxTotalBytes: input.policy.maxTotalBytes,
+    scopeExpiresAt: plus(now, input.policy.scopeTtlMs),
+    fileExpiresAt: plus(
+      now,
+      input.policy.scopeTtlMs + input.policy.fileRetentionMs,
+    ),
+    refExpiresAt: plus(
+      now,
+      input.policy.scopeTtlMs + input.policy.referenceTtlMs,
+    ),
+    createdAt,
+    updatedAt: createdAt,
+  };
+}
+
+export function outputScopeIdentity(input: BeginAiOutputArtifactScopeInput) {
+  const scopeContext = input.context.actor.scopeContext;
+  if (!isServerScopeContext(scopeContext)) {
+    throw new Error("AI Output Scope 缺少授权范围");
+  }
+  const scope = captureAuthorizationScope(scopeContext);
+  const idempotencyHash = sha256(
+    [
+      input.context.actor.id,
+      input.moduleName,
+      input.operationKey,
+      input.runId,
+      input.policy.outputKind,
+      input.idempotencyKey,
+    ].join("\u0000"),
+  );
+  return {
+    idempotencyHash,
+    fingerprint: sha256(
+      canonical({
+        actorId: input.context.actor.id,
+        tenantId: scopeContext.tenantId,
+        moduleName: input.moduleName,
+        operationKey: input.operationKey,
+        runId: input.runId,
+        idempotencyHash,
+        invocationDigest: input.invocationDigest,
+        runtimeKind: input.runtimeKind,
+        outputKind: input.policy.outputKind,
+        dataClassification: input.dataClassification,
+        scopeHash: scope.hash,
+        deploymentIdentity: input.deploymentIdentity,
+        releaseDigest: input.releaseDigest,
+        offersDigest: input.offersDigest,
+        policyDigest: input.policy.digest,
+        maxArtifactBytes: input.policy.maxArtifactBytes,
+        maxArtifacts: input.policy.maxArtifacts,
+        maxTotalBytes: input.policy.maxTotalBytes,
+      }),
+    ),
+  };
+}
+
+export function outputArtifactFingerprint(input: {
+  outputKey: string;
+  outputKind: string;
+  filename: string;
+  mediaType: string;
+  byteSize: number;
+  sha256: string;
+}) {
+  return sha256(canonical(input));
+}
+
+export function opaque(prefix: string) {
+  return `${prefix}_${randomBytes(16).toString("hex")}`;
+}
+
+function plus(now: Date, milliseconds: number) {
+  return new Date(now.getTime() + milliseconds).toISOString();
+}
+
+function digest(value: string) {
+  return /^sha256:[0-9a-f]{64}$/.test(value);
+}
+
+function sha256(value: string) {
+  return createHash("sha256").update(value).digest("hex");
+}
+
+function canonical(value: object) {
+  return JSON.stringify(value, Object.keys(value).sort());
+}

package/template/apps/server/src/ai-output-artifact/service-read.ts

@@ -0,0 +1,89 @@
+import type { StorageRuntime } from "../storage/runtime.js";
+import type {
+  AiOutputArtifactRecord,
+  AiOutputArtifactScope,
+} from "./contracts.js";
+import type { AiOutputArtifactReferenceCodec } from "./reference-codec.js";
+import type { AiOutputArtifactRepository } from "./repository.js";
+import { outputForbidden, validOutputReference } from "./service-support.js";
+
+export interface AiOutputArtifactReadAuthorization {
+  readonly actorId?: string;
+  readonly scopeHash?: string;
+  readonly requestId: string;
+}
+
+export interface AiOutputArtifactReadDependencies {
+  readonly repository: AiOutputArtifactRepository;
+  readonly storage: StorageRuntime;
+  readonly references: AiOutputArtifactReferenceCodec;
+  readonly authorizeRead: (
+    scope: AiOutputArtifactScope,
+    signal: AbortSignal,
+  ) => Promise<AiOutputArtifactReadAuthorization | undefined>;
+  readonly recordRead: (
+    scope: AiOutputArtifactScope,
+    artifact: AiOutputArtifactRecord,
+    outcome: "success" | "denied",
+    requestId: string,
+  ) => void;
+}
+
+export async function openOutputArtifactReference(
+  options: AiOutputArtifactReadDependencies,
+  token: string,
+  now: string,
+  signal: AbortSignal,
+) {
+  let claims;
+  try {
+    claims = options.references.decode(token);
+  } catch {
+    throw outputForbidden();
+  }
+  const [scope, artifact] = await Promise.all([
+    options.repository.getScope(claims.scopeId),
+    options.repository.getArtifact(claims.artifactId),
+  ]);
+  if (
+    !scope ||
+    !artifact ||
+    !validOutputReference(scope, artifact, claims, now)
+  ) {
+    throw outputForbidden();
+  }
+  const authorization = await options.authorizeRead(scope, signal);
+  if (
+    !authorization ||
+    authorization.actorId !== scope.actorId ||
+    authorization.scopeHash !== scope.scopeHash
+  ) {
+    options.recordRead(
+      scope,
+      artifact,
+      "denied",
+      authorization?.requestId ?? scope.requestId,
+    );
+    throw outputForbidden();
+  }
+  try {
+    const opened = await options.storage.files.open(
+      claims.fileId,
+      authorization.actorId,
+    );
+    if (
+      opened.purpose !== scope.purpose ||
+      opened.mimeType !== claims.mediaType ||
+      opened.byteSize !== claims.byteSize ||
+      opened.contentHash.value !== claims.sha256
+    ) {
+      await opened.body.cancel().catch(() => undefined);
+      throw outputForbidden();
+    }
+    options.recordRead(scope, artifact, "success", authorization.requestId);
+    return opened;
+  } catch {
+    options.recordRead(scope, artifact, "denied", authorization.requestId);
+    throw outputForbidden();
+  }
+}