@hraness/slopcamera 3.2.4

package/apps/desktop/application/operations/iteration/create-candidate.ts

@@ -0,0 +1,240 @@
+import { z } from "zod";
+
+import {
+  canonicalJson,
+  canonicalJsonSha256,
+  hashProjectEditPlan,
+} from "../../../core";
+import {
+  CandidateProjectEditBatchV3Schema,
+  CandidateRevisionHostBindingsV1Schema,
+  createCreativeCandidateV1,
+  CreativeBaseV1Schema,
+  CreativeCandidateIdentityV1Schema,
+  CreativeCandidateReferenceV1Schema,
+  CreativeCandidateRenderV1Schema,
+  CreativeCandidateRevisionReferenceV1Schema,
+  CreativeCandidateV1Schema,
+  creativeBaseIdentityV1,
+  creativeCandidatePath,
+  creativeCandidateReferenceV1,
+  CreativeVariantKeySchema,
+} from "../../creative-iteration";
+import type { ApplicationContext } from "../../context";
+import { ApplicationError } from "../../errors";
+import type { OperationDefinition } from "../../operation";
+import { ProjectSnapshotOutputSchema } from "../project/snapshot";
+import { ProjectReferenceSchema, throwIfAborted } from "../shared";
+import {
+  bindCreateCandidateRevisionInput,
+} from "../edit/create-candidate-revision";
+import { deriveProjectEditPlanV3 } from "../project/commit-edits";
+import {
+  creativeProjectFileSystem,
+  loadCreativeDocument,
+  publishCreativeDocument,
+  verifyCandidateRender,
+} from "./shared";
+import { ProjectEditRevisionDocumentSchema } from "../../receipts";
+
+export const CreateCreativeCandidateRequestSchema = z.strictObject({
+  batch: CandidateProjectEditBatchV3Schema,
+  project: ProjectReferenceSchema,
+  renders: z.array(CreativeCandidateRenderV1Schema).max(16),
+  revision: CreativeCandidateRevisionReferenceV1Schema,
+  snapshot: ProjectSnapshotOutputSchema,
+  variantKey: CreativeVariantKeySchema,
+});
+
+export const CreateCreativeCandidateInputSchema = z.strictObject({
+  base: CreativeBaseV1Schema,
+  batch: CandidateProjectEditBatchV3Schema,
+  bindings: CandidateRevisionHostBindingsV1Schema,
+  candidate: CreativeCandidateIdentityV1Schema,
+  project: ProjectReferenceSchema,
+  renders: z.array(CreativeCandidateRenderV1Schema).max(16),
+  revision: CreativeCandidateRevisionReferenceV1Schema,
+  updatedAt: z.string().datetime({ offset: true }),
+}).superRefine((input, context) => {
+  if (
+    input.project !== input.base.projectId
+    || input.project !== input.revision.projectId
+  ) {
+    context.addIssue({
+      code: "custom",
+      message: "Creative candidate project, base, and revision disagree.",
+      path: ["project"],
+    });
+  }
+});
+
+export const CreateCreativeCandidateOutputSchema =
+  CreativeCandidateReferenceV1Schema;
+
+export type CreateCreativeCandidateRequest = z.infer<
+  typeof CreateCreativeCandidateRequestSchema
+>;
+export type CreateCreativeCandidateInput = z.infer<
+  typeof CreateCreativeCandidateInputSchema
+>;
+export type CreateCreativeCandidateOutput = z.infer<
+  typeof CreateCreativeCandidateOutputSchema
+>;
+
+export async function bindCreateCreativeCandidateInput(
+  application: ApplicationContext,
+  input: unknown,
+): Promise<CreateCreativeCandidateInput> {
+  const exact = CreateCreativeCandidateInputSchema.safeParse(input);
+  if (exact.success) return exact.data;
+  const request = CreateCreativeCandidateRequestSchema.parse(input);
+  if (request.project !== request.snapshot.project.projectId) {
+    throw new ApplicationError(
+      "conflict",
+      "Creative candidate project does not match its snapshot.",
+    );
+  }
+  const boundRevision = await bindCreateCandidateRevisionInput(application, {
+    batch: request.batch,
+    project: request.project,
+    snapshot: request.snapshot,
+    updatedAt: request.revision.updatedAt,
+    variantKey: request.variantKey,
+  });
+  if (
+    canonicalJson(boundRevision.candidate)
+      !== canonicalJson(request.revision.candidate)
+    || canonicalJson(creativeBaseIdentityV1(boundRevision.base))
+      !== canonicalJson(request.revision.base)
+    || boundRevision.batch.sha256 !== request.revision.batchSha256
+    || canonicalJsonSha256(boundRevision.bindings)
+      !== request.revision.bindingsSha256
+  ) {
+    throw new ApplicationError(
+      "conflict",
+      "Creative candidate request does not reproduce its exact candidate revision.",
+    );
+  }
+  return CreateCreativeCandidateInputSchema.parse({
+    base: boundRevision.base,
+    batch: boundRevision.batch,
+    bindings: boundRevision.bindings,
+    candidate: boundRevision.candidate,
+    project: request.project,
+    renders: request.renders,
+    revision: request.revision,
+    updatedAt: boundRevision.updatedAt,
+  });
+}
+
+export const createCreativeCandidateOperationDefinition = {
+  inputSchema: CreateCreativeCandidateInputSchema,
+  inputSchemaId: "slopcamera.operation.iteration.create-candidate.input/v1",
+  kind: "iteration.create-candidate",
+  lifecycle: {
+    kind: "local-artifact",
+    execute: async (context, input) => {
+      throwIfAborted(context.abortSignal);
+      const fileSystem = await creativeProjectFileSystem(
+        context.application,
+        input.project,
+      );
+      const revision = await loadCreativeDocument({
+        artifact: input.revision.artifact,
+        fileSystem,
+        label: "Creative candidate revision",
+        schema: ProjectEditRevisionDocumentSchema,
+      });
+      if (
+        revision.revisionSha256 !== input.revision.revisionSha256
+        || revision.projectEditPlanSha256
+          !== input.revision.projectEditPlanSha256
+        || revision.projectSha256 !== input.base.generation.projectSha256
+      ) {
+        throw new ApplicationError(
+          "conflict",
+          "Creative candidate revision does not match its frozen base and reference.",
+        );
+      }
+      const expectedPlan = await deriveProjectEditPlanV3({
+        abortSignal: context.abortSignal,
+        application: context.application,
+        batch: input.batch,
+        manualZoomBindings: input.bindings.manualZoomBindings,
+        ...(input.bindings.metadataBinding === null
+          ? {}
+          : { metadataBinding: input.bindings.metadataBinding }),
+        plan: input.base.currentPlan,
+        project: input.base.project,
+        updatedAt: input.updatedAt,
+      });
+      if (
+        hashProjectEditPlan(expectedPlan) !== revision.projectEditPlanSha256
+        || canonicalJson(expectedPlan) !== canonicalJson(revision.projectEditPlan)
+      ) {
+        throw new ApplicationError(
+          "conflict",
+          "Creative candidate revision was not derived by its declared V3 batch and bindings.",
+        );
+      }
+      const candidate = createCreativeCandidateV1({
+        base: input.base,
+        batch: input.batch,
+        bindings: input.bindings,
+        candidate: input.candidate,
+        renders: input.renders,
+        revision: input.revision,
+        updatedAt: input.updatedAt,
+      });
+      for (const render of candidate.renders) {
+        throwIfAborted(context.abortSignal);
+        await verifyCandidateRender({ candidate, fileSystem, render });
+      }
+      throwIfAborted(context.abortSignal);
+      await context.workflow?.beforePublication();
+      throwIfAborted(context.abortSignal);
+      const path = creativeCandidatePath({
+        baseSha256: candidate.base.baseSha256,
+        candidateId: candidate.candidate.candidateId,
+        candidateSha256: candidate.candidateSha256,
+      });
+      const artifact = await publishCreativeDocument({
+        document: candidate,
+        fileSystem,
+        path,
+        schema: CreativeCandidateV1Schema,
+      });
+      return creativeCandidateReferenceV1({ artifact, candidate });
+    },
+  },
+  outputSchema: CreateCreativeCandidateOutputSchema,
+  outputSchemaId: "slopcamera.operation.iteration.create-candidate.output/v1",
+  policy: {
+    cache: "content-addressed",
+    cancellable: true,
+    effect: "local-derived-write",
+    maxDurationMs: 30_000,
+    maxFanOut: 0,
+    maxInputBytes: 128 * 1024 * 1024,
+    maxOutputBytes: 16 * 1024,
+    preparation: ["project-state", "local-media"],
+    resources: [
+      { amount: 1, resource: "cpu" },
+      { amount: 1, resource: "local-io" },
+    ],
+    resume: "deterministic",
+  },
+  summarize: output => ({
+    fields: {
+      candidateId: output.candidate.candidateId,
+      candidateSha256: output.candidateSha256,
+      revisionSha256: output.revisionSha256,
+    },
+    kind: "iteration.create-candidate",
+  }),
+  version: 1,
+} satisfies OperationDefinition<
+  "iteration.create-candidate",
+  CreateCreativeCandidateInput,
+  CreateCreativeCandidateOutput
+>;

