@sshkeda/task 0.0.0-stage → 1.0.0

package/src/lib/main-thread/lib/run-tasks-on-workers/lib/run-requested-task-once/internal/execute-task.ts

@@ -0,0 +1,272 @@
+import {
+  Cause,
+  Clock,
+  Deferred,
+  Duration,
+  Effect,
+  Exit,
+  FiberSet,
+  Option,
+  Ref,
+  Schema,
+} from "effect";
+
+import {
+  formatTaskPassed,
+  formatTaskServing,
+} from "../../../../../../../shared/format-task-lines.ts";
+import { dieOnInvariantFailure } from "../../../../../../../shared/invariant-errors.ts";
+import { TASK_TRACE_LABEL_PREFIX } from "../../../../../../../shared/names-from-package-json.ts";
+import { printTaskLines } from "../../../../../../../shared/print-to-standard-error.ts";
+import { WorkerExited } from "../../../../../../../shared/process-errors.ts";
+import {
+  TaskBodyFailed,
+  TaskSetupTimedOut,
+  TaskTimedOut,
+} from "../../../../../../../shared/task-errors.ts";
+import { failRun, failTask } from "../../../../../shared/fail-run.ts";
+import { StopState } from "../../../../../shared/provide-stop-state.ts";
+import { FromWorker, WorkerPool } from "../../../../../shared/provide-worker-pool.ts";
+import { reportFailure, reportTaskFailure } from "../../../../../shared/report-task-failure.ts";
+import {
+  formatTaskRunStatusForTrace,
+  findAssignedWorkerId,
+  findTaskNamesOccupyingWorker,
+  formatWaitingForWorker,
+} from "../../../shared/define-task-run-state.ts";
+import type { makeTaskRunsState } from "../../../shared/define-task-run-state.ts";
+import type { makeStopwatch } from "../../../shared/make-stopwatch.ts";
+import { stopTask } from "../../../shared/stop-task.ts";
+import { awaitWithinCountedLimit } from "./await-within-counted-limit.ts";
+import { makeTaskSetupClock } from "./make-task-setup-clock.ts";
+
+const isTaskTimedOut = Schema.is(TaskTimedOut);
+
+const STILL_BEFORE_BODY_NOTICE_SECONDS = 2;
+
+const STILL_BEFORE_BODY_NOTICE_AFTER = Duration.seconds(STILL_BEFORE_BODY_NOTICE_SECONDS);
+
+const isTaskSetupTimedOut = Schema.is(TaskSetupTimedOut);
+
+const taskTimedOut = (taskName: string, timeoutDuration: Duration.Duration) =>
+  new TaskTimedOut({ taskName, timeoutMilliseconds: Duration.toMillis(timeoutDuration) });
+
+const awaitWithinTimeout = <Success, Failure, Services>(
+  awaiting: Effect.Effect<Success, Failure, Services>,
+  bodyWaitingOnRequestedTasks: ReturnType<typeof makeStopwatch>,
+  bodyStartedAtMilliseconds: number,
+  timeoutDuration: Duration.Duration,
+) =>
+  awaitWithinCountedLimit(awaiting, Duration.toMillis(timeoutDuration), (nowMilliseconds) =>
+    Effect.succeed(
+      nowMilliseconds -
+        bodyStartedAtMilliseconds -
+        bodyWaitingOnRequestedTasks.readMilliseconds(nowMilliseconds),
+    ),
+  );
+
+const failRunWhenCleanupOutlastsTimeout = Effect.fn("failRunWhenCleanupOutlastsTimeout")(function* (
+  taskRunsState: Effect.Success<typeof makeTaskRunsState>,
+  taskName: string,
+  timeoutDuration: Duration.Duration,
+) {
+  const taskRun = yield* Effect.fromNullishOr(taskRunsState.runsByTaskName.get(taskName)).pipe(
+    dieOnInvariantFailure("task timeouts", "a task whose cleanup is timed has a run"),
+  );
+  const bodyStartedAtMilliseconds = yield* Deferred.await(
+    taskRun.bodyStartedAtMillisecondsDeferred,
+  ).pipe(Effect.raceFirst(Deferred.await(taskRun.bodyFinishedDeferred).pipe(Effect.as(null))));
+  if (bodyStartedAtMilliseconds === null) {
+    return;
+  }
+  const bodyFinished = yield* awaitWithinTimeout(
+    Deferred.await(taskRun.bodyFinishedDeferred),
+    taskRun.bodyWaitingOnRequestedTasks,
+    bodyStartedAtMilliseconds,
+    timeoutDuration,
+  );
+  if (Option.isNone(bodyFinished)) {
+    yield* failRun(taskTimedOut(taskName, timeoutDuration), taskRunsState.markFailed);
+  }
+});
+
+const endsRunDirectly = Schema.is(Schema.Union([TaskSetupTimedOut, WorkerExited]));
+
+export const executeTask = Effect.fn("executeTaskFiber")(
+  function* (taskRunsState: Effect.Success<typeof makeTaskRunsState>, taskName: string) {
+    yield* Effect.annotateCurrentSpan(`${TASK_TRACE_LABEL_PREFIX}.task`, taskName);
+    yield* Effect.logInfo("task started").pipe(
+      Effect.annotateLogs(`${TASK_TRACE_LABEL_PREFIX}.task`, taskName),
+    );
+    const discoveredTask = yield* Effect.fromNullishOr(
+      taskRunsState.discoveredTasksByName.get(taskName),
+    ).pipe(dieOnInvariantFailure("task execution", "the requested task is registered and started"));
+    const taskRun = yield* Effect.fromNullishOr(taskRunsState.runsByTaskName.get(taskName)).pipe(
+      dieOnInvariantFailure("task execution", "the requested task is registered and started"),
+    );
+
+    const span = yield* Effect.currentSpan.pipe(
+      dieOnInvariantFailure("task execution", "the task has a tracing span"),
+    );
+    const setupClock = yield* makeTaskSetupClock(
+      taskRunsState,
+      taskName,
+      discoveredTask.cleanupDuration,
+    );
+    const waitingForWorkerIdRef = yield* Ref.make<number | null>(null);
+    const describeStepBeforeBody = () => {
+      const waitingForWorkerId = Ref.getUnsafe(waitingForWorkerIdRef);
+      if (waitingForWorkerId === null) {
+        return taskRun.stepBeforeBody;
+      }
+      if (Deferred.isDoneUnsafe(taskRun.bodyStartedAtMillisecondsDeferred)) {
+        return null;
+      }
+      const occupyingTaskNames = findTaskNamesOccupyingWorker(
+        taskRunsState.runsByTaskName,
+        waitingForWorkerId,
+      ).filter((occupyingTaskName) => occupyingTaskName !== taskName);
+      const [longestOccupyingTaskName, ...otherTaskNames] = occupyingTaskNames;
+      if (longestOccupyingTaskName !== undefined) {
+        return formatWaitingForWorker(waitingForWorkerId, longestOccupyingTaskName, otherTaskNames);
+      }
+      return Deferred.isDoneUnsafe(taskRun.bodyLoadingDeferred)
+        ? `loading ${discoveredTask.filePath}`
+        : `waiting for worker ${waitingForWorkerId} to take it`;
+    };
+    const awaitBodyStart = Effect.gen(function* () {
+      yield* printTaskLines("Info", taskName, "started");
+
+      const workerPool = yield* WorkerPool;
+      taskRun.stepBeforeBody = "starting a worker";
+      const workerId = yield* workerPool
+        .selectWorkerIdForTask(taskRunsState.readWorkerLoad, (selectedWorkerId) =>
+          taskRunsState.recordWorkerAssignment(taskName, selectedWorkerId),
+        )
+        .pipe(
+          Effect.mapError(
+            (failure) => new TaskBodyFailed({ taskName, failures: reportFailure(failure) }),
+          ),
+        );
+      yield* setupClock.recordWorkerAssignment(workerId);
+      yield* workerPool.startTaskFiber(workerId, {
+        taskName,
+        taskFilePath: discoveredTask.filePath,
+        taskPackageDirectoryPath: discoveredTask.packageJsonDirectoryPath,
+        cleanupMilliseconds: Duration.toMillis(discoveredTask.cleanupDuration),
+        traceId: span.traceId,
+        spanId: span.spanId,
+        standardInput: taskRunsState.rootTaskStandardInput.standardInput,
+      });
+      yield* Ref.set(waitingForWorkerIdRef, workerId);
+      const awaitBodyStarted = Deferred.await(taskRun.bodyStartedAtMillisecondsDeferred).pipe(
+        Effect.raceFirst(Deferred.await(taskRun.bodyFinishedDeferred)),
+      );
+      const startedBeforeNotice = yield* awaitBodyStarted.pipe(
+        Effect.timeoutOption(STILL_BEFORE_BODY_NOTICE_AFTER),
+      );
+      const stepAtNotice = describeStepBeforeBody();
+      const isStillBeforeBodyAtNotice = Option.isNone(startedBeforeNotice) && stepAtNotice !== null;
+      if (isStillBeforeBodyAtNotice) {
+        yield* printTaskLines("Info", taskName, stepAtNotice);
+      }
+      yield* awaitBodyStarted;
+    }).pipe((setup) =>
+      setupClock.limit(setup, () => describeStepBeforeBody() ?? "waiting for its body to start"),
+    );
+    const timeoutDuration = discoveredTask.timeoutDuration;
+    const awaitBodyOutcome = Effect.gen(function* () {
+      yield* awaitBodyStart;
+      const awaitOutcome = Deferred.await(taskRun.bodyOutcomeDeferred);
+      const bodyStartedAtMilliseconds = yield* Deferred.poll(
+        taskRun.bodyStartedAtMillisecondsDeferred,
+      ).pipe(Effect.flatMap(Effect.transposeOption));
+      const hasNoBodyTimeout = timeoutDuration === null || Option.isNone(bodyStartedAtMilliseconds);
+      if (hasNoBodyTimeout) {
+        return yield* awaitOutcome;
+      }
+      const outcome = yield* awaitWithinTimeout(
+        awaitOutcome,
+        taskRun.bodyWaitingOnRequestedTasks,
+        bodyStartedAtMilliseconds.value,
+        timeoutDuration,
+      );
+      if (Option.isNone(outcome)) {
+        const timedOut = taskTimedOut(taskName, timeoutDuration);
+        yield* failTask(timedOut, taskRunsState.markFailed);
+        yield* stopTask(taskRunsState, taskName, (watch) =>
+          FiberSet.run(taskRunsState.taskFibers, watch).pipe(Effect.asVoid),
+        );
+        return yield* timedOut;
+      }
+      return outcome.value;
+    });
+    const outcome = yield* Effect.uninterruptibleMask((restore) =>
+      Effect.gen(function* () {
+        const outcomeExit = yield* Effect.exit(restore(awaitBodyOutcome));
+        const cleanupMayOutlastTimeout =
+          Exit.isFailure(outcomeExit) &&
+          timeoutDuration !== null &&
+          findAssignedWorkerId(taskRun.status) !== null &&
+          !Deferred.isDoneUnsafe(taskRun.bodyFinishedDeferred) &&
+          !Option.exists(
+            Exit.findErrorOption(outcomeExit),
+            (failure) => isTaskTimedOut(failure) || isTaskSetupTimedOut(failure),
+          );
+        if (cleanupMayOutlastTimeout) {
+          yield* FiberSet.run(
+            taskRunsState.taskFibers,
+            failRunWhenCleanupOutlastsTimeout(taskRunsState, taskName, timeoutDuration),
+          );
+        }
+        return yield* outcomeExit;
+      }),
+    );
+    const taskBodyStartedAtMilliseconds = yield* Deferred.await(
+      taskRun.bodyStartedAtMillisecondsDeferred,
+    );
+    if (FromWorker.guards.TaskFiberServed(outcome)) {
+      yield* printTaskLines(
+        "Info",
+        taskName,
+        formatTaskServing((yield* Clock.currentTimeMillis) - taskBodyStartedAtMilliseconds),
+      );
+      return outcome.value;
+    }
+
+    yield* taskRunsState.markPassed(taskName);
+    yield* printTaskLines("Info", taskName, formatTaskPassed(outcome.elapsedMilliseconds));
+    return outcome.value;
+  },
+  (effect, taskRunsState, taskName) =>
+    effect.pipe(
+      Effect.scoped,
+      Effect.onExit((taskExit) =>
+        Effect.gen(function* () {
+          const taskRun = taskRunsState.runsByTaskName.get(taskName);
+          const isTaskRunMissing = taskRun === undefined;
+          if (isTaskRunMissing) {
+            return;
+          }
+
+          taskRunsState.markEndedFromExit(taskName, taskExit);
+          yield* Effect.annotateCurrentSpan(
+            `${TASK_TRACE_LABEL_PREFIX}.state`,
+            formatTaskRunStatusForTrace(taskRun.status),
+          );
+          const failure = Exit.findErrorOption(taskExit);
+          const failedUnreportedWithMoreThanInterrupts =
+            Exit.isFailure(taskExit) &&
+            !Cause.hasInterruptsOnly(taskExit.cause) &&
+            !Option.exists(failure, isTaskTimedOut);
+          if (failedUnreportedWithMoreThanInterrupts) {
+            yield* reportTaskFailure(taskName, taskExit.cause);
+          }
+          const failureEndsRun = Option.isSome(failure) && endsRunDirectly(failure.value);
+          if (failureEndsRun) {
+            yield* (yield* StopState).recordFirstFailure(failure.value);
+          }
+        }),
+      ),
+    ),
+);

