veryfront 0.1.502 → 0.1.504

package/src/src/mcp/index.ts

@@ -7,13 +7,17 @@
  * ```ts
  * import { createMCPServer } from "veryfront/mcp";
  * import { tool } from "veryfront/tool";
- * import { z } from "zod";
+ * import { defineSchema } from "veryfront/schemas";
+ *
+ * const getSearchInputSchema = defineSchema((v) =>
+ *   v.object({ query: v.string() })
+ * );
  *
  * // Tools auto-register with MCP when defined
  * tool({
  *   id: "search",
  *   description: "Search docs",
- *   inputSchema: z.object({ query: z.string() }),
+ *   inputSchema: getSearchInputSchema(),
  *   execute: async ({ query }) => ({ results: [] }),
  * });
  *

package/src/src/mcp/schemas/index.ts

@@ -5,6 +5,9 @@
  */
 
 export {
+  getMCPAuthConfigSchema,
+  getMCPServerConfigSchema,
+  getMCPStatsSchema,
   MCPAuthConfigSchema,
   type MCPServerConfig,
   MCPServerConfigSchema,

package/src/src/mcp/schemas/mcp.schema.ts

@@ -1,4 +1,5 @@
-import { z } from "zod";
+import { defineSchema } from "../../schemas/index.js";
+import type { InferSchema } from "../../extensions/schema/index.js";
 
 /**
  * MCP auth configuration. One of:
@@ -7,37 +8,52 @@ import { z } from "zod";
  *   unauthenticated server. Required for local dev/testing; prevents accidental
  *   exposure of the JSON-RPC surface in production (VULN-SRV-5).
  */
-const AuthValidatedSchema = z.object({
-  type: z.literal("bearer"),
-  validate: z.function().optional(),
-});
+const getAuthValidatedSchema = defineSchema((v) =>
+  v.object({
+    type: v.literal("bearer"),
+    validate: v.function().optional(),
+  })
+);
 
-const AuthNoneSchema = z.object({
-  type: z.literal("none"),
-  allowUnauthenticated: z.literal(true),
-});
+const getAuthNoneSchema = defineSchema((v) =>
+  v.object({
+    type: v.literal("none"),
+    allowUnauthenticated: v.literal(true),
+  })
+);
 
-export const MCPAuthConfigSchema = z.union([AuthValidatedSchema, AuthNoneSchema]);
+export const getMCPAuthConfigSchema = defineSchema((v) =>
+  v.union([getAuthValidatedSchema(), getAuthNoneSchema()])
+);
 
-export const MCPServerConfigSchema = z.object({
-  enabled: z.boolean(),
-  port: z.number().int().positive().optional(),
-  auth: MCPAuthConfigSchema,
-  cors: z
-    .object({
-      enabled: z.boolean(),
-      origins: z.array(z.string()).optional(),
-    })
-    .optional(),
-});
+export const getMCPServerConfigSchema = defineSchema((v) =>
+  v.object({
+    enabled: v.boolean(),
+    port: v.number().int().positive().optional(),
+    auth: getMCPAuthConfigSchema(),
+    cors: v
+      .object({
+        enabled: v.boolean(),
+        origins: v.array(v.string()).optional(),
+      })
+      .optional(),
+  })
+);
 
-export const MCPStatsSchema = z.object({
-  tools: z.number().int().nonnegative(),
-  resources: z.number().int().nonnegative(),
-  prompts: z.number().int().nonnegative(),
-  total: z.number().int().nonnegative(),
-});
+export const getMCPStatsSchema = defineSchema((v) =>
+  v.object({
+    tools: v.number().int().nonnegative(),
+    resources: v.number().int().nonnegative(),
+    prompts: v.number().int().nonnegative(),
+    total: v.number().int().nonnegative(),
+  })
+);
+
+// Backward-compat aliases
+export const MCPAuthConfigSchema = getMCPAuthConfigSchema();
+export const MCPServerConfigSchema = getMCPServerConfigSchema();
+export const MCPStatsSchema = getMCPStatsSchema();
 
 // Inferred types
-export type MCPServerConfig = z.infer<typeof MCPServerConfigSchema>;
-export type MCPStats = z.infer<typeof MCPStatsSchema>;
+export type MCPServerConfig = InferSchema<ReturnType<typeof getMCPServerConfigSchema>>;
+export type MCPStats = InferSchema<ReturnType<typeof getMCPStatsSchema>>;

package/src/src/mcp/types.ts

@@ -1,4 +1,4 @@
-import type { z } from "zod";
+import type { Schema } from "../extensions/schema/index.js";
 import type { Tool } from "../tool/index.js";
 import type { Resource } from "../resource/index.js";
 import type { Prompt } from "../prompt/index.js";
@@ -21,8 +21,7 @@ export interface ToolAnnotations {
 export interface MCPTool<TInput = any, TOutput = any> {
   name: string;
   description: string;
-  // deno-lint-ignore no-explicit-any -- ZodType Def/Input params require any for ZodDefault/ZodOptional compatibility
-  inputSchema: z.ZodType<TInput, any, any>;
+  inputSchema: Schema<TInput>;
   execute: (input: TInput) => Promise<TOutput>;
   title?: string;
   annotations?: ToolAnnotations;

package/src/src/oauth/schemas/oauth.schema.ts

@@ -1,80 +1,106 @@
-import { z } from "zod";
+import { defineSchema } from "../../schemas/index.js";
+import type { InferSchema } from "../../extensions/schema/index.js";
 
-export const OAuthProviderConfigSchema = z.object({
-  providerId: z.string(),
-  displayName: z.string(),
-  authorizationUrl: z.string().url(),
-  tokenUrl: z.string().url(),
-  userInfoUrl: z.string().url().optional(),
-  revocationUrl: z.string().url().optional(),
-  clientIdEnvVar: z.string(),
-  clientSecretEnvVar: z.string(),
-  additionalAuthParams: z.record(z.string(), z.string()).optional(),
-  additionalTokenParams: z.record(z.string(), z.string()).optional(),
-  useBasicAuth: z.boolean().optional(),
-  tokenResponseMapping: z
-    .object({
-      accessToken: z.string().optional(),
-      refreshToken: z.string().optional(),
-      expiresIn: z.string().optional(),
-      tokenType: z.string().optional(),
-      scope: z.string().optional(),
-    })
-    .partial()
-    .optional(),
-});
+export const getOAuthProviderConfigSchema = defineSchema((v) =>
+  v.object({
+    providerId: v.string(),
+    displayName: v.string(),
+    authorizationUrl: v.string().url(),
+    tokenUrl: v.string().url(),
+    userInfoUrl: v.string().url().optional(),
+    revocationUrl: v.string().url().optional(),
+    clientIdEnvVar: v.string(),
+    clientSecretEnvVar: v.string(),
+    additionalAuthParams: v.record(v.string(), v.string()).optional(),
+    additionalTokenParams: v.record(v.string(), v.string()).optional(),
+    useBasicAuth: v.boolean().optional(),
+    tokenResponseMapping: v
+      .object({
+        accessToken: v.string().optional(),
+        refreshToken: v.string().optional(),
+        expiresIn: v.string().optional(),
+        tokenType: v.string().optional(),
+        scope: v.string().optional(),
+      })
+      .partial()
+      .optional(),
+  })
+);
 
-export const OAuthServiceConfigSchema = OAuthProviderConfigSchema.extend({
-  serviceId: z.string(),
-  defaultScopes: z.array(z.string()),
-  apiBaseUrl: z.string().url(),
-});
+export const getOAuthServiceConfigSchema = defineSchema((v) =>
+  getOAuthProviderConfigSchema().extend({
+    serviceId: v.string(),
+    defaultScopes: v.array(v.string()),
+    apiBaseUrl: v.string().url(),
+  })
+);
 
-export const OAuthTokensSchema = z.object({
-  accessToken: z.string(),
-  refreshToken: z.string().optional(),
-  expiresAt: z.number().int().optional(),
-  tokenType: z.string().optional(),
-  scope: z.string().optional(),
-  idToken: z.string().optional(),
-});
+export const getOAuthTokensSchema = defineSchema((v) =>
+  v.object({
+    accessToken: v.string(),
+    refreshToken: v.string().optional(),
+    expiresAt: v.number().int().optional(),
+    tokenType: v.string().optional(),
+    scope: v.string().optional(),
+    idToken: v.string().optional(),
+  })
+);
 
 /** State for CSRF protection and PKCE */
-export const OAuthStateSchema = z.object({
-  state: z.string(),
-  codeVerifier: z.string().optional(),
-  redirectUri: z.string().url(),
-  scopes: z.array(z.string()),
-  createdAt: z.number().int(),
-  metadata: z.record(z.string(), z.unknown()).optional(),
-});
+export const getOAuthStateSchema = defineSchema((v) =>
+  v.object({
+    state: v.string(),
+    codeVerifier: v.string().optional(),
+    redirectUri: v.string().url(),
+    scopes: v.array(v.string()),
+    createdAt: v.number().int(),
+    metadata: v.record(v.string(), v.unknown()).optional(),
+  })
+);
 
-export const TokenExchangeResultSchema = z.object({
-  success: z.boolean(),
-  tokens: OAuthTokensSchema.optional(),
-  error: z.string().optional(),
-  errorDescription: z.string().optional(),
-});
+export const getTokenExchangeResultSchema = defineSchema((v) =>
+  v.object({
+    success: v.boolean(),
+    tokens: getOAuthTokensSchema().optional(),
+    error: v.string().optional(),
+    errorDescription: v.string().optional(),
+  })
+);
 
-export const AuthorizationUrlOptionsSchema = z.object({
-  scopes: z.array(z.string()).optional(),
-  state: z.string().optional(),
-  usePkce: z.boolean().optional(),
-  additionalParams: z.record(z.string(), z.string()).optional(),
-  redirectUri: z.string().optional(),
-});
+export const getAuthorizationUrlOptionsSchema = defineSchema((v) =>
+  v.object({
+    scopes: v.array(v.string()).optional(),
+    state: v.string().optional(),
+    usePkce: v.boolean().optional(),
+    additionalParams: v.record(v.string(), v.string()).optional(),
+    redirectUri: v.string().optional(),
+  })
+);
 
-export const TokenExchangeOptionsSchema = z.object({
-  code: z.string(),
-  redirectUri: z.string().url(),
-  codeVerifier: z.string().optional(),
-});
+export const getTokenExchangeOptionsSchema = defineSchema((v) =>
+  v.object({
+    code: v.string(),
+    redirectUri: v.string().url(),
+    codeVerifier: v.string().optional(),
+  })
+);
 
 // Inferred types
-export type OAuthProviderConfig = z.infer<typeof OAuthProviderConfigSchema>;
-export type OAuthServiceConfig = z.infer<typeof OAuthServiceConfigSchema>;
-export type OAuthTokens = z.infer<typeof OAuthTokensSchema>;
-export type OAuthState = z.infer<typeof OAuthStateSchema>;
-export type TokenExchangeResult = z.infer<typeof TokenExchangeResultSchema>;
-export type AuthorizationUrlOptions = z.infer<typeof AuthorizationUrlOptionsSchema>;
-export type TokenExchangeOptions = z.infer<typeof TokenExchangeOptionsSchema>;
+export type OAuthProviderConfig = InferSchema<ReturnType<typeof getOAuthProviderConfigSchema>>;
+export type OAuthServiceConfig = InferSchema<ReturnType<typeof getOAuthServiceConfigSchema>>;
+export type OAuthTokens = InferSchema<ReturnType<typeof getOAuthTokensSchema>>;
+export type OAuthState = InferSchema<ReturnType<typeof getOAuthStateSchema>>;
+export type TokenExchangeResult = InferSchema<ReturnType<typeof getTokenExchangeResultSchema>>;
+export type AuthorizationUrlOptions = InferSchema<
+  ReturnType<typeof getAuthorizationUrlOptionsSchema>
+>;
+export type TokenExchangeOptions = InferSchema<ReturnType<typeof getTokenExchangeOptionsSchema>>;
+
+// Backward compat aliases
+export const OAuthProviderConfigSchema = getOAuthProviderConfigSchema();
+export const OAuthServiceConfigSchema = getOAuthServiceConfigSchema();
+export const OAuthTokensSchema = getOAuthTokensSchema();
+export const OAuthStateSchema = getOAuthStateSchema();
+export const TokenExchangeResultSchema = getTokenExchangeResultSchema();
+export const AuthorizationUrlOptionsSchema = getAuthorizationUrlOptionsSchema();
+export const TokenExchangeOptionsSchema = getTokenExchangeOptionsSchema();

package/src/src/platform/adapters/fs/github/github-api-client.ts

@@ -3,12 +3,12 @@ import { createError, toError } from "../../../../errors/index.js";
 import { logger } from "../../../../utils/index.js";
 import type { ResolvedGitHubConfig } from "./types.js";
 import {
+  getGitHubBlobResponseSchema,
+  getGitHubContentsResponseSchema,
+  getGitHubTreeResponseSchema,
   type GitHubBlobResponse,
-  GitHubBlobResponseSchema,
   type GitHubContentItem,
-  GitHubContentsResponseSchema,
   type GitHubTreeResponse,
-  GitHubTreeResponseSchema,
 } from "./schemas/index.js";
 
 const LOG_PREFIX = "[GitHubApiClient]";
@@ -43,7 +43,7 @@ export class GitHubApiClient {
     logger.debug(`${LOG_PREFIX} Fetching tree`, { ref: treeRef });
 
     const raw = await this.request(endpoint);
-    const response = GitHubTreeResponseSchema.parse(raw);
+    const response = getGitHubTreeResponseSchema().parse(raw);
 
     if (response.truncated) {
       logger.warn(
@@ -66,7 +66,7 @@ export class GitHubApiClient {
     logger.debug(`${LOG_PREFIX} Fetching contents`, { path: normalizedPath });
 
     const raw = await this.request(endpoint);
-    return GitHubContentsResponseSchema.parse(raw);
+    return getGitHubContentsResponseSchema().parse(raw);
   }
 
   async getBlob(sha: string): Promise<GitHubBlobResponse> {
@@ -75,7 +75,7 @@ export class GitHubApiClient {
     logger.debug(`${LOG_PREFIX} Fetching blob`, { sha });
 
     const raw = await this.request(endpoint);
-    return GitHubBlobResponseSchema.parse(raw);
+    return getGitHubBlobResponseSchema().parse(raw);
   }
 
   getRateLimitInfo(): RateLimitInfo | null {

package/src/src/platform/adapters/fs/github/index.ts

@@ -25,10 +25,10 @@ export type {
 } from "./types.js";
 
 export {
+  getGitHubBlobResponseSchema,
+  getGitHubContentItemSchema,
+  getGitHubContentsResponseSchema,
+  getGitHubTreeEntrySchema,
+  getGitHubTreeResponseSchema,
   GITHUB_API_ENDPOINTS,
-  GitHubBlobResponseSchema,
-  GitHubContentItemSchema,
-  GitHubContentsResponseSchema,
-  GitHubTreeEntrySchema,
-  GitHubTreeResponseSchema,
 } from "./schemas/index.js";

package/src/src/platform/adapters/fs/github/schemas/github-api.schema.ts

@@ -1,50 +1,63 @@
 /** @see https://docs.github.com/en/rest */
 
-import { z } from "zod";
+import { defineSchema } from "../../../../../schemas/index.js";
+import type { InferSchema } from "../../../../../extensions/schema/index.js";
 
-export const GitHubTreeEntrySchema = z.object({
-  path: z.string(),
-  mode: z.string().optional(),
-  type: z.enum(["blob", "tree", "commit"]),
-  sha: z.string(),
-  size: z.number().optional(),
-});
+export const getGitHubTreeEntrySchema = defineSchema((v) =>
+  v.object({
+    path: v.string(),
+    mode: v.string().optional(),
+    type: v.enum(["blob", "tree", "commit"] as const),
+    sha: v.string(),
+    size: v.number().optional(),
+  })
+);
 
-export const GitHubContentItemSchema = z.object({
-  type: z.enum(["file", "dir", "symlink", "submodule"]),
-  name: z.string(),
-  path: z.string(),
-  sha: z.string(),
-  size: z.number(),
-  content: z.string().optional(),
-  encoding: z.literal("base64").optional(),
-  download_url: z.string().nullable().optional(),
-});
+export const getGitHubContentItemSchema = defineSchema((v) =>
+  v.object({
+    type: v.enum(["file", "dir", "symlink", "submodule"] as const),
+    name: v.string(),
+    path: v.string(),
+    sha: v.string(),
+    size: v.number(),
+    content: v.string().optional(),
+    encoding: v.literal("base64").optional(),
+    download_url: v.string().nullable().optional(),
+  })
+);
 
-export const GitHubTreeResponseSchema = z.object({
-  sha: z.string(),
-  url: z.string().optional(),
-  tree: z.array(GitHubTreeEntrySchema),
-  truncated: z.boolean(),
-});
+export const getGitHubTreeResponseSchema = defineSchema((v) =>
+  v.object({
+    sha: v.string(),
+    url: v.string().optional(),
+    tree: v.array(getGitHubTreeEntrySchema()),
+    truncated: v.boolean(),
+  })
+);
 
-export const GitHubContentsResponseSchema = z.union([
-  GitHubContentItemSchema,
-  z.array(GitHubContentItemSchema),
-]);
+export const getGitHubContentsResponseSchema = defineSchema((v) =>
+  v.union([
+    getGitHubContentItemSchema(),
+    v.array(getGitHubContentItemSchema()),
+  ])
+);
 
-export const GitHubBlobResponseSchema = z.object({
-  sha: z.string(),
-  size: z.number(),
-  content: z.string(),
-  encoding: z.enum(["base64", "utf-8"]),
-});
+export const getGitHubBlobResponseSchema = defineSchema((v) =>
+  v.object({
+    sha: v.string(),
+    size: v.number(),
+    content: v.string(),
+    encoding: v.enum(["base64", "utf-8"] as const),
+  })
+);
 
-export type GitHubTreeEntry = z.infer<typeof GitHubTreeEntrySchema>;
-export type GitHubContentItem = z.infer<typeof GitHubContentItemSchema>;
-export type GitHubTreeResponse = z.infer<typeof GitHubTreeResponseSchema>;
-export type GitHubContentsResponse = z.infer<typeof GitHubContentsResponseSchema>;
-export type GitHubBlobResponse = z.infer<typeof GitHubBlobResponseSchema>;
+export type GitHubTreeEntry = InferSchema<ReturnType<typeof getGitHubTreeEntrySchema>>;
+export type GitHubContentItem = InferSchema<ReturnType<typeof getGitHubContentItemSchema>>;
+export type GitHubTreeResponse = InferSchema<ReturnType<typeof getGitHubTreeResponseSchema>>;
+export type GitHubContentsResponse = InferSchema<
+  ReturnType<typeof getGitHubContentsResponseSchema>
+>;
+export type GitHubBlobResponse = InferSchema<ReturnType<typeof getGitHubBlobResponseSchema>>;
 
 export const GITHUB_API_ENDPOINTS = {
   getTree: {
@@ -52,7 +65,8 @@ export const GITHUB_API_ENDPOINTS = {
     path: "/repos/{owner}/{repo}/git/trees/{tree_sha}",
     description: "Get a tree. Use ?recursive=1 for full repository tree.",
     queryParams: ["recursive"],
-    responseSchema: GitHubTreeResponseSchema,
+    // schema getter — call to materialize the underlying Schema<T>
+    responseSchema: getGitHubTreeResponseSchema,
     docs: "https://docs.github.com/en/rest/git/trees#get-a-tree",
   },
   getContents: {
@@ -60,14 +74,16 @@ export const GITHUB_API_ENDPOINTS = {
     path: "/repos/{owner}/{repo}/contents/{path}",
     description: "Get repository content. Returns file content or directory listing.",
     queryParams: ["ref"],
-    responseSchema: GitHubContentsResponseSchema,
+    // schema getter — call to materialize the underlying Schema<T>
+    responseSchema: getGitHubContentsResponseSchema,
     docs: "https://docs.github.com/en/rest/repos/contents#get-repository-content",
   },
   getBlob: {
     method: "GET",
     path: "/repos/{owner}/{repo}/git/blobs/{file_sha}",
     description: "Get a blob by SHA. Used for large files (>1MB).",
-    responseSchema: GitHubBlobResponseSchema,
+    // schema getter — call to materialize the underlying Schema<T>
+    responseSchema: getGitHubBlobResponseSchema,
     docs: "https://docs.github.com/en/rest/git/blobs#get-a-blob",
   },
 } as const;

package/src/src/platform/adapters/fs/github/schemas/index.ts

@@ -5,15 +5,15 @@
  */
 
 export {
+  getGitHubBlobResponseSchema,
+  getGitHubContentItemSchema,
+  getGitHubContentsResponseSchema,
+  getGitHubTreeEntrySchema,
+  getGitHubTreeResponseSchema,
   GITHUB_API_ENDPOINTS,
   type GitHubBlobResponse,
-  GitHubBlobResponseSchema,
   type GitHubContentItem,
-  GitHubContentItemSchema,
   type GitHubContentsResponse,
-  GitHubContentsResponseSchema,
   type GitHubTreeEntry,
-  GitHubTreeEntrySchema,
   type GitHubTreeResponse,
-  GitHubTreeResponseSchema,
 } from "./github-api.schema.js";

package/src/src/platform/adapters/fs/veryfront/proxy-manager.ts

@@ -4,7 +4,7 @@ import { CACHE_INVARIANT_VIOLATION, INVALID_ARGUMENT, VeryfrontError } from "../
 import { buildProxyManagerCacheKey } from "../../../../cache/index.js";
 import { VeryfrontFSAdapter } from "./index.js";
 import type { CacheStats, FSAdapterConfig, ResolvedContentContext } from "./types.js";
-import { GetAdapterParamsSchema } from "./schemas/index.js";
+import { getGetAdapterParamsSchema } from "./schemas/index.js";
 import { createDefaultInvalidationCallbacks } from "./default-invalidation-callbacks.js";
 
 const logger = baseLogger.component("proxy-fs-adapter-manager");
@@ -147,7 +147,7 @@ export class ProxyFSAdapterManager {
       branch: effectiveBranch,
     });
 
-    const validationResult = GetAdapterParamsSchema.safeParse({
+    const validationResult = getGetAdapterParamsSchema().safeParse({
       projectSlug,
       token,
       projectId,
@@ -159,7 +159,7 @@ export class ProxyFSAdapterManager {
 
     if (!validationResult.success) {
       logger.error("Validation failed", {
-        errors: validationResult.error.issues,
+        errors: validationResult.issues,
         params: {
           projectSlug,
           productionMode: effectiveProductionMode,
@@ -168,9 +168,13 @@ export class ProxyFSAdapterManager {
           branch: effectiveBranch,
         },
       });
+      const detailMessage = validationResult.issues
+        .map((issue) =>
+          issue.path.length > 0 ? `${issue.path.join(".")}: ${issue.message}` : issue.message
+        )
+        .join("; ");
       throw INVALID_ARGUMENT.create({
-        detail:
-          `[ProxyFSAdapterManager] Invalid getAdapter parameters: ${validationResult.error.message}`,
+        detail: `[ProxyFSAdapterManager] Invalid getAdapter parameters: ${detailMessage}`,
       });
     }
 

package/src/src/platform/adapters/fs/veryfront/schemas/index.ts

@@ -4,4 +4,4 @@
  * @module platform/adapters/fs/veryfront/schemas
  */
 
-export { type GetAdapterParams, GetAdapterParamsSchema } from "./proxy-manager.schema.js";
+export { type GetAdapterParams, getGetAdapterParamsSchema } from "./proxy-manager.schema.js";

package/src/src/platform/adapters/fs/veryfront/schemas/proxy-manager.schema.ts

@@ -1,13 +1,16 @@
-import { z } from "zod";
+import { defineSchema } from "../../../../../schemas/index.js";
+import type { InferSchema } from "../../../../../extensions/schema/index.js";
 
-export const GetAdapterParamsSchema = z.object({
-  projectSlug: z.string().min(1, "projectSlug must be non-empty"),
-  token: z.string().min(1, "token must be non-empty"),
-  projectId: z.string().optional(),
-  productionMode: z.boolean(),
-  releaseId: z.string().nullable().optional(),
-  environmentName: z.string().nullable().optional(),
-  branch: z.string().nullable().optional(),
-});
+export const getGetAdapterParamsSchema = defineSchema((v) =>
+  v.object({
+    projectSlug: v.string().min(1, "projectSlug must be non-empty"),
+    token: v.string().min(1, "token must be non-empty"),
+    projectId: v.string().optional(),
+    productionMode: v.boolean(),
+    releaseId: v.string().nullable().optional(),
+    environmentName: v.string().nullable().optional(),
+    branch: v.string().nullable().optional(),
+  })
+);
 
-export type GetAdapterParams = z.infer<typeof GetAdapterParamsSchema>;
+export type GetAdapterParams = InferSchema<ReturnType<typeof getGetAdapterParamsSchema>>;

package/src/src/platform/adapters/fs/veryfront/stat-operations.ts

@@ -109,6 +109,7 @@ export class StatOperations extends VeryfrontOperationsBase {
                 // Add to index for future lookups
                 fileIdx.set(normalizedPath, {
                   id: exactMatch.id,
+                  version_id: undefined,
                   path: normalizedPath,
                   content: undefined,
                   type: "file",