package/apps/desktop/application/operations/iteration/create-matrix.ts

@@ -0,0 +1,117 @@
+import { z } from "zod";
+
+import {
+  createVariantMatrixV1,
+  CreativeCandidateReferenceV1Schema,
+  variantMatrixPath,
+  variantMatrixReferenceV1,
+  VariantMatrixReferenceV1Schema,
+  VariantMatrixV1Schema,
+} from "../../creative-iteration";
+import { ApplicationError } from "../../errors";
+import type { OperationDefinition } from "../../operation";
+import { ProjectReferenceSchema, throwIfAborted } from "../shared";
+import {
+  creativeProjectFileSystem,
+  loadCreativeCandidate,
+  publishCreativeDocument,
+} from "./shared";
+
+export const CreateVariantMatrixInputSchema = z.strictObject({
+  candidates: z.array(CreativeCandidateReferenceV1Schema).min(1).max(16),
+  project: ProjectReferenceSchema,
+}).superRefine((input, context) => {
+  if (input.candidates.some(candidate => candidate.base.projectId !== input.project)) {
+    context.addIssue({
+      code: "custom",
+      message: "Variant matrix project must match every candidate base.",
+      path: ["project"],
+    });
+  }
+});
+
+export const CreateVariantMatrixOutputSchema = VariantMatrixReferenceV1Schema;
+
+export type CreateVariantMatrixInput = z.infer<
+  typeof CreateVariantMatrixInputSchema
+>;
+export type CreateVariantMatrixOutput = z.infer<
+  typeof CreateVariantMatrixOutputSchema
+>;
+
+export const createVariantMatrixOperationDefinition = {
+  inputSchema: CreateVariantMatrixInputSchema,
+  inputSchemaId: "slopcamera.operation.iteration.create-matrix.input/v1",
+  kind: "iteration.create-matrix",
+  lifecycle: {
+    kind: "local-artifact",
+    execute: async (context, input) => {
+      throwIfAborted(context.abortSignal);
+      const first = input.candidates[0]!;
+      const fileSystem = await creativeProjectFileSystem(
+        context.application,
+        input.project,
+      );
+      for (const candidate of input.candidates) {
+        throwIfAborted(context.abortSignal);
+        if (
+          candidate.base.projectId !== first.base.projectId
+          || candidate.base.baseSha256 !== first.base.baseSha256
+        ) {
+          throw new ApplicationError(
+            "conflict",
+            "Variant matrix candidates must come from one frozen project base.",
+          );
+        }
+        await loadCreativeCandidate({ fileSystem, reference: candidate });
+      }
+      const matrix = createVariantMatrixV1({
+        base: first.base,
+        candidates: input.candidates,
+      });
+      throwIfAborted(context.abortSignal);
+      await context.workflow?.beforePublication();
+      throwIfAborted(context.abortSignal);
+      const artifact = await publishCreativeDocument({
+        document: matrix,
+        fileSystem,
+        path: variantMatrixPath({
+          baseSha256: matrix.base.baseSha256,
+          matrixSha256: matrix.matrixSha256,
+        }),
+        schema: VariantMatrixV1Schema,
+      });
+      return variantMatrixReferenceV1({ artifact, matrix });
+    },
+  },
+  outputSchema: CreateVariantMatrixOutputSchema,
+  outputSchemaId: "slopcamera.operation.iteration.create-matrix.output/v1",
+  policy: {
+    cache: "content-addressed",
+    cancellable: true,
+    effect: "local-derived-write",
+    maxDurationMs: 30_000,
+    maxFanOut: 0,
+    maxInputBytes: 256 * 1024,
+    maxOutputBytes: 16 * 1024,
+    preparation: [],
+    resources: [
+      { amount: 1, resource: "cpu" },
+      { amount: 1, resource: "local-io" },
+    ],
+    resume: "deterministic",
+  },
+  summarize: output => ({
+    fields: {
+      candidateCount: output.candidateCount,
+      candidateSetSha256: output.candidateSetSha256,
+      matrixSha256: output.matrixSha256,
+    },
+    kind: "iteration.create-matrix",
+  }),
+  version: 1,
+} satisfies OperationDefinition<
+  "iteration.create-matrix",
+  CreateVariantMatrixInput,
+  CreateVariantMatrixOutput
+>;