package/src/lib/main-thread/lib/run-tasks-on-workers/lib/run-requested-task-once/internal/make-task-setup-clock.ts

@@ -0,0 +1,129 @@
+import { Cause, Clock, Duration, Effect, Exit, Fiber, Option, Ref } from "effect";
+
+import { TaskSetupTimedOut } from "../../../../../../../shared/task-errors.ts";
+import { failRun } from "../../../../../shared/fail-run.ts";
+import { TaskCleanupTimedOut } from "../../../../../shared/main-thread-errors.ts";
+import { RunRootTaskConfig } from "../../../../../shared/provide-run-root-task-config.ts";
+import type { makeTaskRunsState } from "../../../shared/define-task-run-state.ts";
+import { awaitWithinCountedLimit } from "./await-within-counted-limit.ts";
+
+export const makeTaskSetupClock = Effect.fn("makeTaskSetupClock")(function* (
+  taskRunsState: Effect.Success<typeof makeTaskRunsState>,
+  taskName: string,
+  cleanupDuration: Duration.Duration,
+) {
+  const limitMilliseconds = Duration.toMillis((yield* RunRootTaskConfig).setupLimit);
+  const setupStartedAtMilliseconds = yield* Clock.currentTimeMillis;
+  const workerAssignment = yield* Ref.make(
+    Option.none<{
+      readonly workerId: number;
+      readonly busyMillisecondsAtAssignment: number;
+    }>(),
+  );
+  const countSetupMilliseconds = (nowMilliseconds: number) =>
+    Effect.map(Ref.get(workerAssignment), (assignedWorker) => {
+      const workerBusyMilliseconds = Option.match(assignedWorker, {
+        onNone: () => 0,
+        onSome: (worker) =>
+          taskRunsState.readWorkerBodyBusyMilliseconds(worker.workerId, nowMilliseconds) -
+          worker.busyMillisecondsAtAssignment,
+      });
+      return nowMilliseconds - setupStartedAtMilliseconds - workerBusyMilliseconds;
+    });
+  const interruptSetupKeepingFailures = <Success, Failure>(
+    setupFiber: Fiber.Fiber<Success, Failure>,
+  ) =>
+    Effect.gen(function* () {
+      const cleanup = Fiber.interrupt(setupFiber).pipe(Effect.andThen(Fiber.await(setupFiber)));
+      const interruptedSetupExit = yield* cleanup.pipe(
+        Effect.interruptible,
+        Effect.timeoutOrElse({
+          duration: cleanupDuration,
+          orElse: () =>
+            Effect.succeed(
+              Exit.fail<Failure | TaskCleanupTimedOut>(
+                new TaskCleanupTimedOut({
+                  taskName,
+                  cleanupMilliseconds: Duration.toMillis(cleanupDuration),
+                }),
+              ),
+            ),
+        }),
+      );
+      const failuresWhileInterrupted = Exit.isFailure(interruptedSetupExit)
+        ? interruptedSetupExit.cause.reasons.filter((reason) => !Cause.isInterruptReason(reason))
+        : [];
+      const failures = Cause.fromReasons(failuresWhileInterrupted);
+      if (failures.reasons.length > 0) {
+        return yield* Effect.failCause(failures);
+      }
+    });
+  const awaitSetupWithinLimit = <Success, Failure>(
+    setupFiber: Fiber.Fiber<Success, Failure>,
+    describeUnfinishedStep: () => string,
+  ) =>
+    Effect.gen(function* () {
+      const setupExit = yield* awaitWithinCountedLimit(
+        Fiber.await(setupFiber),
+        limitMilliseconds,
+        countSetupMilliseconds,
+      );
+      if (Option.isSome(setupExit)) {
+        return setupExit.value;
+      }
+      yield* failRun(
+        new TaskSetupTimedOut({
+          taskName,
+          limitMilliseconds,
+          unfinishedStep: describeUnfinishedStep(),
+        }),
+        taskRunsState.markFailed,
+      );
+      return null;
+    });
+  return {
+    recordWorkerAssignment: (workerId: number) =>
+      Effect.flatMap(Clock.currentTimeMillis, (nowMilliseconds) =>
+        Ref.set(
+          workerAssignment,
+          Option.some({
+            workerId,
+            busyMillisecondsAtAssignment: taskRunsState.readWorkerBodyBusyMilliseconds(
+              workerId,
+              nowMilliseconds,
+            ),
+          }),
+        ),
+      ),
+    limit: <Success, Failure, Services>(
+      setup: Effect.Effect<Success, Failure, Services>,
+      describeUnfinishedStep: () => string,
+    ) =>
+      Effect.uninterruptibleMask((restore) =>
+        Effect.gen(function* () {
+          const context = yield* Effect.context<Services>();
+          const hasReadSetupExit = yield* Ref.make(false);
+          return yield* Effect.acquireUseRelease(
+            Effect.sync(() =>
+              Effect.runForkWith(context)(restore(setup), { uninterruptible: true }),
+            ),
+            (setupFiber) =>
+              Effect.interruptible(awaitSetupWithinLimit(setupFiber, describeUnfinishedStep)).pipe(
+                Effect.flatMap((setupExit) => {
+                  if (setupExit === null) {
+                    return Effect.interrupt;
+                  }
+                  return Ref.set(hasReadSetupExit, true).pipe(Effect.andThen(setupExit));
+                }),
+              ),
+            (setupFiber) =>
+              Ref.get(hasReadSetupExit).pipe(
+                Effect.flatMap((hasReadExit) =>
+                  hasReadExit ? Effect.void : interruptSetupKeepingFailures(setupFiber),
+                ),
+              ),
+          );
+        }),
+      ),
+  };
+});

