@hraness/slopcamera 3.2.4

package/apps/desktop/application/operations/analysis/project-auto-zooms.ts

@@ -0,0 +1,302 @@
+import { z } from "zod";
+
+import {
+  AutomaticZoomPlannerConfigSchema,
+  ProjectPlacementIdSchema,
+  ProjectZoomOperationSchema,
+  RecordingIdSchema,
+  RecordingManifestV1Schema,
+  Sha256Schema,
+  VideoProjectIdSchema,
+  type RecordingEventV1,
+  type RecordingManifestV1,
+} from "../../../contracts";
+import {
+  canonicalJsonSha256,
+  hashPlacementSync,
+  mapAssetIntervalToProjectSlices,
+  mapAutomaticZoomsToProject,
+  planAutomaticZooms,
+} from "../../../core";
+import {
+  loadRecordingEvents,
+  openRecording,
+  type OpenRecording,
+} from "../../../cli/bundle-service";
+import type { ApplicationContext } from "../../context";
+import { ApplicationError } from "../../errors";
+import type { OperationDefinition } from "../../operation";
+import { openLeasedProjectSnapshot } from "../../project-publication-lease";
+import {
+  assertProjectEditBasis,
+  ProjectEditBasisSchema,
+  ProjectGenerationHashesSchema,
+  type OpenProjectSnapshot,
+} from "../../project-store";
+import {
+  ProjectReferenceSchema,
+  throwIfAborted,
+} from "../shared";
+
+export const DEFAULT_PROJECT_AUTO_ZOOM_CONFIG =
+  AutomaticZoomPlannerConfigSchema.parse({
+    enterDurationUs: 300_000,
+    exitDurationUs: 300_000,
+    intentMergeGapUs: 750_000,
+    maxDurationUs: 8_000_000,
+    maxScale: 3,
+    minDurationUs: 1_500_000,
+    postHandleUs: 1_000_000,
+    preHandleUs: 500_000,
+    scale: 2,
+  });
+
+export const ProjectAutoZoomBindingSchema = z.strictObject({
+  projectBinding: ProjectEditBasisSchema,
+  recordingId: RecordingIdSchema,
+  recordingManifestSha256: Sha256Schema,
+  sourcePlacementId: ProjectPlacementIdSchema,
+  syncSha256: Sha256Schema,
+});
+
+export const ProjectAutoZoomInputSchema = z.strictObject({
+  binding: ProjectAutoZoomBindingSchema.optional(),
+  config: AutomaticZoomPlannerConfigSchema.optional(),
+  project: ProjectReferenceSchema,
+  sourcePlacement: ProjectPlacementIdSchema.optional(),
+});
+
+export const ProjectAutoZoomOutputSchema = z.strictObject({
+  generation: ProjectGenerationHashesSchema,
+  operations: z.array(ProjectZoomOperationSchema).max(10_000),
+  projectId: VideoProjectIdSchema,
+  recordingId: RecordingIdSchema,
+  recordingManifestSha256: Sha256Schema,
+  sourcePlacementId: ProjectPlacementIdSchema,
+  sourceZoomCount: z.number().int().safe().nonnegative().max(10_000),
+  syncSha256: Sha256Schema,
+  unmappedSourceZoomCount: z.number().int().safe().nonnegative().max(10_000),
+});
+
+export type ProjectAutoZoomInput = z.infer<typeof ProjectAutoZoomInputSchema>;
+export type ProjectAutoZoomOutput = z.infer<typeof ProjectAutoZoomOutputSchema>;
+export type ProjectAutoZoomBinding = z.infer<typeof ProjectAutoZoomBindingSchema>;
+
+interface ProjectAutoZoomSubject {
+  readonly binding: ProjectAutoZoomBinding;
+  readonly manifest: RecordingManifestV1;
+  readonly placement: OpenProjectSnapshot["project"]["placements"][number];
+  readonly recording: OpenRecording;
+  readonly snapshot: OpenProjectSnapshot;
+}
+
+async function resolveSubject(
+  application: ApplicationContext,
+  input: ProjectAutoZoomInput,
+): Promise<ProjectAutoZoomSubject> {
+  const snapshot = await openLeasedProjectSnapshot(
+    application,
+    input.project,
+  );
+  const placementId = input.sourcePlacement
+    ?? snapshot.plan.effects.metadataPlacementId
+    ?? snapshot.project.referencePlacementId;
+  const placement = snapshot.project.placements.find(
+    candidate => candidate.placementId === placementId,
+  );
+  if (placement === undefined) {
+    throw new ApplicationError(
+      "not-found",
+      `Unknown project metadata placement: ${placementId}`,
+    );
+  }
+  if (!placement.enabled) {
+    throw new ApplicationError(
+      "conflict",
+      `Project metadata placement is disabled: ${placement.placementId}`,
+    );
+  }
+  if (placement.sync.provenance.kind === "unverified") {
+    throw new ApplicationError(
+      "conflict",
+      `Project metadata placement has unverified synchronization: ${placement.placementId}`,
+    );
+  }
+  const asset = snapshot.project.assets.find(
+    candidate => candidate.assetId === placement.assetId,
+  );
+  if (asset?.source.kind !== "recording") {
+    throw new ApplicationError(
+      "conflict",
+      `Placement ${placement.placementId} is not backed by a Slopcamera recording.`,
+    );
+  }
+  const recording = await openRecording(
+    application.paths.artifactRoot,
+    asset.source.recordingId,
+  );
+  const manifest = RecordingManifestV1Schema.parse(recording.manifest);
+  if (manifest.state !== "stopped") {
+    throw new ApplicationError(
+      "conflict",
+      "Project automatic zoom requires an immutable stopped recording.",
+    );
+  }
+  return {
+    binding: ProjectAutoZoomBindingSchema.parse({
+      projectBinding: snapshot.editBasis,
+      recordingId: manifest.recordingId,
+      recordingManifestSha256: canonicalJsonSha256(manifest),
+      sourcePlacementId: placement.placementId,
+      syncSha256: hashPlacementSync(placement),
+    }),
+    manifest,
+    placement,
+    recording,
+    snapshot,
+  };
+}
+
+export async function bindProjectAutoZoomInput(
+  application: ApplicationContext,
+  inputValue: unknown,
+): Promise<ProjectAutoZoomInput> {
+  const input = ProjectAutoZoomInputSchema.parse(inputValue);
+  const subject = await resolveSubject(application, input);
+  return ProjectAutoZoomInputSchema.parse({
+    ...input,
+    binding: subject.binding,
+    sourcePlacement: subject.placement.placementId,
+  });
+}
+
+export interface ProjectAutoZoomOperationDependencies {
+  readonly loadEvents?: (
+    recording: OpenRecording,
+  ) => Promise<readonly RecordingEventV1[]>;
+}
+
+export function createProjectAutoZoomOperationDefinition(
+  dependencies: ProjectAutoZoomOperationDependencies = {},
+): OperationDefinition<
+  "analysis.project-auto-zooms",
+  ProjectAutoZoomInput,
+  ProjectAutoZoomOutput
+> {
+  const loadEvents = dependencies.loadEvents ?? loadRecordingEvents;
+  return {
+    inputSchema: ProjectAutoZoomInputSchema,
+    inputSchemaId: "slopcamera.operation.analysis.project-auto-zooms.input/v1",
+    kind: "analysis.project-auto-zooms",
+    lifecycle: {
+      kind: "local-artifact",
+      execute: async (context, input) => {
+        throwIfAborted(context.abortSignal);
+        if (input.binding === undefined) {
+          throw new ApplicationError(
+            "unsupported-plan",
+            "Project automatic zoom execution requires a host-bound exact input.",
+          );
+        }
+        const subject = await resolveSubject(context.application, input);
+        const {
+          projectBinding: currentProjectBinding,
+          ...currentRecordingBinding
+        } = subject.binding;
+        assertProjectEditBasis(
+          currentProjectBinding,
+          subject.snapshot,
+        );
+        const {
+          projectBinding: plannedProjectBinding,
+          ...plannedRecordingBinding
+        } = input.binding;
+        if (
+          canonicalJsonSha256(currentRecordingBinding)
+          !== canonicalJsonSha256(plannedRecordingBinding)
+        ) {
+          throw new ApplicationError(
+            "conflict",
+            "Project automatic zoom bindings changed after node planning.",
+          );
+        }
+        assertProjectEditBasis(
+          plannedProjectBinding,
+          subject.snapshot,
+        );
+        const events = await loadEvents(subject.recording);
+        throwIfAborted(context.abortSignal);
+        const sourceZooms = planAutomaticZooms(
+          events,
+          subject.manifest.timeline.durationUs,
+          input.config ?? DEFAULT_PROJECT_AUTO_ZOOM_CONFIG,
+        );
+        const operations = mapAutomaticZoomsToProject(
+          subject.placement,
+          sourceZooms,
+        );
+        const unmappedSourceZoomCount = sourceZooms.filter(zoom => (
+          mapAssetIntervalToProjectSlices(
+            subject.placement,
+            zoom.range,
+          ).length === 0
+        )).length;
+        const finalSnapshot = await openLeasedProjectSnapshot(
+          context.application,
+          subject.snapshot.project.projectId,
+        );
+        assertProjectEditBasis(
+          subject.snapshot.editBasis,
+          finalSnapshot,
+        );
+        return {
+          generation: subject.snapshot.generation,
+          operations: [...operations],
+          projectId: subject.snapshot.project.projectId,
+          recordingId: subject.binding.recordingId,
+          recordingManifestSha256: subject.binding.recordingManifestSha256,
+          sourcePlacementId: subject.placement.placementId,
+          sourceZoomCount: sourceZooms.length,
+          syncSha256: subject.binding.syncSha256,
+          unmappedSourceZoomCount,
+        };
+      },
+    },
+    outputSchema: ProjectAutoZoomOutputSchema,
+    outputSchemaId: "slopcamera.operation.analysis.project-auto-zooms.output/v1",
+    policy: {
+      cache: "exact-run",
+      cancellable: true,
+      effect: "local-read",
+      maxDurationMs: 2 * 60_000,
+      maxFanOut: 1,
+      maxInputBytes: 32_768,
+      maxOutputBytes: 16 * 1024 * 1024,
+      preparation: [
+        "project-state",
+        "recording-metadata",
+        "typed-text",
+        "window-metadata",
+      ],
+      resources: [
+        { amount: 1, resource: "cpu" },
+        { amount: 1, resource: "local-io" },
+      ],
+      resume: "deterministic",
+    },
+    summarize: output => ({
+      fields: {
+        operations: output.operations.length,
+        projectId: output.projectId,
+        recordingId: output.recordingId,
+        sourcePlacementId: output.sourcePlacementId,
+        sourceZooms: output.sourceZoomCount,
+      },
+      kind: "analysis.project-auto-zooms",
+    }),
+    version: 1,
+  };
+}
+
+export const projectAutoZoomOperationDefinition =
+  createProjectAutoZoomOperationDefinition();

