@wichayutdew/pi-workflows 2.0.1 → 2.2.0

package/src/engine/gate-transitions.ts

@@ -1,9 +1,34 @@
 import type { LoadedWorkflow } from '../config/types.ts';
 import { advanceRun } from './run-advance.ts';
 import { recordCurrentGateDecision } from './step-trace.ts';
-import type { GateResolution, WorkflowRun } from './state-types.ts';
+import {
+  MAX_GATE_FEEDBACK_CHARS,
+  type GateResolution,
+  type WorkflowRun,
+} from './state-types.ts';
 import { currentStep, withRunUpdate } from './transition-helpers.ts';
 
+const GATE_FEEDBACK_TRUNCATION_SUFFIX =
+  '\n… [gate feedback truncated by Pi Workflows]';
+const MAX_GATE_REJECTION_SUMMARY_CHARS = 500;
+
+const boundedGateFeedback = (feedback: string): string =>
+  feedback.length <= MAX_GATE_FEEDBACK_CHARS
+    ? feedback
+    : `${feedback.slice(
+        0,
+        MAX_GATE_FEEDBACK_CHARS - GATE_FEEDBACK_TRUNCATION_SUFFIX.length,
+      )}${GATE_FEEDBACK_TRUNCATION_SUFFIX}`;
+
+const gateRejectionSummary = (feedback: string): string => {
+  const compact = feedback.trim().replace(/\s+/g, ' ');
+  if (!compact) return 'Gate rejected';
+  const summary = `Gate rejected: ${compact}`;
+  return summary.length <= MAX_GATE_REJECTION_SUMMARY_CHARS
+    ? summary
+    : `${summary.slice(0, MAX_GATE_REJECTION_SUMMARY_CHARS - 1)}…`;
+};
+
 /**
  * Begins human review for a gated workflow step.
  *
@@ -101,21 +126,22 @@ export const failGate = (
   run: WorkflowRun,
   reason: string,
   now: number,
-): WorkflowRun =>
-  run.pendingGate
-    ? withRunUpdate(
-        run,
-        {
-          status: 'running',
-          pendingGate: undefined,
-          gateFeedback: reason,
-          pausedFrom: undefined,
-          pauseReason: undefined,
-          failedStepId: undefined,
-        },
-        now,
-      )
-    : run;
+): WorkflowRun => {
+  if (!run.pendingGate) return run;
+  return withRunUpdate(
+    run,
+    {
+      status: 'running',
+      pendingGate: undefined,
+      gateArtifact: run.pendingGate.artifact,
+      gateFeedback: boundedGateFeedback(reason),
+      pausedFrom: undefined,
+      pauseReason: undefined,
+      failedStepId: undefined,
+    },
+    now,
+  );
+};
 
 /**
  * Stores a gate resolution without advancing the workflow.
@@ -129,14 +155,22 @@ export const storeGateResolution = (
   run: WorkflowRun,
   resolution: GateResolution,
   now: number,
-): WorkflowRun =>
-  run.pendingGate
-    ? withRunUpdate(
-        run,
-        { pendingGate: { ...run.pendingGate, resolution } },
-        now,
-      )
-    : run;
+): WorkflowRun => {
+  if (!run.pendingGate) return run;
+  return withRunUpdate(
+    run,
+    {
+      pendingGate: {
+        ...run.pendingGate,
+        resolution: {
+          ...resolution,
+          feedback: boundedGateFeedback(resolution.feedback),
+        },
+      },
+    },
+    now,
+  );
+};
 
 /**
  * Applies a human gate decision and follows its configured transition.
@@ -168,6 +202,7 @@ export const resolveGate = (
   const outcome = resolution.approved
     ? step.gate.approvedOutcome
     : step.gate.rejectedOutcome;
+  const feedback = boundedGateFeedback(resolution.feedback);
   const stepStructuralDigest =
     workflow.stepStructuralDigests[pendingGate.stepId] ?? '';
   if (resolution.approved && !stepStructuralDigest) {
@@ -177,16 +212,14 @@ export const resolveGate = (
   }
   const summary = resolution.approved
     ? (pendingGate.summary ?? '')
-    : resolution.feedback
-      ? `Gate rejected: ${resolution.feedback}`
-      : 'Gate rejected';
+    : gateRejectionSummary(feedback);
   const decidedRun = recordCurrentGateDecision(
     run,
     {
       provider: pendingGate.provider,
       requestId: pendingGate.requestId,
       approved: resolution.approved,
-      feedback: resolution.feedback,
+      feedback,
       resolvedAt: resolution.resolvedAt,
       ...(pendingGate.reviewId ? { reviewId: pendingGate.reviewId } : {}),
     },
@@ -199,11 +232,24 @@ export const resolveGate = (
       pendingGate: undefined,
       pausedFrom: undefined,
       pauseReason: undefined,
-      gateFeedback: resolution.feedback,
+      gateArtifact: resolution.approved ? '' : pendingGate.artifact,
+      gateFeedback: resolution.approved ? '' : feedback,
     },
     now,
   );
-  const advanced = advanceRun(workflow, runnableRun, outcome, summary, now);
+  const isSameStepHumanRevision =
+    !resolution.approved && step.transitions[outcome] === pendingGate.stepId;
+  const advanced = advanceRun(
+    workflow,
+    runnableRun,
+    outcome,
+    summary,
+    now,
+    {},
+    {
+      sameStepHumanGateRevision: isSameStepHumanRevision,
+    },
+  );
   const completedApprovedGate =
     resolution.approved && advanced.history.length > runnableRun.history.length;
   const history = completedApprovedGate
@@ -215,7 +261,7 @@ export const resolveGate = (
               approval: {
                 requestId: pendingGate.requestId,
                 artifact: pendingGate.artifact,
-                feedback: resolution.feedback,
+                feedback,
                 stepStructuralDigest,
               },
             }
@@ -228,9 +274,10 @@ export const resolveGate = (
     ...(completedApprovedGate
       ? {
           reviewedArtifact: pendingGate.artifact,
-          reviewedFeedback: resolution.feedback,
+          reviewedFeedback: feedback,
         }
       : {}),
-    gateFeedback: resolution.feedback,
+    gateArtifact: resolution.approved ? '' : pendingGate.artifact,
+    gateFeedback: resolution.approved ? '' : feedback,
   };
 };

package/src/engine/run-advance.ts

@@ -7,6 +7,14 @@ export type RunStepEffects = {
   readonly workspaceCwd?: string | undefined;
 };
 
+export type RunAdvanceOptions = {
+  /**
+   * Marks an explicit human rejection back to the same gated step. This keeps
+   * the incoming handoff and bypasses the visit-limit check for this decision.
+   */
+  readonly sameStepHumanGateRevision?: boolean | undefined;
+};
+
 const completedStep = (
   run: WorkflowRun,
   outcome: string,
@@ -37,6 +45,7 @@ const completedStep = (
  * @param summary - Step handoff summary.
  * @param now - Update timestamp.
  * @param effects - Validated declarative effects accepted with this result.
+ * @param options - Internal graph-advancement controls.
  * @returns A new paused, running, or completed workflow state.
  * @throws When the run, outcome, current step, or transition target is invalid.
  */
@@ -47,6 +56,7 @@ export const advanceRun = (
   summary: string,
   now: number,
   effects: RunStepEffects = {},
+  options: RunAdvanceOptions = {},
 ): WorkflowRun => {
   if (run.status !== 'running') {
     throw new Error(
@@ -78,6 +88,15 @@ export const advanceRun = (
         : `outcome "${outcome}" cannot bind a workspace`,
     );
   }
+  if (
+    shouldBindWorkspace &&
+    run.restartWorkspaceCwd !== undefined &&
+    effects.workspaceCwd !== run.restartWorkspaceCwd
+  ) {
+    throw new Error(
+      `restarted workflow must rebind workspace "${run.restartWorkspaceCwd}"`,
+    );
+  }
   if (target === '$pause') {
     return withRunUpdate(
       run,
@@ -95,6 +114,11 @@ export const advanceRun = (
   const completed = completedStep(run, outcome, summary, now, effects);
   const cwd = effects.workspaceCwd ?? run.cwd;
   if (target === '$done') {
+    if (run.restartWorkspaceCwd !== undefined) {
+      throw new Error(
+        `restarted workflow completed before rebinding workspace "${run.restartWorkspaceCwd}"`,
+      );
+    }
     return withRunUpdate(
       run,
       {
@@ -103,8 +127,10 @@ export const advanceRun = (
         currentStepAttempts: undefined,
         currentStepOmittedAttempts: undefined,
         ...(cwd ? { cwd } : {}),
+        ...(effects.workspaceCwd ? { restartWorkspaceCwd: undefined } : {}),
         stepHandoff: summary,
         lastSummary: summary,
+        gateArtifact: '',
         gateFeedback: '',
         pausedFrom: undefined,
         pendingGate: undefined,
@@ -118,8 +144,13 @@ export const advanceRun = (
     throw new Error(`transition target "${target}" does not exist`);
   }
 
+  const preservesGateRevisionContext =
+    target === run.currentStepId &&
+    (options.sameStepHumanGateRevision || Boolean(run.gateArtifact));
   const nextVisitCount = (run.visits[target] ?? 0) + 1;
-  const isOverVisitLimit = nextVisitCount > workflow.definition.maxStepVisits;
+  const isOverVisitLimit =
+    !options.sameStepHumanGateRevision &&
+    nextVisitCount > workflow.definition.maxStepVisits;
   const visitLimitChanges: Partial<WorkflowRun> = isOverVisitLimit
     ? {
         status: 'paused',
@@ -145,9 +176,11 @@ export const advanceRun = (
       currentStepAttempts: undefined,
       currentStepOmittedAttempts: undefined,
       ...(cwd ? { cwd } : {}),
-      stepHandoff: summary,
+      ...(effects.workspaceCwd ? { restartWorkspaceCwd: undefined } : {}),
+      stepHandoff: preservesGateRevisionContext ? run.stepHandoff : summary,
       lastSummary: summary,
-      gateFeedback: '',
+      gateArtifact: preservesGateRevisionContext ? run.gateArtifact : '',
+      gateFeedback: preservesGateRevisionContext ? run.gateFeedback : '',
       resumeInput: undefined,
     },
     now,

package/src/engine/run-lifecycle.ts

@@ -1,7 +1,16 @@
 import type { LoadedWorkflow } from '../config/types.ts';
+import { createRun } from './create-run.ts';
 import type { WorkflowRun } from './state-types.ts';
 import { currentStep, withRunUpdate } from './transition-helpers.ts';
 
+const completedWorkspaceCwd = (run: WorkflowRun): string | undefined => {
+  for (let index = run.history.length - 1; index >= 0; index -= 1) {
+    const workspaceCwd = run.history[index]?.workspaceCwd;
+    if (workspaceCwd) return workspaceCwd;
+  }
+  return undefined;
+};
+
 /**
  * Lists outcomes the active step may submit directly.
  *
@@ -133,3 +142,63 @@ export const abortRun = (
     },
     now,
   );
+
+/**
+ * Starts another iteration of a completed workflow while retaining its stable
+ * run/worktree identity. The next workspace-binding result must reaffirm the
+ * previously selected workspace before the iteration can complete.
+ *
+ * @param workflow - Current loaded workflow definition.
+ * @param run - Completed iteration to restart.
+ * @param input - New request, or the prior request when no replacement was supplied.
+ * @param baselineTools - Tools available before the new iteration is isolated.
+ * @param now - Restart timestamp.
+ * @returns A fresh running state for the next iteration.
+ */
+export const restartRun = (
+  workflow: LoadedWorkflow,
+  run: WorkflowRun,
+  input: string,
+  baselineTools: ReadonlyArray<string>,
+  now: number,
+): WorkflowRun => {
+  if (run.status !== 'completed') {
+    throw new Error('only a completed workflow can be restarted');
+  }
+  if (!run.startCwd) {
+    throw new Error(
+      'the completed workflow has no captured start directory; start a new workflow instead',
+    );
+  }
+
+  const previousIteration = run.iteration ?? 1;
+  if (!Number.isSafeInteger(previousIteration) || previousIteration < 1) {
+    throw new Error('the completed workflow has an invalid iteration number');
+  }
+  if (previousIteration >= Number.MAX_SAFE_INTEGER) {
+    throw new Error('the workflow iteration limit has been reached');
+  }
+
+  const workspaceCwd = completedWorkspaceCwd(run);
+  if (workspaceCwd && run.cwd !== workspaceCwd) {
+    throw new Error(
+      'the completed workflow workspace does not match its recorded binding',
+    );
+  }
+
+  const restarted = createRun(
+    workflow,
+    input,
+    baselineTools,
+    run.runId,
+    now,
+    run.startCwd,
+    previousIteration + 1,
+  );
+  return {
+    ...restarted,
+    stepHandoff: run.lastSummary,
+    lastSummary: run.lastSummary,
+    ...(workspaceCwd ? { restartWorkspaceCwd: workspaceCwd } : {}),
+  };
+};

package/src/engine/run-reconciliation.ts

@@ -110,6 +110,7 @@ export const reconcileRun = (
           pausedFrom: 'running',
           failedStepId: undefined,
           pauseReason: `Configuration changed; restarted step "${restartedStep}"`,
+          gateArtifact: '',
           gateFeedback: '',
         },
         now,
@@ -127,6 +128,7 @@ export const reconcileRun = (
         pausedFrom: 'running',
         failedStepId: undefined,
         pauseReason: `Configuration changed; restarted step "${run.currentStepId}"`,
+        gateArtifact: '',
         gateFeedback: '',
       }
     : {};

package/src/engine/run-validation.ts

@@ -1,5 +1,6 @@
 import { isAbsolute, resolve } from 'node:path';
 import {
+  MAX_GATE_FEEDBACK_CHARS,
   MAX_RESUME_INPUT_CHARS,
   MAX_STEP_TRACE_ARTIFACT_CHARS,
   MAX_STEP_TRACE_ATTEMPTS,
@@ -40,6 +41,7 @@ const isGateApproval = (value: unknown): value is GateApproval =>
   typeof value.artifact === 'string' &&
   value.artifact.trim().length > 0 &&
   typeof value.feedback === 'string' &&
+  value.feedback.length <= MAX_GATE_FEEDBACK_CHARS &&
   typeof value.stepStructuralDigest === 'string' &&
   value.stepStructuralDigest.length > 0;
 
@@ -221,6 +223,7 @@ const isGateResolution = (value: unknown): value is GateResolution =>
   isRecord(value) &&
   typeof value.approved === 'boolean' &&
   typeof value.feedback === 'string' &&
+  value.feedback.length <= MAX_GATE_FEEDBACK_CHARS &&
   typeof value.resolvedAt === 'number';
 
 const isPendingGate = (value: unknown): value is PendingGate =>
@@ -250,6 +253,10 @@ const isOptionalResumeInput = (value: unknown): value is string | undefined =>
   value === undefined ||
   (typeof value === 'string' && value.length <= MAX_RESUME_INPUT_CHARS);
 
+const isOptionalIteration = (value: unknown): value is number | undefined =>
+  value === undefined ||
+  (Number.isSafeInteger(value) && (value as number) >= 1);
+
 const isWorkflowRunStatus = (value: unknown): value is WorkflowRunStatus =>
   value === 'running' ||
   value === 'paused' ||
@@ -333,13 +340,20 @@ export const isWorkflowRun = (value: unknown): value is WorkflowRun => {
     typeof value.startedAt === 'number' &&
     typeof value.updatedAt === 'number' &&
     typeof value.lastSummary === 'string' &&
-    typeof value.gateFeedback === 'string';
+    typeof value.gateFeedback === 'string' &&
+    value.gateFeedback.length <= MAX_GATE_FEEDBACK_CHARS;
   if (!hasValidRequiredFields) return false;
 
   const hasValidOptionalFields =
+    isOptionalIteration(value.iteration) &&
     isOptionalString(value.reviewedArtifact) &&
     isOptionalString(value.reviewedFeedback) &&
+    (typeof value.reviewedFeedback !== 'string' ||
+      value.reviewedFeedback.length <= MAX_GATE_FEEDBACK_CHARS) &&
     isOptionalString(value.stepHandoff) &&
+    isOptionalString(value.gateArtifact) &&
+    (value.restartWorkspaceCwd === undefined ||
+      isAbsoluteCwd(value.restartWorkspaceCwd)) &&
     isOptionalResumeInput(value.resumeInput) &&
     isOptionalString(value.pauseReason) &&
     isOptionalString(value.failedStepId) &&
@@ -351,6 +365,15 @@ export const isWorkflowRun = (value: unknown): value is WorkflowRun => {
   const pendingGate = value.pendingGate;
   if (pendingGate !== undefined && !isPendingGate(pendingGate)) return false;
 
+  if (
+    value.restartWorkspaceCwd !== undefined &&
+    (value.history as ReadonlyArray<StepHistoryEntry>).some(
+      (entry) => entry.workspaceCwd !== undefined,
+    )
+  ) {
+    return false;
+  }
+
   return (
     workflowTraceChars(value as WorkflowRun) <= MAX_WORKFLOW_TRACE_CHARS &&
     hasValidWorkspaceState(

package/src/engine/state-types.ts

@@ -1,4 +1,5 @@
 export const RUN_STATE_VERSION = 1 as const;
+export const MAX_GATE_FEEDBACK_CHARS = 50_000;
 export const MAX_RESUME_INPUT_CHARS = 16_000;
 export const MAX_STEP_TRACE_TASK_CHARS = 64_000;
 export const MAX_STEP_TRACE_ATTEMPTS = 16;
@@ -124,6 +125,8 @@ export type PendingGate = {
 
 export type WorkflowRun = {
   readonly stateVersion: typeof RUN_STATE_VERSION;
+  /** One-based attempt number within a restartable workflow/worktree lineage. */
+  readonly iteration?: number | undefined;
   readonly runId: string;
   readonly workflowId: string;
   readonly workflowDigest: string;
@@ -152,12 +155,19 @@ export type WorkflowRun = {
   readonly startCwd?: string | undefined;
   /** Current canonical execution directory for delegated workflow steps. */
   readonly cwd?: string | undefined;
+  /**
+   * Exact workspace that a restarted iteration must bind before it can finish.
+   * This prevents a missing prior worktree from being silently replaced.
+   */
+  readonly restartWorkspaceCwd?: string | undefined;
   /**
    * Input inherited from the previous completed step. Unlike `lastSummary`,
    * this survives a paused attempt of the current step.
    */
   readonly stepHandoff?: string | undefined;
   readonly lastSummary: string;
+  /** Opaque artifact returned by the latest rejected or failed gate. */
+  readonly gateArtifact?: string | undefined;
   readonly gateFeedback: string;
   /** User-authored guidance supplied for the current resume attempt. */
   readonly resumeInput?: string | undefined;

package/src/engine/state.ts

@@ -1,6 +1,7 @@
 export { createRun } from './create-run.ts';
 export { isWorkflowRun } from './run-validation.ts';
 export {
+  MAX_GATE_FEEDBACK_CHARS,
   MAX_RESUME_INPUT_CHARS,
   MAX_STEP_TRACE_ATTEMPTS,
   MAX_STEP_TRACE_LOG_CHARS,

package/src/engine/transitions.ts

@@ -11,6 +11,7 @@ export {
   allowedOutcomes,
   failRun,
   pauseRun,
+  restartRun,
   resumeRun,
   setResumeInput,
 } from './run-lifecycle.ts';

package/src/harness/action-context.ts

@@ -77,6 +77,12 @@ export type HarnessActionContext = {
     startContext: WorkflowStartContext,
     sessionEpoch: number,
   ) => Promise<void>;
+  restart: (input: string, context: ExtensionCommandContext) => Promise<void>;
+  restartNow: (
+    input: string,
+    startContext: WorkflowStartContext,
+    sessionEpoch: number,
+  ) => Promise<void>;
   pause: (reason: string, context: ExtensionCommandContext) => Promise<void>;
   pauseNow: (reason: string, context: ExtensionCommandContext) => Promise<void>;
   resume: (input: string, context: ExtensionCommandContext) => Promise<void>;

package/src/harness/core-actions.ts

@@ -190,6 +190,8 @@ function enqueueMutation(
 function persist(this: HarnessActionContext): void {
   if (this.run) {
     this.pi.appendEntry(STATE_ENTRY_TYPE, structuredClone(this.run));
+    const session = this.latestContext?.sessionManager;
+    if (session) this.dependencies.flushUnwrittenSession(session);
   }
 }
 

package/src/harness/dependencies.ts

@@ -33,6 +33,7 @@ import {
   resolveWorkspaceDirectory,
   type ResolveWorkspaceDirectoryOptions,
 } from './workspace-directory.ts';
+import { flushUnwrittenSession } from './session-persistence.ts';
 
 const MAX_DELEGATED_RESULT_BYTES = 1024 * 1024;
 
@@ -71,6 +72,8 @@ export type WorkflowHarnessDependencies = {
     pi: ExtensionAPI,
   ) => MainStepRuntimeController;
   readonly createMutationQueue: () => SerialTaskQueueController;
+  /** Makes a new Pi session durable before its first assistant message. */
+  readonly flushUnwrittenSession: typeof flushUnwrittenSession;
   readonly scheduleInterval: (
     operation: () => void,
     intervalMs: number,
@@ -154,6 +157,7 @@ const DEFAULT_DEPENDENCIES: WorkflowHarnessDependencies = {
   createSubagentClient: (pi) => createSubagentDelegationClient(pi.events),
   createMainStepRuntime: (pi) => createMainStepRuntime({ pi }),
   createMutationQueue: createSerialTaskQueue,
+  flushUnwrittenSession,
   scheduleInterval: (operation, intervalMs) =>
     setInterval(operation, intervalMs),
   cancelInterval: (timer) => {

package/src/harness/lifecycle-actions.ts

@@ -107,9 +107,22 @@ function registerLifecycle(this: HarnessActionContext): void {
     this.isSessionActive = true;
   });
 
-  this.pi.on('session_shutdown', async () => {
+  this.pi.on('session_shutdown', async (_event, context) => {
     this.sessionEpoch += 1;
     this.isSessionActive = false;
+    if (this.run) {
+      this.latestContext = context;
+      try {
+        this.persist();
+      } catch (error) {
+        context.ui.notify(
+          `Workflow checkpoint could not be saved before shutdown: ${
+            error instanceof Error ? error.message : String(error)
+          }`,
+          'error',
+        );
+      }
+    }
     this.cancelPromptReview();
     this.mainSteps.deactivate();
     await this.cancelActiveDelegation('Pi session shut down');

package/src/harness/session-persistence.ts

@@ -0,0 +1,66 @@
+import { existsSync, writeFileSync } from 'node:fs';
+import type {
+  ExtensionContext,
+  SessionManager,
+} from '@earendil-works/pi-coding-agent';
+
+type SessionSnapshot = Pick<
+  ExtensionContext['sessionManager'],
+  'getEntries' | 'getHeader' | 'getSessionFile'
+>;
+
+type AdoptableSessionSnapshot = SessionSnapshot &
+  Pick<SessionManager, 'setSessionFile'>;
+
+const isAlreadyPersisted = (error: unknown): boolean =>
+  error instanceof Error && 'code' in error && error.code === 'EEXIST';
+
+function getAdoptableSession(
+  session: SessionSnapshot,
+): AdoptableSessionSnapshot {
+  const adoptable = session as Partial<AdoptableSessionSnapshot>;
+  if (typeof adoptable.setSessionFile !== 'function') {
+    throw new Error(
+      'This Pi runtime cannot adopt a materialized workflow session file',
+    );
+  }
+  return adoptable as AdoptableSessionSnapshot;
+}
+
+/**
+ * Materializes a Pi session before its first regular assistant message.
+ *
+ * Pi defers creating a new session file until it records a regular assistant
+ * message. A workflow made entirely of delegated steps can therefore have
+ * checkpoint entries in memory but no file to reopen. After creating a public
+ * session snapshot, this re-adopts the same file through Pi's public
+ * `SessionManager#setSessionFile` method. That marks the running manager as
+ * flushed, allowing Pi to append future custom and assistant entries normally.
+ *
+ * @param session - Public snapshot view supplied by Pi's extension context.
+ * @returns `true` when this call created the session file.
+ */
+export function flushUnwrittenSession(session: SessionSnapshot): boolean {
+  const sessionFile = session.getSessionFile();
+  const header = session.getHeader();
+  if (!sessionFile || !header) return false;
+  if (existsSync(sessionFile)) return false;
+  const adoptable = getAdoptableSession(session);
+
+  const serialized = [header, ...session.getEntries()]
+    .map((entry) => JSON.stringify(entry))
+    .join('\n');
+
+  try {
+    writeFileSync(sessionFile, `${serialized}\n`, {
+      encoding: 'utf8',
+      flag: 'wx',
+      mode: 0o600,
+    });
+    adoptable.setSessionFile(sessionFile);
+    return true;
+  } catch (error) {
+    if (isAlreadyPersisted(error)) return false;
+    throw error;
+  }
+}