package/apps/desktop/application/operations/iteration/select.ts

@@ -0,0 +1,155 @@
+import { z } from "zod";
+
+import { canonicalJson } from "../../../core";
+import {
+  createVariantSelectionV1,
+  CreativeVariantKeySchema,
+  variantSelectionPath,
+  variantSelectionReferenceV1,
+  VariantSelectionEvidenceV1Schema,
+  VariantSelectionReferenceV1Schema,
+  VariantSelectionV1Schema,
+  VariantMatrixReferenceV1Schema,
+} from "../../creative-iteration";
+import { ApplicationError } from "../../errors";
+import type { OperationDefinition } from "../../operation";
+import { ProjectReferenceSchema, throwIfAborted } from "../shared";
+import {
+  creativeProjectFileSystem,
+  loadCreativeCandidate,
+  loadVariantMatrix,
+  publishCreativeDocument,
+  verifyCandidateRender,
+} from "./shared";
+
+export const SelectVariantInputSchema = z.strictObject({
+  evidence: VariantSelectionEvidenceV1Schema.optional(),
+  matrix: VariantMatrixReferenceV1Schema,
+  project: ProjectReferenceSchema,
+  variantKey: CreativeVariantKeySchema,
+}).superRefine((input, context) => {
+  if (input.project !== input.matrix.base.projectId) {
+    context.addIssue({
+      code: "custom",
+      message: "Variant selection project does not match its matrix base.",
+      path: ["project"],
+    });
+  }
+});
+
+export const SelectVariantOutputSchema = VariantSelectionReferenceV1Schema;
+
+export type SelectVariantInput = z.infer<typeof SelectVariantInputSchema>;
+export type SelectVariantOutput = z.infer<typeof SelectVariantOutputSchema>;
+
+export const selectVariantOperationDefinition = {
+  inputSchema: SelectVariantInputSchema,
+  inputSchemaId: "slopcamera.operation.iteration.select.input/v1",
+  kind: "iteration.select",
+  lifecycle: {
+    kind: "local-artifact",
+    execute: async (context, input) => {
+      throwIfAborted(context.abortSignal);
+      const fileSystem = await creativeProjectFileSystem(
+        context.application,
+        input.project,
+      );
+      const matrix = await loadVariantMatrix({
+        fileSystem,
+        reference: input.matrix,
+      });
+      let chosenDocument;
+      const chosenReference = matrix.candidates.find(candidate => (
+        candidate.candidate.variantKey === input.variantKey
+      ));
+      if (chosenReference === undefined) {
+        throw new ApplicationError(
+          "not-found",
+          `Variant matrix does not contain variant key: ${input.variantKey}`,
+        );
+      }
+      for (const candidateReference of matrix.candidates) {
+        throwIfAborted(context.abortSignal);
+        const document = await loadCreativeCandidate({
+          fileSystem,
+          reference: candidateReference,
+        });
+        if (
+          candidateReference.candidate.candidateId
+            === chosenReference.candidate.candidateId
+        ) {
+          if (canonicalJson(candidateReference) !== canonicalJson(chosenReference)) {
+            throw new ApplicationError(
+              "conflict",
+              "Chosen candidate is not an exact member of the closed matrix.",
+            );
+          }
+          chosenDocument = document;
+        }
+      }
+      if (chosenDocument === undefined) {
+        throw new ApplicationError(
+          "conflict",
+          "Chosen candidate artifact could not be verified from the closed matrix.",
+        );
+      }
+      for (const render of chosenDocument.renders) {
+        throwIfAborted(context.abortSignal);
+        await verifyCandidateRender({
+          candidate: chosenDocument,
+          fileSystem,
+          render,
+        });
+      }
+      const selection = createVariantSelectionV1({
+        candidate: chosenDocument,
+        chosen: chosenReference,
+        ...(input.evidence === undefined ? {} : { evidence: input.evidence }),
+        matrix: input.matrix,
+      });
+      throwIfAborted(context.abortSignal);
+      await context.workflow?.beforePublication();
+      throwIfAborted(context.abortSignal);
+      const artifact = await publishCreativeDocument({
+        document: selection,
+        fileSystem,
+        path: variantSelectionPath({
+          baseSha256: selection.base.baseSha256,
+          selectionSha256: selection.selectionSha256,
+        }),
+        schema: VariantSelectionV1Schema,
+      });
+      return variantSelectionReferenceV1({ artifact, selection });
+    },
+  },
+  outputSchema: SelectVariantOutputSchema,
+  outputSchemaId: "slopcamera.operation.iteration.select.output/v1",
+  policy: {
+    cache: "content-addressed",
+    cancellable: true,
+    effect: "local-derived-write",
+    maxDurationMs: 30_000,
+    maxFanOut: 0,
+    maxInputBytes: 32 * 1024,
+    maxOutputBytes: 16 * 1024,
+    preparation: [],
+    resources: [
+      { amount: 1, resource: "cpu" },
+      { amount: 1, resource: "local-io" },
+    ],
+    resume: "deterministic",
+  },
+  summarize: output => ({
+    fields: {
+      candidateId: output.chosenCandidateId,
+      matrixSha256: output.matrixSha256,
+      selectionSha256: output.selectionSha256,
+    },
+    kind: "iteration.select",
+  }),
+  version: 1,
+} satisfies OperationDefinition<
+  "iteration.select",
+  SelectVariantInput,
+  SelectVariantOutput
+>;