package/apps/desktop/application/operations/analysis/project-inactivity.ts

@@ -0,0 +1,381 @@
+import { z } from "zod";
+
+import {
+  AnalysisIdSchema,
+  ProjectPlacementIdSchema,
+  ProjectAnalysisReferenceSchema,
+  ProjectInactivityAnalysisV1Schema,
+  ProjectInactivityConfigSchema,
+  RecordingIdSchema,
+  RepositoryRelativePathSchema,
+  Sha256Schema,
+  SourceIntervalSchema,
+  VideoProjectIdSchema,
+  type ProjectInactivityAnalysisV1,
+  type VideoProjectV1,
+} from "../../../contracts";
+import {
+  DEFAULT_PROJECT_INACTIVITY_CONFIG,
+  analyzeProjectInactivity,
+  loadProjectInactivityReferenceEvidence,
+  publishProjectInactivityArtifact,
+  type AnalyzeProjectInactivityOptions,
+  type ProjectInactivityReferenceEvidence,
+  type PublishedProjectInactivityArtifact,
+} from "../../../cli/project-inactivity-service";
+import {
+  canonicalJson,
+  canonicalJsonSha256,
+} from "../../../core";
+import type { ApplicationContext } from "../../context";
+import { ApplicationError } from "../../errors";
+import type { OperationDefinition } from "../../operation";
+import { writeOperationCompletionCheckpoint } from "../../operation-completion-checkpoint";
+import {
+  mergeProjectAnalysisReference,
+  openLeasedProjectSnapshot,
+  projectAnalysisPublicationBasis,
+} from "../../project-publication-lease";
+import {
+  ProjectReferenceSchema,
+  requireCapabilities,
+  requiredCapabilityVersion,
+  throwIfAborted,
+} from "../shared";
+import {
+  AnalysisCapabilityBindingsSchema,
+  AnalysisProjectBindingSchema,
+  analysisCapabilityCommand,
+  analysisCapabilityRunner,
+  assertAnalysisCapabilityBindings,
+  assertAnalysisProjectBinding,
+  assertPublishedAnalysisReference,
+  bindAnalysisCapabilityInput,
+  resolveAnalysisId,
+  resolveToolVersion,
+  type VersionedAnalysisDependencies,
+} from "./shared";
+
+interface AnalyzedProjectInactivity {
+  readonly analysis: Pick<
+    ProjectInactivityAnalysisV1,
+    "analysisId" | "projectId" | "referenceRecording" | "result"
+  >;
+}
+
+type ProjectInactivityExecutor = (
+  options: AnalyzeProjectInactivityOptions,
+) => Promise<AnalyzedProjectInactivity>;
+
+type ProjectInactivityPublisher = (options: {
+  readonly analysis: AnalyzedProjectInactivity["analysis"];
+  readonly project: AnalyzeProjectInactivityOptions["project"];
+}) => Promise<PublishedProjectInactivityArtifact>;
+
+export interface ProjectInactivityOperationDependencies
+  extends VersionedAnalysisDependencies {
+  readonly analyze?: ProjectInactivityExecutor;
+  readonly publish?: ProjectInactivityPublisher;
+}
+
+export const ProjectInactivityOperationInputSchema = z.strictObject({
+  analysisId: AnalysisIdSchema.optional(),
+  capabilityBindings: AnalysisCapabilityBindingsSchema.optional(),
+  config: ProjectInactivityConfigSchema.optional(),
+  project: ProjectReferenceSchema,
+  projectBinding: AnalysisProjectBindingSchema.optional(),
+  recordingBinding: z.strictObject({
+    eventsSha256: Sha256Schema,
+    eventStreamsSha256: Sha256Schema,
+    manifestSha256: Sha256Schema,
+    placementId: ProjectPlacementIdSchema,
+    recordingId: RecordingIdSchema,
+    syncMapSha256: Sha256Schema,
+  }).nullable().optional(),
+});
+
+export const ProjectInactivityOperationOutputSchema = z.strictObject({
+  analysisId: AnalysisIdSchema,
+  candidateCount: z.number().int().safe().nonnegative(),
+  cuts: z.array(SourceIntervalSchema).max(100_000),
+  evidencePath: RepositoryRelativePathSchema,
+  projectId: VideoProjectIdSchema,
+  protectedInteractionCount: z.number().int().safe().nonnegative(),
+  reference: ProjectAnalysisReferenceSchema,
+  referenceRecording: RecordingIdSchema.nullable(),
+}).superRefine((output, context) => {
+  if (output.reference.kind !== "inactivity") {
+    context.addIssue({ code: "custom", message: "Expected an inactivity analysis reference.", path: ["reference"] });
+    return;
+  }
+  if (
+    output.reference.analysisId !== output.analysisId
+    || output.reference.path !== output.evidencePath
+    || output.reference.recommendedRanges !== output.cuts.length
+  ) {
+    context.addIssue({
+      code: "custom",
+      message: "Inactivity result and authoritative reference disagree.",
+      path: ["reference"],
+    });
+  }
+});
+
+export type ProjectInactivityOperationInput = z.infer<
+  typeof ProjectInactivityOperationInputSchema
+>;
+
+export function projectInactivityRecordingBinding(
+  evidence: ProjectInactivityReferenceEvidence,
+): ProjectInactivityOperationInput["recordingBinding"] {
+  if (evidence.manifest === null) {
+    if (
+      evidence.referenceRecording !== null
+      || evidence.events.length !== 0
+    ) {
+      throw new ApplicationError(
+        "internal",
+        "Non-recording inactivity evidence unexpectedly contains recording metadata.",
+      );
+    }
+    return null;
+  }
+  if (evidence.manifest.state !== "stopped") {
+    throw new ApplicationError(
+      "conflict",
+      "Workflow inactivity analysis requires immutable stopped recording metadata.",
+    );
+  }
+  const reference = evidence.referenceRecording;
+  if (
+    reference === null
+    || reference.recordingId !== evidence.manifest.recordingId
+  ) {
+    throw new ApplicationError(
+      "internal",
+      "Inactivity recording evidence disagrees with its manifest identity.",
+    );
+  }
+  return {
+    eventsSha256: canonicalJsonSha256(evidence.events),
+    eventStreamsSha256: canonicalJsonSha256(evidence.input),
+    manifestSha256: canonicalJsonSha256(evidence.manifest),
+    placementId: reference.placementId,
+    recordingId: reference.recordingId,
+    syncMapSha256: reference.syncMapSha256,
+  };
+}
+
+export async function bindProjectInactivityInput(
+  application: ApplicationContext,
+  inputValue: unknown,
+): Promise<ProjectInactivityOperationInput> {
+  const input = ProjectInactivityOperationInputSchema.parse(
+    await bindAnalysisCapabilityInput(
+      application,
+      "analysis.project-inactivity",
+      inputValue,
+    ),
+  );
+  const snapshot = await openLeasedProjectSnapshot(
+    application,
+    input.project,
+  );
+  assertAnalysisProjectBinding(
+    { workflow: {} },
+    input.projectBinding,
+    snapshot,
+  );
+  const config = input.config ?? DEFAULT_PROJECT_INACTIVITY_CONFIG;
+  const evidence = await loadProjectInactivityReferenceEvidence(
+    snapshot.project,
+    application.paths.artifactRoot,
+    config.cursorMovementThresholdPx,
+  );
+  return ProjectInactivityOperationInputSchema.parse({
+    ...input,
+    recordingBinding: projectInactivityRecordingBinding(evidence),
+  });
+}
+
+function assertRecordingBinding(
+  context: { readonly workflow?: unknown },
+  expected: ProjectInactivityOperationInput["recordingBinding"],
+  evidence: ProjectInactivityReferenceEvidence,
+): void {
+  if (context.workflow !== undefined && expected === undefined) {
+    throw new ApplicationError(
+      "incompatible",
+      "Workflow inactivity analysis requires exact recording metadata bindings.",
+    );
+  }
+  if (
+    expected !== undefined
+    && canonicalJson(expected)
+      !== canonicalJson(projectInactivityRecordingBinding(evidence))
+  ) {
+    throw new ApplicationError(
+      "conflict",
+      "Reference recording metadata changed after inactivity analysis planning.",
+    );
+  }
+}
+export interface ProjectInactivityOperationOutput {
+  readonly analysisId: ProjectInactivityAnalysisV1["analysisId"];
+  readonly candidateCount: number;
+  readonly cuts: ProjectInactivityAnalysisV1["result"]["recommendedRanges"];
+  readonly evidencePath: string;
+  readonly projectId: ProjectInactivityAnalysisV1["projectId"];
+  readonly protectedInteractionCount: number;
+  readonly reference: VideoProjectV1["analyses"][number];
+  readonly referenceRecording: ProjectInactivityAnalysisV1["referenceRecording"] extends null
+    ? never
+    : NonNullable<ProjectInactivityAnalysisV1["referenceRecording"]>["recordingId"] | null;
+}
+
+export function createProjectInactivityOperationDefinition(
+  dependencies: ProjectInactivityOperationDependencies,
+): OperationDefinition<
+  "analysis.project-inactivity",
+  ProjectInactivityOperationInput,
+  ProjectInactivityOperationOutput
+> {
+  const executeAnalysis = dependencies.analyze ?? analyzeProjectInactivity;
+  const publishAnalysis = dependencies.publish ?? (async options =>
+    await publishProjectInactivityArtifact({
+      analysis: ProjectInactivityAnalysisV1Schema.parse(options.analysis),
+      project: options.project,
+    }));
+  const toolVersion = resolveToolVersion(dependencies);
+  return {
+    inputSchema: ProjectInactivityOperationInputSchema,
+    inputSchemaId: "slopcamera.operation.analysis.project-inactivity.input/v1",
+    kind: "analysis.project-inactivity",
+    lifecycle: {
+      kind: "local-artifact",
+      execute: async (context, input) => {
+        throwIfAborted(context.abortSignal);
+        const snapshot = await openLeasedProjectSnapshot(
+          context.application,
+          input.project,
+        );
+        assertAnalysisProjectBinding(context, input.projectBinding, snapshot);
+        const publicationBasis = projectAnalysisPublicationBasis(snapshot);
+        const project = snapshot.openProject;
+        const capabilities = await requireCapabilities(
+          context.application,
+          ["ffmpeg", "ffprobe"],
+        );
+        await assertAnalysisCapabilityBindings(
+          context,
+          input.capabilityBindings,
+          context.application,
+          ["ffmpeg", "ffprobe"],
+        );
+        const config = input.config ?? DEFAULT_PROJECT_INACTIVITY_CONFIG;
+        const referenceEvidence =
+          await loadProjectInactivityReferenceEvidence(
+            snapshot.project,
+            context.application.paths.artifactRoot,
+            config.cursorMovementThresholdPx,
+          );
+        assertRecordingBinding(
+          context,
+          input.recordingBinding,
+          referenceEvidence,
+        );
+        const analyzed = await executeAnalysis({
+          analysisId: resolveAnalysisId(input.analysisId, dependencies),
+          artifactRoot: context.application.paths.artifactRoot,
+          config,
+          ffmpeg: analysisCapabilityCommand(
+            input.capabilityBindings,
+            capabilities,
+            "ffmpeg",
+          ),
+          ffmpegVersion: requiredCapabilityVersion(capabilities, "ffmpeg"),
+          ffprobe: analysisCapabilityCommand(
+            input.capabilityBindings,
+            capabilities,
+            "ffprobe",
+          ),
+          now: context.application.clock.now(),
+          project,
+          referenceEvidence,
+          repositoryRoot: context.application.paths.repositoryRoot,
+          runner: analysisCapabilityRunner(
+            context.application,
+            input.capabilityBindings,
+          ),
+          toolVersion,
+        });
+        throwIfAborted(context.abortSignal);
+        await context.workflow?.beforePublication();
+        const published = await publishAnalysis({
+          analysis: analyzed.analysis,
+          project,
+        });
+        throwIfAborted(context.abortSignal);
+        const merged = await mergeProjectAnalysisReference({
+          application: context.application,
+          basis: publicationBasis,
+          beforePublication: async () => {
+            await context.workflow?.beforePublication();
+          },
+          operation: "analysis.project-inactivity",
+          project: input.project,
+          reference: published.reference,
+        });
+        assertPublishedAnalysisReference(merged.project, merged.reference);
+        const output = ProjectInactivityOperationOutputSchema.parse({
+          analysisId: analyzed.analysis.analysisId,
+          candidateCount: analyzed.analysis.result.candidateCount,
+          cuts: analyzed.analysis.result.recommendedRanges,
+          evidencePath: published.analysisPath,
+          projectId: analyzed.analysis.projectId,
+          protectedInteractionCount: analyzed.analysis.result.protectedInteractionCount,
+          reference: merged.reference,
+          referenceRecording: analyzed.analysis.referenceRecording?.recordingId ?? null,
+        });
+        await writeOperationCompletionCheckpoint(context, {
+          inputSchemaId:
+            "slopcamera.operation.analysis.project-inactivity.input/v1",
+          kind: "analysis.project-inactivity",
+          outputSchemaId:
+            "slopcamera.operation.analysis.project-inactivity.output/v1",
+          version: 1,
+        }, output);
+        return output;
+      },
+    },
+    outputSchema: ProjectInactivityOperationOutputSchema,
+    outputSchemaId: "slopcamera.operation.analysis.project-inactivity.output/v1",
+    policy: {
+      cache: "none",
+      cancellable: true,
+      effect: "local-derived-write",
+      maxDurationMs: 2 * 60 * 60_000,
+      maxFanOut: 1,
+      maxInputBytes: 16_384,
+      maxOutputBytes: 8 * 1024 * 1024,
+      preparation: ["project-state", "recording-metadata", "local-media"],
+      resources: [
+        { amount: 1, resource: "cpu" },
+        { amount: 1, resource: "ffmpeg" },
+        { amount: 1, resource: "local-io" },
+      ],
+      resume: "verified-receipt",
+    },
+    summarize: output => ({
+      fields: {
+        analysisId: output.analysisId,
+        candidateCount: output.candidateCount,
+        cuts: output.cuts.length,
+        evidencePath: output.evidencePath,
+        projectId: output.projectId,
+      },
+      kind: "analysis.project-inactivity",
+    }),
+    version: 1,
+  };
+}