veryfront 0.1.89 → 0.1.91

package/src/src/platform/adapters/veryfront-api-client/index.ts

@@ -9,6 +9,10 @@ export {
   type FileDetail,
   type FileListResult,
   type ListFilesOptions,
+  type ProjectStyleArtifactResolution,
+  type ResolveStyleArtifactInput,
+  type StyleArtifactSelector,
+  type UpsertStyleArtifactInput,
   VeryfrontAPIOperations,
 } from "./operations.js";
 export { type RequestOptions, requestWithRetry, type RetryConfig } from "./retry-handler.js";
@@ -39,4 +43,6 @@ export {
   ProjectSchema,
   ReleaseFileDetailSchema,
   ReleaseFileListItemSchema,
+  type StyleArtifactResolveResponse,
+  StyleArtifactResolveResponseSchema,
 } from "./schemas/index.js";

package/src/src/platform/adapters/veryfront-api-client/operations.ts

@@ -1,6 +1,6 @@
 import { logger as baseLogger } from "../../../utils/index.js";
 import { z } from "zod";
-import { requestWithRetry, type RetryConfig } from "./retry-handler.js";
+import { type RequestOptions, requestWithRetry, type RetryConfig } from "./retry-handler.js";
 import { API_CLIENT_ERROR } from "./types.js";
 import {
   BranchFileDetailSchema,
@@ -15,6 +15,7 @@ import {
   type ProjectFile,
   ProjectSchema,
   ReleaseFileDetailSchema,
+  StyleArtifactResolveResponseSchema,
 } from "./schemas/index.js";
 import { withSpan } from "../../../observability/tracing/otlp-setup.js";
 import { SpanNames } from "../../../observability/tracing/span-names.js";
@@ -53,6 +54,32 @@ export interface FileDetail {
   release_version?: string | null;
 }
 
+export interface StyleArtifactSelector {
+  branch?: string;
+  environmentName?: string;
+  releaseId?: string;
+}
+
+export interface ResolveStyleArtifactInput extends StyleArtifactSelector {
+  styleProfileHash: string;
+}
+
+export interface UpsertStyleArtifactInput extends ResolveStyleArtifactInput {
+  artifactHash: string;
+  assetPath?: string;
+  contentType?: string;
+  etag?: string;
+}
+
+export interface ProjectStyleArtifactResolution {
+  status: "ready" | "missing";
+  artifactHash?: string;
+  assetPath?: string;
+  etag?: string;
+  contentType?: string;
+  updatedAt?: string;
+}
+
 function buildListParams(options: ListFilesOptions): URLSearchParams {
   const { cursor, limit = DEFAULT_PAGE_LIMIT, pattern, sortBy = "updated_at", sortOrder = "desc" } =
     options;
@@ -81,6 +108,30 @@ function mapProjectFile<T extends ProjectFile>(file: T): ProjectFile {
   };
 }
 
+function buildStyleArtifactParams(input: ResolveStyleArtifactInput): URLSearchParams {
+  const params = new URLSearchParams({
+    style_profile_hash: input.styleProfileHash,
+  });
+
+  if (input.branch) params.set("branch", input.branch);
+  if (input.environmentName) params.set("environment_name", input.environmentName);
+  if (input.releaseId) params.set("release_id", input.releaseId);
+
+  return params;
+}
+
+function mapStyleArtifactResolution(raw: unknown): ProjectStyleArtifactResolution {
+  const response = StyleArtifactResolveResponseSchema.parse(raw);
+  return {
+    status: response.status,
+    artifactHash: response.artifact_hash,
+    assetPath: response.asset_path,
+    etag: response.etag,
+    contentType: response.content_type,
+    updatedAt: response.updated_at,
+  };
+}
+
 async function listAllFiles(
   list: (cursor?: string) => Promise<FileListResult>,
 ): Promise<ProjectFile[]> {
@@ -423,11 +474,67 @@ export class VeryfrontAPIOperations {
     );
   }
 
-  private request(endpoint: string): Promise<unknown> {
+  async resolveStyleArtifact(
+    projectRef: string,
+    input: ResolveStyleArtifactInput,
+  ): Promise<ProjectStyleArtifactResolution> {
+    const params = buildStyleArtifactParams(input);
+    const url = `/projects/${encodeURIComponent(projectRef)}/style-artifacts/current?${params}`;
+    logger.debug("resolveStyleArtifact", {
+      projectRef,
+      branch: input.branch,
+      environmentName: input.environmentName,
+      releaseId: input.releaseId,
+      styleProfileHash: input.styleProfileHash,
+    });
+
+    return mapStyleArtifactResolution(await this.request(url));
+  }
+
+  async upsertStyleArtifact(
+    projectRef: string,
+    input: UpsertStyleArtifactInput,
+  ): Promise<ProjectStyleArtifactResolution> {
+    const url = `/projects/${encodeURIComponent(projectRef)}/style-artifacts/current`;
+    logger.debug("upsertStyleArtifact", {
+      projectRef,
+      branch: input.branch,
+      environmentName: input.environmentName,
+      releaseId: input.releaseId,
+      styleProfileHash: input.styleProfileHash,
+      artifactHash: input.artifactHash,
+    });
+
+    return mapStyleArtifactResolution(
+      await this.request(url, {
+        method: "PUT",
+        headers: {
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+          style_profile_hash: input.styleProfileHash,
+          branch: input.branch,
+          environment_name: input.environmentName,
+          release_id: input.releaseId,
+          artifact_hash: input.artifactHash,
+          asset_path: input.assetPath,
+          content_type: input.contentType,
+          etag: input.etag,
+        }),
+      }),
+    );
+  }
+
+  private request(endpoint: string, options: RequestOptions = {}): Promise<unknown> {
     return withSpan(
       SpanNames.API_REQUEST,
       () =>
-        requestWithRetry(`${this.apiBaseUrl}${endpoint}`, this.tokenProvider(), this.retryConfig),
+        requestWithRetry(
+          `${this.apiBaseUrl}${endpoint}`,
+          this.tokenProvider(),
+          this.retryConfig,
+          options,
+        ),
       { "api.endpoint": endpoint, "api.base_url": this.apiBaseUrl },
     );
   }

package/src/src/platform/adapters/veryfront-api-client/schemas/api.schema.ts

@@ -147,6 +147,15 @@ export const LookupDomainResponseSchema = z.object({
   release_id: z.string().uuid().nullable(),
 });
 
+export const StyleArtifactResolveResponseSchema = z.object({
+  status: z.enum(["ready", "missing"]),
+  artifact_hash: z.string().optional(),
+  asset_path: z.string().optional(),
+  etag: z.string().optional(),
+  content_type: z.string().optional(),
+  updated_at: z.string().optional(),
+});
+
 export type Project = z.infer<typeof ProjectSchema>;
 export type ProjectFile = z.infer<typeof ProjectFileSchema>;
 export type PageInfo = z.infer<typeof PageInfoSchema>;
@@ -165,6 +174,7 @@ export type ListReleaseFilesResponse = z.infer<typeof ListReleaseFilesResponseSc
 export type ReleaseFileDetail = z.infer<typeof ReleaseFileDetailSchema>;
 
 export type LookupDomainResponse = z.infer<typeof LookupDomainResponseSchema>;
+export type StyleArtifactResolveResponse = z.infer<typeof StyleArtifactResolveResponseSchema>;
 
 export const API_ENDPOINTS = {
   listProjects: {
@@ -212,4 +222,10 @@ export const API_ENDPOINTS = {
     path: "/projects/{domain}",
     description: "Look up project by custom domain (resolved via project_reference)",
   },
+  resolveStyleArtifact: {
+    method: "GET" as const,
+    path: "/projects/{projectRef}/style-artifacts/current",
+    description:
+      "Resolve metadata for the latest ready style artifact for a branch, environment, or release selector",
+  },
 } as const;

package/src/src/platform/adapters/veryfront-api-client/schemas/index.ts

@@ -35,4 +35,6 @@ export {
   ReleaseFileDetailSchema,
   type ReleaseFileListItem,
   ReleaseFileListItemSchema,
+  type StyleArtifactResolveResponse,
+  StyleArtifactResolveResponseSchema,
 } from "./api.schema.js";

package/src/src/rendering/orchestrator/css-candidate-manifest.ts

@@ -1,4 +1,8 @@
 import { extractCandidates } from "../../html/styles-builder/tailwind-compiler.js";
+import {
+  filterFilesForStyleScope,
+  type StyleScopeProfile,
+} from "../../html/styles-builder/style-scope-profile.js";
 import { getRouteModulePaths } from "../../modules/manifest/route-module-manifest.js";
 import { rendererLogger } from "../../utils/index.js";
 
@@ -17,6 +21,7 @@ interface RouteCandidateOptions {
   projectScope: string;
   projectVersion: string;
   projectDir: string;
+  styleProfile?: StyleScopeProfile;
   routeKey: string;
   routeFilePaths: string[];
   files: SourceFileLike[];
@@ -27,6 +32,7 @@ interface ProjectCandidateOptions {
   projectScope: string;
   projectVersion: string;
   projectDir: string;
+  styleProfile?: StyleScopeProfile;
   files: SourceFileLike[];
   developmentMode: boolean;
 }
@@ -51,8 +57,12 @@ function toRelativeProjectPath(path: string, projectDir: string): string {
   return normalized.replace(/^\/+/, "");
 }
 
-function buildManifestCacheKey(projectScope: string, projectVersion: string): string {
-  return `${projectScope}:${projectVersion}`;
+function buildManifestCacheKey(
+  projectScope: string,
+  projectVersion: string,
+  styleProfileHash?: string,
+): string {
+  return `${projectScope}:${projectVersion}:${styleProfileHash ?? "default"}`;
 }
 
 function shouldRebuildManifest(
@@ -101,13 +111,20 @@ function buildCandidateManifest(files: SourceFileLike[], projectDir: string): Ca
 function getOrBuildManifest(
   options: Pick<
     ProjectCandidateOptions,
-    "projectScope" | "projectVersion" | "projectDir" | "files" | "developmentMode"
+    "projectScope" | "projectVersion" | "projectDir" | "files" | "developmentMode" | "styleProfile"
   >,
 ): CandidateManifest {
-  const manifestKey = buildManifestCacheKey(options.projectScope, options.projectVersion);
+  const manifestKey = buildManifestCacheKey(
+    options.projectScope,
+    options.projectVersion,
+    options.styleProfile?.hash,
+  );
   const existingManifest = manifestCache.get(manifestKey);
+  const scopedFiles = options.styleProfile
+    ? filterFilesForStyleScope(options.files, options.styleProfile, options.projectDir)
+    : options.files;
   const manifest = shouldRebuildManifest(existingManifest, options.developmentMode)
-    ? buildCandidateManifest(options.files, options.projectDir)
+    ? buildCandidateManifest(scopedFiles, options.projectDir)
     : existingManifest!;
 
   if (manifest !== existingManifest) {
@@ -139,7 +156,11 @@ function addCandidatesForPath(
  * Resolve route-scoped Tailwind candidates from a precomputed per-project manifest.
  */
 export function getRouteCandidates(options: RouteCandidateOptions): Set<string> {
-  const manifestKey = buildManifestCacheKey(options.projectScope, options.projectVersion);
+  const manifestKey = buildManifestCacheKey(
+    options.projectScope,
+    options.projectVersion,
+    options.styleProfile?.hash,
+  );
   const manifest = getOrBuildManifest(options);
   const routeCacheKey = `${manifestKey}:${options.routeKey}`;
   const cachedRoute = routeCandidateCache.get(routeCacheKey);
@@ -167,6 +188,7 @@ export function getRouteCandidates(options: RouteCandidateOptions): Set<string>
   logger.debug("Resolved route candidates", {
     projectScope: options.projectScope,
     projectVersion: options.projectVersion,
+    styleProfileHash: options.styleProfile?.hash,
     route: options.routeKey,
     count: routeCandidates.size,
   });

package/src/src/rendering/orchestrator/html.ts

@@ -29,6 +29,9 @@ import {
   rewriteCssModuleContent,
 } from "../../transforms/css-modules/naming.js";
 import { getRouteCandidates } from "./css-candidate-manifest.js";
+import { resolveStyleContentVersion } from "../../html/styles-builder/content-version.js";
+import { createStyleScopeProfile } from "../../html/styles-builder/style-scope-profile.js";
+import type { ResolvedContentContext } from "../../platform/adapters/fs/veryfront/types.js";
 
 const logger = rendererLogger.component("html-generator");
 
@@ -453,9 +456,16 @@ export class HTMLGenerator {
     if (typeof wrappedFs.getUnderlyingAdapter !== "function") return undefined;
 
     const fsAdapter = wrappedFs.getUnderlyingAdapter() as {
+      getContentContext?: () => ResolvedContentContext | null;
       getProjectData?: () => { updated_at?: string } | undefined;
     };
 
+    const contentContext = typeof fsAdapter.getContentContext === "function"
+      ? fsAdapter.getContentContext()
+      : null;
+
+    if (contentContext) return resolveStyleContentVersion(contentContext);
+
     return fsAdapter.getProjectData?.()?.updated_at;
   }
 
@@ -505,6 +515,7 @@ export class HTMLGenerator {
       projectScope,
       projectVersion,
       projectDir: this.config.projectDir,
+      styleProfile: createStyleScopeProfile(this.config.config),
       routeKey,
       routeFilePaths,
       files,

package/src/src/sandbox/index.ts

@@ -19,4 +19,16 @@
 import "../../_dnt.polyfills.js";
 
 
-export { type ExecResult, type ExecStreamEvent, Sandbox, type SandboxOptions } from "./sandbox.js";
+export {
+  type CommandJob,
+  type CommandJobHeartbeatStatus,
+  type CommandJobOutput,
+  type CommandJobStatus,
+  type ExecResult,
+  type ExecStreamEvent,
+  Sandbox,
+  type SandboxListOptions,
+  type SandboxListResult,
+  type SandboxOptions,
+  type SandboxSession,
+} from "./sandbox.js";

package/src/src/sandbox/sandbox.ts

@@ -41,6 +41,60 @@ export interface ExecStreamEvent {
   exitCode?: number;
 }
 
+/** Status of an async command job. */
+export type CommandJobStatus = "running" | "completed" | "failed" | "canceled";
+
+/** Heartbeat health status for a command job. */
+export type CommandJobHeartbeatStatus = "disabled" | "healthy" | "degraded";
+
+/** An async command job running in a sandbox. */
+export interface CommandJob {
+  id: string;
+  status: CommandJobStatus;
+  exitCode: number | null;
+  signal: string | null;
+  startedAt: string;
+  finishedAt: string | null;
+  heartbeatStatus: CommandJobHeartbeatStatus;
+  lastHeartbeatAt: string | null;
+  lastHeartbeatError: string | null;
+  heartbeatFailureCount: number;
+}
+
+/** A command job with its captured output. */
+export interface CommandJobOutput extends CommandJob {
+  stdout: string;
+  stderr: string;
+  stdoutTruncated: boolean;
+  stderrTruncated: boolean;
+}
+
+/** A sandbox session summary returned by list. */
+export interface SandboxSession {
+  id: string;
+  shortId: string;
+  endpoint: string;
+  status: string;
+  createdAt: string;
+}
+
+/** Options for listing sandbox sessions. */
+export interface SandboxListOptions extends SandboxOptions {
+  cursor?: string;
+  limit?: number;
+}
+
+/** Paginated result of sandbox sessions. */
+export interface SandboxListResult {
+  data: SandboxSession[];
+  pageInfo: {
+    self: string | null;
+    first: null;
+    next: string | null;
+    prev: string | null;
+  };
+}
+
 /** Client for isolated ephemeral compute environments with command execution and file I/O. */
 export class Sandbox {
   private constructor(
@@ -117,6 +171,47 @@ export class Sandbox {
     return new Sandbox(endpoint, id, authToken, apiUrl);
   }
 
+  /** List sandbox sessions with optional pagination. */
+  static async list(options: SandboxListOptions = {}): Promise<SandboxListResult> {
+    const apiUrl = Sandbox.resolveApiUrl(options);
+    const authToken = Sandbox.resolveAuthToken(options);
+
+    const params = new URLSearchParams();
+    if (options.cursor) params.set("cursor", options.cursor);
+    if (options.limit !== undefined) params.set("limit", String(options.limit));
+
+    const query = params.toString();
+    const url = `${apiUrl}/sandbox-sessions${query ? `?${query}` : ""}`;
+
+    const res = await dntShim.fetch(url, {
+      headers: { Authorization: `Bearer ${authToken}` },
+    });
+
+    if (!res.ok) {
+      throw REQUEST_ERROR.create({
+        detail: `Failed to list sandboxes: ${res.status} ${await res.text()}`,
+      });
+    }
+
+    const json = await res.json();
+
+    return {
+      data: json.data.map((s: Record<string, unknown>) => ({
+        id: s.id,
+        shortId: s.short_id,
+        endpoint: s.endpoint,
+        status: s.status,
+        createdAt: s.created_at,
+      })),
+      pageInfo: {
+        self: json.page_info?.self ?? null,
+        first: null,
+        next: json.page_info?.next ?? null,
+        prev: json.page_info?.prev ?? null,
+      },
+    };
+  }
+
   private static async waitForReady(
     apiUrl: string,
     id: string,
@@ -247,6 +342,94 @@ export class Sandbox {
     }
   }
 
+  /** Start an async command job in the sandbox. */
+  async startCommandJob(command: string): Promise<CommandJob> {
+    const res = await dntShim.fetch(`${this.endpoint}/exec/jobs`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${this.authToken}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({ command }),
+    });
+
+    if (!res.ok) {
+      throw REQUEST_ERROR.create({
+        detail: `Start command job failed: ${res.status} ${await res.text()}`,
+      });
+    }
+
+    return Sandbox.mapCommandJob(await res.json());
+  }
+
+  /** Get the status of an async command job. */
+  async getCommandJob(jobId: string): Promise<CommandJob> {
+    const res = await dntShim.fetch(`${this.endpoint}/exec/jobs/${jobId}`, {
+      headers: { Authorization: `Bearer ${this.authToken}` },
+    });
+
+    if (!res.ok) {
+      throw REQUEST_ERROR.create({
+        detail: `Get command job failed: ${res.status} ${await res.text()}`,
+      });
+    }
+
+    return Sandbox.mapCommandJob(await res.json());
+  }
+
+  /** Get the output of an async command job. */
+  async getCommandJobOutput(jobId: string): Promise<CommandJobOutput> {
+    const res = await dntShim.fetch(`${this.endpoint}/exec/jobs/${jobId}/output`, {
+      headers: { Authorization: `Bearer ${this.authToken}` },
+    });
+
+    if (!res.ok) {
+      throw REQUEST_ERROR.create({
+        detail: `Get command job output failed: ${res.status} ${await res.text()}`,
+      });
+    }
+
+    const json = await res.json();
+    return {
+      ...Sandbox.mapCommandJob(json),
+      stdout: json.stdout,
+      stderr: json.stderr,
+      stdoutTruncated: json.stdout_truncated,
+      stderrTruncated: json.stderr_truncated,
+    };
+  }
+
+  /** Cancel an async command job. */
+  async cancelCommandJob(jobId: string): Promise<CommandJob> {
+    const res = await dntShim.fetch(`${this.endpoint}/exec/jobs/${jobId}/cancel`, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${this.authToken}` },
+    });
+
+    if (!res.ok) {
+      throw REQUEST_ERROR.create({
+        detail: `Cancel command job failed: ${res.status} ${await res.text()}`,
+      });
+    }
+
+    return Sandbox.mapCommandJob(await res.json());
+  }
+
+  private static mapCommandJob(json: Record<string, unknown>): CommandJob {
+    return {
+      id: json.id as string,
+      status: json.status as CommandJobStatus,
+      exitCode: json.exit_code as number | null,
+      signal: json.signal as string | null,
+      startedAt: json.started_at as string,
+      finishedAt: json.finished_at as string | null,
+      heartbeatStatus: json.heartbeat_status as CommandJobHeartbeatStatus,
+      lastHeartbeatAt: json.last_heartbeat_at as string | null,
+      lastHeartbeatError: json.last_heartbeat_error as string | null,
+      heartbeatFailureCount: json.heartbeat_failure_count as number,
+    };
+  }
+
   /** Send a heartbeat to prevent idle timeout. */
   async heartbeat(): Promise<void> {
     await dntShim.fetch(`${this.apiUrl}/sandbox-sessions/${this.sessionId}/heartbeat`, {

package/src/src/server/handlers/dev/styles-candidate-scanner.ts

@@ -9,6 +9,12 @@
  */
 
 import { extractCandidates } from "../../../html/styles-builder/tailwind-compiler.js";
+import { resolveStyleContentVersion } from "../../../html/styles-builder/content-version.js";
+import {
+  createStyleScopeProfile,
+  shouldIncludeStylePath,
+  shouldTraverseStyleDirectory,
+} from "../../../html/styles-builder/style-scope-profile.js";
 import { serverLogger } from "../../../utils/index.js";
 import { createFileSystem } from "../../../platform/compat/fs.js";
 import { join } from "../../../platform/compat/path/index.js";
@@ -20,7 +26,6 @@ import { FRAMEWORK_CANDIDATES } from "./framework-candidates.generated.js";
 const logger = serverLogger.component("styles-candidate-scanner");
 
 const SOURCE_EXTENSIONS = [".tsx", ".jsx", ".mdx", ".ts", ".js"];
-const SKIP_DIRS = new Set(["node_modules", ".cache", ".git", "dist", "build", ".vscode"]);
 
 /** De-duplicated set of framework candidates, computed once at import time. */
 const frameworkCandidates = new Set<string>(FRAMEWORK_CANDIDATES);
@@ -32,18 +37,6 @@ interface SourceFileProvider {
   getContentContext?: () => ResolvedContentContext | null;
 }
 
-function resolveProjectVersion(
-  ctx: HandlerContext,
-  contentContext: ResolvedContentContext | null,
-): string {
-  if (contentContext?.releaseId) return `release:${contentContext.releaseId}`;
-  if (contentContext?.branch) return `branch:${contentContext.branch}`;
-  if (contentContext?.environmentName) return `environment:${contentContext.environmentName}`;
-  if (ctx.releaseId) return `release:${ctx.releaseId}`;
-  if (ctx.parsedDomain?.branch) return `branch:${ctx.parsedDomain.branch}`;
-  return "live";
-}
-
 /**
  * Extract Tailwind CSS candidate class names from all project source files.
  *
@@ -52,6 +45,7 @@ function resolveProjectVersion(
  * method is available (local dev mode).
  */
 export async function extractProjectCandidates(ctx: HandlerContext): Promise<Set<string>> {
+  const styleProfile = createStyleScopeProfile(ctx.config);
   const wrappedFs = ctx.adapter.fs as { getUnderlyingAdapter?: () => unknown };
 
   if (typeof wrappedFs.getUnderlyingAdapter !== "function") {
@@ -83,8 +77,13 @@ export async function extractProjectCandidates(ctx: HandlerContext): Promise<Set
   for (
     const cls of getProjectCandidates({
       projectScope: ctx.projectSlug ?? contentContext?.projectSlug ?? ctx.projectDir,
-      projectVersion: resolveProjectVersion(ctx, contentContext),
+      projectVersion: resolveStyleContentVersion(contentContext, {
+        releaseId: ctx.releaseId,
+        branch: ctx.parsedDomain?.branch,
+        environmentName: ctx.environmentName,
+      }),
       projectDir: ctx.projectDir,
+      styleProfile,
       files,
       developmentMode: contentContext?.sourceType === "branch",
     })
@@ -100,6 +99,7 @@ export async function extractProjectCandidates(ctx: HandlerContext): Promise<Set
  * Used in local development mode where projects are read directly from disk.
  */
 async function scanLocalFiles(projectDir: string, ctx: HandlerContext): Promise<Set<string>> {
+  const styleProfile = createStyleScopeProfile(ctx.config);
   const candidates = new Set<string>(frameworkCandidates);
   const fs = createFileSystem();
 
@@ -116,11 +116,14 @@ async function scanLocalFiles(projectDir: string, ctx: HandlerContext): Promise<
       const fullPath = join(dir, entry.name);
 
       if (entry.isDirectory) {
-        if (!SKIP_DIRS.has(entry.name)) await scanDir(fullPath);
+        if (shouldTraverseStyleDirectory(styleProfile, fullPath, projectDir)) {
+          await scanDir(fullPath);
+        }
         continue;
       }
 
       if (!entry.isFile) continue;
+      if (!shouldIncludeStylePath(styleProfile, fullPath, projectDir)) continue;
       if (!SOURCE_EXTENSIONS.some((ext) => entry.name.endsWith(ext))) continue;
 
       try {