package/src/lib/main-thread/lib/run-tasks-on-workers/lib/run-requested-task-once/internal/run-requested-tasks.ts

@@ -0,0 +1,135 @@
+import { Deferred, Effect, FiberSet } from "effect";
+
+import { TASK_TRACE_LABEL_PREFIX } from "../../../../../../../shared/names-from-package-json.ts";
+import {
+  AwaitedTaskFailed,
+  TaskNotMadeAtTopLevel,
+  TaskWaitsOnItself,
+} from "../../../../../../errors/index.ts";
+import type { makeTaskRun, makeTaskRunsState } from "../../../shared/define-task-run-state.ts";
+import { executeTask } from "./execute-task.ts";
+
+const requestedTaskNotDiscovered = (requestedTaskName: string, requestingTaskName: string) =>
+  new TaskNotMadeAtTopLevel({ taskName: requestingTaskName, requestedTaskName });
+
+const runTaskOnce = Effect.fn("runTaskOnce")(function* (
+  taskRunsState: Effect.Success<typeof makeTaskRunsState>,
+  resultDeferreds: Map<
+    string,
+    Deferred.Deferred<
+      Effect.Success<ReturnType<typeof executeTask>>,
+      Effect.Error<ReturnType<typeof executeTask>>
+    >
+  >,
+  taskName: string,
+) {
+  const existingResultDeferred = resultDeferreds.get(taskName);
+  if (existingResultDeferred !== undefined) {
+    return existingResultDeferred;
+  }
+  taskRunsState.createRecord(taskName);
+  const resultDeferred: Parameters<typeof resultDeferreds.set>[1] = Deferred.makeUnsafe();
+  resultDeferreds.set(taskName, resultDeferred);
+  yield* FiberSet.run(
+    taskRunsState.taskFibers,
+    executeTask(taskRunsState, taskName).pipe(
+      Effect.onExit((taskExit) => Deferred.done(resultDeferred, taskExit)),
+      Effect.withParentSpan(taskRunsState.runSpan),
+    ),
+  );
+  return resultDeferred;
+});
+
+const findDependencyPathToRequestingTask = (
+  taskRunsByName: ReadonlyMap<string, ReturnType<typeof makeTaskRun>>,
+  dependencyTaskName: string,
+  requestingTaskName: string,
+): readonly string[] | null => {
+  const visitedTaskNames = new Set<string>();
+  const findDependencyPath = (currentTaskName: string): readonly string[] | null => {
+    if (currentTaskName === requestingTaskName) {
+      return [currentTaskName];
+    }
+    if (visitedTaskNames.has(currentTaskName)) {
+      return null;
+    }
+
+    visitedTaskNames.add(currentTaskName);
+    for (const nextDependencyTaskName of taskRunsByName.get(currentTaskName)?.awaitedTaskNames ??
+      []) {
+      const remainingDependencyPath = findDependencyPath(nextDependencyTaskName);
+      if (remainingDependencyPath !== null) {
+        return [currentTaskName, ...remainingDependencyPath];
+      }
+    }
+    return null;
+  };
+  return findDependencyPath(dependencyTaskName);
+};
+
+export const runRequestedTask = Effect.fn("runRequestedTask")(function* (
+  taskRunsState: Effect.Success<typeof makeTaskRunsState>,
+  resultDeferreds: Parameters<typeof runTaskOnce>[1],
+  taskName: string,
+) {
+  yield* Effect.annotateCurrentSpan(`${TASK_TRACE_LABEL_PREFIX}.task`, taskName);
+  if (!taskRunsState.discoveredTasksByName.has(taskName)) {
+    return yield* requestedTaskNotDiscovered(taskName, taskName);
+  }
+  const resultDeferred = yield* runTaskOnce(taskRunsState, resultDeferreds, taskName);
+  return yield* Deferred.await(resultDeferred);
+});
+
+export const runRequestedDependencyTask = Effect.fn("runRequestedDependencyTask")(function* (
+  taskRunsState: Effect.Success<typeof makeTaskRunsState>,
+  resultDeferreds: Parameters<typeof runTaskOnce>[1],
+  dependencyTaskName: string,
+  requestingTaskName: string,
+) {
+  yield* Effect.annotateCurrentSpan({
+    [`${TASK_TRACE_LABEL_PREFIX}.task`]: dependencyTaskName,
+    [`${TASK_TRACE_LABEL_PREFIX}.requested_by`]: requestingTaskName,
+  });
+  if (!taskRunsState.discoveredTasksByName.has(dependencyTaskName)) {
+    return yield* requestedTaskNotDiscovered(dependencyTaskName, requestingTaskName);
+  }
+  const existingResultDeferred = resultDeferreds.get(dependencyTaskName);
+  const isTaskRunInProgress =
+    existingResultDeferred !== undefined && !Deferred.isDoneUnsafe(existingResultDeferred);
+  if (isTaskRunInProgress) {
+    const dependencyCycle = findDependencyPathToRequestingTask(
+      taskRunsState.runsByTaskName,
+      dependencyTaskName,
+      requestingTaskName,
+    );
+    if (dependencyCycle !== null) {
+      return yield* new TaskWaitsOnItself({
+        taskName: requestingTaskName,
+        cycle: [requestingTaskName, ...dependencyCycle],
+      });
+    }
+  }
+  const requestingTaskDependencies =
+    taskRunsState.runsByTaskName.get(requestingTaskName)?.awaitedTaskNames;
+  requestingTaskDependencies?.push(dependencyTaskName);
+  const awaitedResultDeferred = yield* runTaskOnce(
+    taskRunsState,
+    resultDeferreds,
+    dependencyTaskName,
+  );
+  return yield* Deferred.await(awaitedResultDeferred).pipe(
+    Effect.map((result) => structuredClone(result)),
+    Effect.mapError(() => new AwaitedTaskFailed({ awaitedTaskName: dependencyTaskName })),
+    Effect.ensuring(
+      Effect.sync(() => {
+        if (requestingTaskDependencies === undefined) {
+          return;
+        }
+        requestingTaskDependencies.splice(
+          requestingTaskDependencies.indexOf(dependencyTaskName),
+          1,
+        );
+      }),
+    ),
+  );
+});