@ai-sdk/harness 1.0.124 → 1.0.126

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/harness",
-  "version": "1.0.124",
+  "version": "1.0.126",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -45,8 +45,8 @@
   },
   "dependencies": {
     "@ai-sdk/provider": "4.0.18",
-    "@ai-sdk/provider-utils": "5.0.47",
-    "ai": "7.0.114"
+    "@ai-sdk/provider-utils": "5.0.49",
+    "ai": "7.0.116"
   },
   "peerDependencies": {
     "ws": "^8.21.0",
@@ -58,7 +58,7 @@
     }
   },
   "devDependencies": {
-    "@ai-sdk/otel": "1.0.114",
+    "@ai-sdk/otel": "1.0.116",
     "@opentelemetry/sdk-trace-base": "2.7.1",
     "@types/node": "22.19.19",
     "@types/ws": "^8.5.13",

package/src/agent/create-harness-sandbox-template.ts

@@ -0,0 +1,80 @@
+import type {
+  HarnessAgentAdapter,
+  HarnessSandboxTemplate,
+} from './harness-agent-types';
+import type { HarnessAgentSandboxConfig } from './harness-agent-settings';
+import { hashHarnessBootstrap } from './internal/bootstrap-recipe';
+import { resolvePreparedSandboxIdentity } from './internal/prepared-sandbox-identity';
+import {
+  normalizeSandboxWorkDir,
+  runSandboxBootstrap,
+  validateSandboxBootstrapSettings,
+} from './internal/sandbox-bootstrap';
+
+export async function createHarnessSandboxTemplate(options: {
+  readonly harnesses: ReadonlyArray<HarnessAgentAdapter>;
+  readonly sandboxConfig?: Omit<HarnessAgentSandboxConfig, 'onSession'>;
+}): Promise<HarnessSandboxTemplate | undefined> {
+  if (options.harnesses.length === 0) {
+    throw new Error(
+      'createHarnessSandboxTemplate: at least one harness must be provided.',
+    );
+  }
+  const settings = options.sandboxConfig ?? {};
+  validateSandboxBootstrapSettings(settings);
+  const workDir =
+    settings.workDir == null
+      ? undefined
+      : normalizeSandboxWorkDir(settings.workDir);
+  const harnesses = [
+    ...new Map(
+      options.harnesses.map(harness => [harness.harnessId, harness]),
+    ).values(),
+  ].sort((a, b) => a.harnessId.localeCompare(b.harnessId));
+  const recipes = await Promise.all(
+    harnesses.map(async harness => {
+      const recipe = await harness.getBootstrap?.({});
+      return recipe == null
+        ? undefined
+        : {
+            recipe,
+            identity: await hashHarnessBootstrap(recipe),
+          };
+    }),
+  );
+  const recipeIdentities: Record<string, string> = {};
+  for (let index = 0; index < harnesses.length; index++) {
+    const entry = recipes[index];
+    if (entry != null)
+      recipeIdentities[harnesses[index].harnessId] = entry.identity;
+  }
+  const identity = await resolvePreparedSandboxIdentity({
+    recipeIdentities,
+    bootstrapHash: settings.bootstrapHash,
+    workDir,
+  });
+  if (identity == null) return undefined;
+  return {
+    identity,
+    prepare: async ({ session, abortSignal }) => {
+      for (const entry of recipes) {
+        if (entry != null) {
+          await runSandboxBootstrap({
+            session,
+            recipe: entry.recipe,
+            recipeIdentity: entry.identity,
+            abortSignal,
+          });
+        }
+      }
+      await runSandboxBootstrap({
+        session,
+        workDir,
+        onBootstrap: settings.onBootstrap,
+        bootstrapHash: settings.bootstrapHash,
+        skipOnBootstrapIfMarked: true,
+        abortSignal,
+      });
+    },
+  };
+}

package/src/agent/harness-agent-settings.ts

@@ -356,6 +356,7 @@ export type HarnessAgentSettings<
    * sessions. When omitted, every `createSession()` call must provide an
    * existing network sandbox session.
    */
+  /** @deprecated Supply `sandboxSession` to `HarnessAgent.createSession()` instead. */
   readonly sandbox?: HarnessV1SandboxProvider;
 
   /**

package/src/agent/harness-agent-types.ts

@@ -15,6 +15,7 @@ import type {
   HarnessV1PromptControl,
   HarnessV1PromptTurnOptions,
   HarnessV1ResumeSessionState,
+  HarnessV1SandboxTemplate,
   HarnessV1Session,
   HarnessV1Skill,
   HarnessV1StartOptions,
@@ -24,6 +25,7 @@ import type {
 
 export type HarnessAgentAdapter<TBuiltinTools extends ToolSet = ToolSet> =
   HarnessV1<TBuiltinTools>;
+export type HarnessSandboxTemplate = HarnessV1SandboxTemplate;
 
 export type HarnessAgentBuiltinTool<
   INPUT = unknown,

package/src/agent/harness-agent.ts

@@ -48,6 +48,7 @@ import type {
   HarnessAgentResumeSessionState,
   HarnessAgentSkill,
   HarnessAgentToolSpec,
+  HarnessSandboxTemplate,
 } from './harness-agent-types';
 import { collectHarnessAgentToolApprovalContinuations } from './harness-agent-tool-approval-continuation';
 import { collectHarnessAgentToolResultContinuations } from './harness-agent-tool-result-continuation';
@@ -59,6 +60,7 @@ import {
   createSandboxBootstrapPlan,
   ensureSandboxDirectory,
   resolveSessionWorkDir,
+  runSandboxBootstrap,
   validateSandboxBootstrapSettings,
 } from './internal/sandbox-bootstrap';
 import { buildObservability } from './internal/resolve-observability';
@@ -72,6 +74,7 @@ import { resolveSandboxDefaultWorkingDirectory } from '../utils/resolve-sandbox-
 import { resolveSandboxHomeDir } from '../utils/sandbox-home-dir';
 import { getRestrictedSandboxSession } from '../utils/get-restricted-sandbox-session';
 import type { HarnessAgentLifecycleCallbacks } from './internal/turn-telemetry';
+import { createHarnessSandboxTemplate } from './create-harness-sandbox-template';
 
 export type { HarnessAllTools } from './harness-agent-tool-types';
 
@@ -222,6 +225,11 @@ export class HarnessAgent<
       CALL_OPTIONS
     >,
   ) {
+    if (settings.sandbox != null) {
+      console.warn(
+        'HarnessAgent: `sandbox` is deprecated. Supply `sandboxSession` to createSession() instead.',
+      );
+    }
     const sandboxConfig = resolveSandboxConfig(settings);
     validateSandboxBootstrapSettings(sandboxConfig);
     this.settings = settings;
@@ -290,6 +298,13 @@ export class HarnessAgent<
     return this.settings.output != null;
   }
 
+  getSandboxTemplate(): Promise<HarnessSandboxTemplate | undefined> {
+    return createHarnessSandboxTemplate({
+      harnesses: [this.settings.harness],
+      sandboxConfig: this.sandboxConfig,
+    });
+  }
+
   /**
    * Start a fresh session, or resume from state previously returned by
    * `session.detach()` or `session.stop()`. The returned
@@ -540,6 +555,14 @@ export class HarnessAgent<
     }
 
     try {
+      await runSandboxBootstrap({
+        session: getRestrictedSandboxSession(sandboxSession),
+        workDir: this.sandboxConfig.workDir,
+        onBootstrap: this.sandboxConfig.onBootstrap,
+        bootstrapHash: this.sandboxConfig.bootstrapHash,
+        skipOnBootstrapIfMarked: true,
+        abortSignal,
+      });
       await ensureSandboxDirectory({
         session: sandboxSession,
         workDir: sessionWorkDir,

package/src/agent/internal/on-bootstrap-marker.ts

@@ -0,0 +1,70 @@
+import { posix } from 'node:path';
+import type { Experimental_SandboxSession as SandboxSession } from '@ai-sdk/provider-utils';
+import { harnessStateDirectoryPath } from '../../v1';
+import { resolveSandboxHomeDir } from '../../utils/sandbox-home-dir';
+
+export async function onBootstrapMarkerPath({
+  session,
+  bootstrapHash,
+  abortSignal,
+}: {
+  session: SandboxSession;
+  bootstrapHash: string;
+  abortSignal?: AbortSignal;
+}): Promise<string> {
+  const digest = new Uint8Array(
+    await crypto.subtle.digest(
+      'SHA-256',
+      new TextEncoder().encode(bootstrapHash),
+    ),
+  );
+  const filename = Array.from(digest, byte =>
+    byte.toString(16).padStart(2, '0'),
+  ).join('');
+  return posix.join(
+    harnessStateDirectoryPath({
+      sandboxHomeDir: await resolveSandboxHomeDir({
+        sandbox: session,
+        abortSignal,
+      }),
+    }),
+    '.on-bootstrap',
+    `${filename}.ok`,
+  );
+}
+
+export async function hasOnBootstrapMarker(options: {
+  session: SandboxSession;
+  bootstrapHash: string;
+  abortSignal?: AbortSignal;
+}): Promise<boolean> {
+  return (
+    (await options.session.readTextFile({
+      path: await onBootstrapMarkerPath(options),
+      abortSignal: options.abortSignal,
+    })) !== null
+  );
+}
+
+export async function writeOnBootstrapMarker(options: {
+  session: SandboxSession;
+  bootstrapHash: string;
+  abortSignal?: AbortSignal;
+}): Promise<void> {
+  const path = await onBootstrapMarkerPath(options);
+  const result = await options.session.run({
+    command: 'mkdir -p "$MARKER_DIR"',
+    env: { MARKER_DIR: posix.dirname(path) },
+    abortSignal: options.abortSignal,
+  });
+  if (result.exitCode !== 0) {
+    throw new Error(
+      `Failed to create onBootstrap marker directory: ${result.stderr || result.stdout}`,
+    );
+  }
+  await options.session.writeTextFile({
+    path,
+    content: '',
+    abortSignal: options.abortSignal,
+  });
+}

package/src/agent/internal/prepared-sandbox-identity.ts

@@ -0,0 +1,42 @@
+const PREPARED_SANDBOX_IDENTITY_VERSION = 1;
+
+export async function resolvePreparedSandboxIdentity({
+  recipeIdentities,
+  bootstrapHash,
+  workDir,
+}: {
+  readonly recipeIdentities: Record<string, string>;
+  readonly bootstrapHash?: string;
+  readonly workDir?: string;
+}): Promise<string | undefined> {
+  const entries = Object.entries(recipeIdentities).sort(([a], [b]) =>
+    a.localeCompare(b),
+  );
+  if (entries.length === 0 && bootstrapHash == null) return undefined;
+
+  const encoder = new TextEncoder();
+  const chunks: Uint8Array[] = [];
+  const pushString = (value: string) => {
+    chunks.push(encoder.encode(value));
+    chunks.push(encoder.encode('\0'));
+  };
+  pushString(String(PREPARED_SANDBOX_IDENTITY_VERSION));
+  pushString(workDir ?? '');
+  pushString(bootstrapHash ?? '');
+  for (const [harnessId, identity] of entries) {
+    pushString(harnessId);
+    pushString(identity);
+  }
+  const buffer = new Uint8Array(
+    chunks.reduce((sum, chunk) => sum + chunk.length, 0),
+  );
+  let offset = 0;
+  for (const chunk of chunks) {
+    buffer.set(chunk, offset);
+    offset += chunk.length;
+  }
+  const digest = new Uint8Array(await crypto.subtle.digest('SHA-256', buffer));
+  return Array.from(digest.slice(0, 8), byte =>
+    byte.toString(16).padStart(2, '0'),
+  ).join('');
+}

package/src/agent/internal/sandbox-bootstrap.ts

@@ -6,6 +6,10 @@ import { resolveSandboxDefaultWorkingDirectory } from '../../utils/resolve-sandb
 import { resolveSandboxHomeDir } from '../../utils/sandbox-home-dir';
 import type { HarnessAgentSandboxConfig } from '../harness-agent-settings';
 import { applyBootstrapRecipe, hashHarnessBootstrap } from './bootstrap-recipe';
+import {
+  hasOnBootstrapMarker,
+  writeOnBootstrapMarker,
+} from './on-bootstrap-marker';
 
 const SANDBOX_BOOTSTRAP_IDENTITY_VERSION = 1;
 
@@ -125,6 +129,7 @@ export async function createSandboxBootstrapPlan({
               recipeIdentity,
               workDir,
               onBootstrap: settings.onBootstrap,
+              bootstrapHash: settings.bootstrapHash,
               abortSignal: opts.abortSignal,
             }),
         }
@@ -138,6 +143,8 @@ export async function runSandboxBootstrap({
   recipeIdentity,
   workDir,
   onBootstrap,
+  bootstrapHash,
+  skipOnBootstrapIfMarked = false,
   defaultWorkingDirectory,
   abortSignal,
 }: {
@@ -146,6 +153,8 @@ export async function runSandboxBootstrap({
   readonly recipeIdentity?: string;
   readonly workDir?: string;
   readonly onBootstrap?: SandboxBootstrapSettings['onBootstrap'];
+  readonly bootstrapHash?: string;
+  readonly skipOnBootstrapIfMarked?: boolean;
   readonly defaultWorkingDirectory?: string;
   readonly abortSignal?: AbortSignal;
 }): Promise<void> {
@@ -173,6 +182,13 @@ export async function runSandboxBootstrap({
 
   if (onBootstrap == null) return;
 
+  if (
+    skipOnBootstrapIfMarked &&
+    bootstrapHash != null &&
+    (await hasOnBootstrapMarker({ session, bootstrapHash, abortSignal }))
+  )
+    return;
+
   const resolvedDefaultWorkingDirectory =
     defaultWorkingDirectory ??
     (await resolveSandboxDefaultWorkingDirectory({
@@ -194,6 +210,9 @@ export async function runSandboxBootstrap({
     abortSignal,
   });
   await onBootstrap({ session, workDir: bootstrapWorkDir, abortSignal });
+  if (bootstrapHash != null) {
+    await writeOnBootstrapMarker({ session, bootstrapHash, abortSignal });
+  }
 }
 
 export async function ensureSandboxDirectory({

package/src/agent/prepare-harness-sandbox-template.ts

@@ -25,8 +25,8 @@ type SandboxBootstrapSettings = Omit<HarnessAgentSandboxConfig, 'onSession'>;
  *
  * The temporary network sandbox session created during preparation is stopped
  * before the function resolves; the snapshot/template state persists in the
- * provider's native storage (for Vercel: as the `currentSnapshotId` of the
- * named template sandbox).
+ * provider's native storage.
+ * @deprecated Use `createHarnessSandboxTemplate` and pass its template to a sandbox session creator instead.
  */
 export async function prepareHarnessSandboxTemplate(options: {
   readonly harness: HarnessAgentAdapter;
@@ -34,6 +34,9 @@ export async function prepareHarnessSandboxTemplate(options: {
   readonly sandboxConfig?: SandboxBootstrapSettings;
   readonly abortSignal?: AbortSignal;
 }): Promise<void> {
+  console.warn(
+    'prepareHarnessSandboxTemplate (prewarmHarness) is deprecated. Use createHarnessSandboxTemplate and a sandbox session creator instead.',
+  );
   const sandboxConfig = options.sandboxConfig ?? {};
   validateSandboxBootstrapSettings(sandboxConfig);
 

package/src/agent/prepare-sandbox-for-harness.ts

@@ -13,9 +13,9 @@ import {
   runSandboxBootstrap,
   validateSandboxBootstrapSettings,
 } from './internal/sandbox-bootstrap';
+import { resolvePreparedSandboxIdentity } from './internal/prepared-sandbox-identity';
 
-const PREPARED_SANDBOX_IDENTITY_VERSION = 1;
-
+/** @deprecated Use `createHarnessSandboxTemplate` and `template.prepare` instead. */
 export type PrepareSandboxForHarnessResult = {
   readonly identity?: string;
   readonly recipeIdentities: Record<string, string>;
@@ -41,6 +41,7 @@ export type PrepareSandboxForHarnessResult = {
  *
  * Repeated harness IDs are prepared once. When multiple adapters use the same
  * ID, the last adapter in `harnesses` is used.
+ * @deprecated Use `createHarnessSandboxTemplate` and `template.prepare` instead.
  */
 export async function prepareSandboxForHarness(options: {
   readonly session: SandboxSession;
@@ -48,6 +49,9 @@ export async function prepareSandboxForHarness(options: {
   readonly sandboxConfig?: HarnessAgentSandboxConfig;
   readonly abortSignal?: AbortSignal;
 }): Promise<PrepareSandboxForHarnessResult> {
+  console.warn(
+    'prepareSandboxForHarness is deprecated. Use createHarnessSandboxTemplate and template.prepare instead.',
+  );
   const sandboxConfig = options.sandboxConfig ?? {};
   validateSandboxBootstrapSettings(sandboxConfig);
 
@@ -107,6 +111,7 @@ export async function prepareSandboxForHarness(options: {
       session: options.session,
       workDir,
       onBootstrap: sandboxConfig.onBootstrap,
+      bootstrapHash: sandboxConfig.bootstrapHash,
       defaultWorkingDirectory,
       abortSignal: options.abortSignal,
     });
@@ -124,52 +129,3 @@ export async function prepareSandboxForHarness(options: {
     skippedHarnessIds,
   };
 }
-
-async function resolvePreparedSandboxIdentity({
-  recipeIdentities,
-  bootstrapHash,
-  workDir,
-}: {
-  readonly recipeIdentities: Record<string, string>;
-  readonly bootstrapHash?: string;
-  readonly workDir?: string;
-}): Promise<string | undefined> {
-  const entries = Object.entries(recipeIdentities).sort(([a], [b]) =>
-    a.localeCompare(b),
-  );
-  if (entries.length === 0 && bootstrapHash == null) {
-    return undefined;
-  }
-
-  const encoder = new TextEncoder();
-  const chunks: Uint8Array[] = [];
-  const pushString = (value: string) => {
-    chunks.push(encoder.encode(value));
-    chunks.push(encoder.encode('\0'));
-  };
-
-  pushString(String(PREPARED_SANDBOX_IDENTITY_VERSION));
-  pushString(workDir ?? '');
-  pushString(bootstrapHash ?? '');
-
-  for (const [harnessId, identity] of entries) {
-    pushString(harnessId);
-    pushString(identity);
-  }
-
-  const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
-  const buffer = new Uint8Array(totalLength);
-  let offset = 0;
-  for (const chunk of chunks) {
-    buffer.set(chunk, offset);
-    offset += chunk.length;
-  }
-
-  const digest = await crypto.subtle.digest('SHA-256', buffer);
-  const bytes = new Uint8Array(digest);
-  let hex = '';
-  for (let i = 0; i < 8; i++) {
-    hex += bytes[i].toString(16).padStart(2, '0');
-  }
-  return hex;
-}

package/src/v1/harness-v1-network-sandbox-session.ts

@@ -34,8 +34,8 @@ export function harnessStateDirectoryPath({
 }
 
 /**
- * Network sandbox session returned by `HarnessV1SandboxProvider.createSession()`. The
- * harness keeps this for the lifetime of a session. It is itself a
+ * Network sandbox session returned by sandbox adapter creation and resume
+ * functions. The harness keeps this for the lifetime of a session. It is itself a
  * {@link SandboxSession} (file I/O, exec, spawn) and adds the infra surface on
  * top: port resolution, lifecycle, and network-policy mutation.
  *
@@ -46,22 +46,15 @@ export function harnessStateDirectoryPath({
  */
 export interface HarnessV1NetworkSandboxSession extends SandboxSession {
   /**
-   * Stable identifier for the underlying sandbox resource. Used by the
-   * harness session manager as the durable lookup key for cross-process
-   * resume — the framework persists this on lifecycle state so a future
-   * process can call `HarnessV1SandboxProvider.resume?({ sessionId })` and
-   * reach the same resource. Providers populate it from their native
-   * identifier (Vercel: the sandbox name; just-bash: a UUID minted at
-   * create time).
+   * Identifier for the sandbox session. Persist this separately from the
+   * harness session ID and resume state when reattaching across processes.
    */
   readonly id: string;
 
   /**
    * The sandbox's default working directory — the absolute path that
    * `run`/`spawn` resolve relative commands against when no `workingDirectory`
-   * is given. Read from the live sandbox (it is provider-specific and
-   * configurable at create time: Vercel defaults to `/vercel/sandbox`,
-   * just-bash to `/home/user`), never hardcoded.
+   * is given. Read from the live sandbox, never hardcoded.
    *
    * The framework composes each session's working directory underneath this
    * path (`<defaultWorkingDirectory>/<harnessId>-<sessionId>`) so adapters do
@@ -105,7 +98,7 @@ export interface HarnessV1NetworkSandboxSession extends SandboxSession {
 
   /**
    * Update the sandbox's outbound network policy. Optional — implementations
-   * without a local enforcement primitive (e.g. just-bash) omit this. Callers
+   * without a local enforcement primitive omit this. Callers
    * use optional-call (`sandboxSession.setNetworkPolicy?.(policy)`); a
    * missing implementation is a no-op.
    */
@@ -139,7 +132,7 @@ export interface HarnessV1NetworkSandboxSession extends SandboxSession {
   /**
    * Replace the set of ports exposed by the sandbox. Full-replacement
    * semantics: ports omitted from the array are deregistered. Optional —
-   * implementations that cannot expose ports (e.g. just-bash) omit this.
+   * implementations that cannot expose ports omit this.
    */
   readonly setPorts?: (
     ports: ReadonlyArray<number>,

package/src/v1/harness-v1-sandbox-provider.ts

@@ -7,6 +7,7 @@ import type { HarnessV1NetworkSandboxSession } from './harness-v1-network-sandbo
  * `LanguageModelV4` providers, no I/O performed at construction. The actual
  * sandbox is created (or wrapped) when `HarnessAgent` calls `createSession()`.
  */
+/** @deprecated Supply a sandbox session to `HarnessAgent.createSession()` instead. */
 export interface HarnessV1SandboxProvider {
   readonly specificationVersion: 'harness-sandbox-v1';
   readonly providerId: string;
@@ -54,8 +55,8 @@ export interface HarnessV1SandboxProvider {
 
   /**
    * Reattach to an existing sandbox previously created with the same
-   * `sessionId`. Optional — providers that cannot rehydrate by id (e.g.
-   * just-bash) omit this; the harness throws
+   * `sessionId`. Optional — providers that cannot rehydrate by id omit
+   * this; the harness throws
    * `HarnessCapabilityUnsupportedError` when resume is attempted against
    * them.
    *

package/src/v1/harness-v1-sandbox-session-create-options.ts

@@ -0,0 +1,14 @@
+import type { HarnessV1SandboxTemplate } from './harness-v1-sandbox-template';
+
+export type HarnessV1SandboxSessionCreateOptions<
+  TProviderOptions extends object,
+> = TProviderOptions & {
+  /**
+   * Manually assign the ID of a newly created sandbox session. Creation never
+   * looks up or resumes an existing session. An existing sandbox resource with
+   * the same ID is a creation conflict.
+   */
+  readonly sandboxId?: string;
+  readonly template?: HarnessV1SandboxTemplate;
+  readonly abortSignal?: AbortSignal;
+};

package/src/v1/harness-v1-sandbox-session-resume-options.ts

@@ -0,0 +1,10 @@
+export type HarnessV1SandboxSessionResumeOptions<
+  TProviderOptions extends object,
+> = TProviderOptions & {
+  /**
+   * ID of the existing sandbox session to reattach. Resume never creates a
+   * sandbox when the ID cannot be found.
+   */
+  readonly sandboxId: string;
+  readonly abortSignal?: AbortSignal;
+};

package/src/v1/harness-v1-sandbox-template.ts

@@ -0,0 +1,9 @@
+import type { Experimental_SandboxSession } from '@ai-sdk/provider-utils';
+
+export type HarnessV1SandboxTemplate = {
+  readonly identity: string;
+  readonly prepare: (options: {
+    readonly session: Experimental_SandboxSession;
+    readonly abortSignal?: AbortSignal;
+  }) => Promise<void>;
+};

package/src/v1/index.ts

@@ -48,6 +48,9 @@ export type {
   HarnessV1ResponseFormat,
 } from './harness-v1-response-format';
 export type { HarnessV1SandboxProvider } from './harness-v1-sandbox-provider';
+export type { HarnessV1SandboxTemplate } from './harness-v1-sandbox-template';
+export type { HarnessV1SandboxSessionCreateOptions } from './harness-v1-sandbox-session-create-options';
+export type { HarnessV1SandboxSessionResumeOptions } from './harness-v1-sandbox-session-resume-options';
 export type {
   HarnessV1ContinueTurnState,
   HarnessV1LifecycleState,