veryfront 0.1.48 → 0.1.49

package/esm/src/config/schemas/config.schema.d.ts

@@ -473,15 +473,15 @@ export declare const veryfrontConfigSchema: z.ZodObject<{
             serviceName: z.ZodOptional<z.ZodOptional<z.ZodString>>;
             sampleRate: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
         }, "strip", z.ZodTypeAny, {
-            endpoint?: string | undefined;
             enabled?: boolean | undefined;
             exporter?: "console" | "jaeger" | "zipkin" | "otlp" | undefined;
+            endpoint?: string | undefined;
             serviceName?: string | undefined;
             sampleRate?: number | undefined;
         }, {
-            endpoint?: string | undefined;
             enabled?: boolean | undefined;
             exporter?: "console" | "jaeger" | "zipkin" | "otlp" | undefined;
+            endpoint?: string | undefined;
             serviceName?: string | undefined;
             sampleRate?: number | undefined;
         }>>>;
@@ -492,45 +492,45 @@ export declare const veryfrontConfigSchema: z.ZodObject<{
             prefix: z.ZodOptional<z.ZodOptional<z.ZodString>>;
             collectInterval: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
         }, "strip", z.ZodTypeAny, {
-            endpoint?: string | undefined;
             enabled?: boolean | undefined;
             exporter?: "console" | "otlp" | "prometheus" | undefined;
+            endpoint?: string | undefined;
             prefix?: string | undefined;
             collectInterval?: number | undefined;
         }, {
-            endpoint?: string | undefined;
             enabled?: boolean | undefined;
             exporter?: "console" | "otlp" | "prometheus" | undefined;
+            endpoint?: string | undefined;
             prefix?: string | undefined;
             collectInterval?: number | undefined;
         }>>>;
     }, "strip", z.ZodTypeAny, {
         tracing?: {
-            endpoint?: string | undefined;
             enabled?: boolean | undefined;
             exporter?: "console" | "jaeger" | "zipkin" | "otlp" | undefined;
+            endpoint?: string | undefined;
             serviceName?: string | undefined;
             sampleRate?: number | undefined;
         } | undefined;
         metrics?: {
-            endpoint?: string | undefined;
             enabled?: boolean | undefined;
             exporter?: "console" | "otlp" | "prometheus" | undefined;
+            endpoint?: string | undefined;
             prefix?: string | undefined;
             collectInterval?: number | undefined;
         } | undefined;
     }, {
         tracing?: {
-            endpoint?: string | undefined;
             enabled?: boolean | undefined;
             exporter?: "console" | "jaeger" | "zipkin" | "otlp" | undefined;
+            endpoint?: string | undefined;
             serviceName?: string | undefined;
             sampleRate?: number | undefined;
         } | undefined;
         metrics?: {
-            endpoint?: string | undefined;
             enabled?: boolean | undefined;
             exporter?: "console" | "otlp" | "prometheus" | undefined;
+            endpoint?: string | undefined;
             prefix?: string | undefined;
             collectInterval?: number | undefined;
         } | undefined;
@@ -905,6 +905,28 @@ export declare const veryfrontConfigSchema: z.ZodObject<{
                 paths?: string[] | undefined;
             } | undefined;
         }>>>;
+        skills: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+            discovery: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+                paths: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+            }, "strip", z.ZodTypeAny, {
+                enabled?: boolean | undefined;
+                paths?: string[] | undefined;
+            }, {
+                enabled?: boolean | undefined;
+                paths?: string[] | undefined;
+            }>>>;
+        }, "strip", z.ZodTypeAny, {
+            discovery?: {
+                enabled?: boolean | undefined;
+                paths?: string[] | undefined;
+            } | undefined;
+        }, {
+            discovery?: {
+                enabled?: boolean | undefined;
+                paths?: string[] | undefined;
+            } | undefined;
+        }>>>;
         mcp: z.ZodOptional<z.ZodOptional<z.ZodObject<{
             enabled: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
             port: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
@@ -938,6 +960,12 @@ export declare const veryfrontConfigSchema: z.ZodObject<{
                 paths?: string[] | undefined;
             } | undefined;
         } | undefined;
+        skills?: {
+            discovery?: {
+                enabled?: boolean | undefined;
+                paths?: string[] | undefined;
+            } | undefined;
+        } | undefined;
         mcp?: {
             port?: number | undefined;
             enabled?: boolean | undefined;
@@ -963,6 +991,12 @@ export declare const veryfrontConfigSchema: z.ZodObject<{
                 paths?: string[] | undefined;
             } | undefined;
         } | undefined;
+        skills?: {
+            discovery?: {
+                enabled?: boolean | undefined;
+                paths?: string[] | undefined;
+            } | undefined;
+        } | undefined;
         mcp?: {
             port?: number | undefined;
             enabled?: boolean | undefined;
@@ -1186,6 +1220,12 @@ export declare const veryfrontConfigSchema: z.ZodObject<{
                 paths?: string[] | undefined;
             } | undefined;
         } | undefined;
+        skills?: {
+            discovery?: {
+                enabled?: boolean | undefined;
+                paths?: string[] | undefined;
+            } | undefined;
+        } | undefined;
         mcp?: {
             port?: number | undefined;
             enabled?: boolean | undefined;
@@ -1304,16 +1344,16 @@ export declare const veryfrontConfigSchema: z.ZodObject<{
     } | undefined;
     observability?: {
         tracing?: {
-            endpoint?: string | undefined;
             enabled?: boolean | undefined;
             exporter?: "console" | "jaeger" | "zipkin" | "otlp" | undefined;
+            endpoint?: string | undefined;
             serviceName?: string | undefined;
             sampleRate?: number | undefined;
         } | undefined;
         metrics?: {
-            endpoint?: string | undefined;
             enabled?: boolean | undefined;
             exporter?: "console" | "otlp" | "prometheus" | undefined;
+            endpoint?: string | undefined;
             prefix?: string | undefined;
             collectInterval?: number | undefined;
         } | undefined;
@@ -1456,6 +1496,12 @@ export declare const veryfrontConfigSchema: z.ZodObject<{
                 paths?: string[] | undefined;
             } | undefined;
         } | undefined;
+        skills?: {
+            discovery?: {
+                enabled?: boolean | undefined;
+                paths?: string[] | undefined;
+            } | undefined;
+        } | undefined;
         mcp?: {
             port?: number | undefined;
             enabled?: boolean | undefined;
@@ -1574,16 +1620,16 @@ export declare const veryfrontConfigSchema: z.ZodObject<{
     } | undefined;
     observability?: {
         tracing?: {
-            endpoint?: string | undefined;
             enabled?: boolean | undefined;
             exporter?: "console" | "jaeger" | "zipkin" | "otlp" | undefined;
+            endpoint?: string | undefined;
             serviceName?: string | undefined;
             sampleRate?: number | undefined;
         } | undefined;
         metrics?: {
-            endpoint?: string | undefined;
             enabled?: boolean | undefined;
             exporter?: "console" | "otlp" | "prometheus" | undefined;
+            endpoint?: string | undefined;
             prefix?: string | undefined;
             collectInterval?: number | undefined;
         } | undefined;

package/esm/src/config/schemas/config.schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.schema.d.ts","sourceRoot":"","sources":["../../../../src/src/config/schemas/config.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAyBxB,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAqTtB,mCAAmC;;YAEnC,8CAA8C;;YAE9C,sBAAsB;;YAEtB,mDAAmD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmLnD,CAAC;AAGb,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACpE,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAGzE,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,OAAO,GAAG,eAAe,CAyBvE;AAQD,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,EAAE,CAEhF"}
+{"version":3,"file":"config.schema.d.ts","sourceRoot":"","sources":["../../../../src/src/config/schemas/config.schema.ts"],"names":[],"mappings":"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"}

package/esm/src/config/schemas/config.schema.js

@@ -390,6 +390,18 @@ export const veryfrontConfigSchema = z
         })
             .partial()
             .optional(),
+        skills: z
+            .object({
+            discovery: z
+                .object({
+                enabled: z.boolean().optional(),
+                paths: z.array(z.string()).optional(),
+            })
+                .partial()
+                .optional(),
+        })
+            .partial()
+            .optional(),
         mcp: z
             .object({
             enabled: z.boolean().optional(),

package/esm/src/data/data-fetcher.d.ts

@@ -1,11 +1,10 @@
-import type { RuntimeAdapter } from "../platform/adapters/base.js";
 import type { DataContext, DataResult, PageWithData, StaticPathsResult } from "./types.js";
 export declare class DataFetcher {
     private cacheManager;
     private serverFetcher;
     private staticFetcher;
     private pathsFetcher;
-    constructor(adapter?: RuntimeAdapter);
+    constructor(adapter?: unknown);
     fetchData(pageModule: PageWithData, context: DataContext, mode?: "development" | "production"): Promise<DataResult>;
     getStaticPaths(pageModule: PageWithData): Promise<StaticPathsResult | null>;
     clearCache(pattern?: string): void;

package/esm/src/data/data-fetcher.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"data-fetcher.d.ts","sourceRoot":"","sources":["../../../src/src/data/data-fetcher.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAOnE,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAE3F,qBAAa,WAAW;IACtB,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,aAAa,CAAoB;IACzC,OAAO,CAAC,aAAa,CAAoB;IACzC,OAAO,CAAC,YAAY,CAAqB;gBAE7B,OAAO,CAAC,EAAE,cAAc;IAOpC,SAAS,CACP,UAAU,EAAE,YAAY,EACxB,OAAO,EAAE,WAAW,EACpB,IAAI,GAAE,aAAa,GAAG,YAA4B,GACjD,OAAO,CAAC,UAAU,CAAC;IA+BtB,cAAc,CAAC,UAAU,EAAE,YAAY,GAAG,OAAO,CAAC,iBAAiB,GAAG,IAAI,CAAC;IAI3E,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI;CAQnC"}
+{"version":3,"file":"data-fetcher.d.ts","sourceRoot":"","sources":["../../../src/src/data/data-fetcher.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAE3F,qBAAa,WAAW;IACtB,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,aAAa,CAAoB;IACzC,OAAO,CAAC,aAAa,CAAoB;IACzC,OAAO,CAAC,YAAY,CAAqB;gBAG7B,OAAO,CAAC,EAAE,OAAO;IAO7B,SAAS,CACP,UAAU,EAAE,YAAY,EACxB,OAAO,EAAE,WAAW,EACpB,IAAI,GAAE,aAAa,GAAG,YAA4B,GACjD,OAAO,CAAC,UAAU,CAAC;IA0BtB,cAAc,CAAC,UAAU,EAAE,YAAY,GAAG,OAAO,CAAC,iBAAiB,GAAG,IAAI,CAAC;IAI3E,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI;CAQnC"}

package/esm/src/data/data-fetcher.js

@@ -9,29 +9,28 @@ export class DataFetcher {
     serverFetcher;
     staticFetcher;
     pathsFetcher;
+    // deno-lint-ignore no-unused-vars -- adapter kept for public API compatibility
     constructor(adapter) {
         this.cacheManager = new CacheManager();
-        this.serverFetcher = new ServerDataFetcher(adapter);
-        this.staticFetcher = new StaticDataFetcher(this.cacheManager, adapter);
+        this.serverFetcher = new ServerDataFetcher();
+        this.staticFetcher = new StaticDataFetcher(this.cacheManager);
         this.pathsFetcher = new StaticPathsFetcher();
     }
     fetchData(pageModule, context, mode = "development") {
         const preferServerData = mode === "development" || !pageModule.getStaticData;
-        let fetchType = "none";
-        if (preferServerData && pageModule.getServerData) {
-            fetchType = "server";
-        }
-        else if (pageModule.getStaticData) {
-            fetchType = "static";
-        }
-        return withSpan(SpanNames.DATA_FETCH, async () => {
-            if (preferServerData && pageModule.getServerData) {
+        const useServer = preferServerData && !!pageModule.getServerData;
+        const useStatic = !useServer && !!pageModule.getStaticData;
+        const fetchType = useServer
+            ? "server"
+            : useStatic
+                ? "static"
+                : "none";
+        return withSpan(SpanNames.DATA_FETCH, () => {
+            if (useServer)
                 return this.serverFetcher.fetch(pageModule, context);
-            }
-            if (pageModule.getStaticData) {
+            if (useStatic)
                 return this.staticFetcher.fetch(pageModule, context);
-            }
-            return { props: {} };
+            return Promise.resolve({ props: {} });
         }, {
             "data.fetch_type": fetchType,
             "data.mode": mode,

package/esm/src/data/server-data-fetcher.d.ts

@@ -1,8 +1,5 @@
-import type { RuntimeAdapter } from "../platform/adapters/base.js";
 import type { DataContext, DataResult, PageWithData } from "./types.js";
 export declare class ServerDataFetcher {
-    private adapter?;
-    constructor(adapter?: RuntimeAdapter | undefined);
     fetch(pageModule: PageWithData, context: DataContext): Promise<DataResult>;
     /**
      * Log errors unconditionally. Production errors should always be logged.

package/esm/src/data/server-data-fetcher.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server-data-fetcher.d.ts","sourceRoot":"","sources":["../../../src/src/data/server-data-fetcher.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AACnE,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAOxE,qBAAa,iBAAiB;IAChB,OAAO,CAAC,OAAO,CAAC;gBAAR,OAAO,CAAC,EAAE,cAAc,YAAA;IAE5C,KAAK,CAAC,UAAU,EAAE,YAAY,EAAE,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC;IAqE1E;;;OAGG;IACH,OAAO,CAAC,QAAQ;CAGjB"}
+{"version":3,"file":"server-data-fetcher.d.ts","sourceRoot":"","sources":["../../../src/src/data/server-data-fetcher.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAOxE,qBAAa,iBAAiB;IAC5B,KAAK,CAAC,UAAU,EAAE,YAAY,EAAE,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC;IAkE1E;;;OAGG;IACH,OAAO,CAAC,QAAQ;CAGjB"}

package/esm/src/data/server-data-fetcher.js

@@ -4,10 +4,6 @@ import { TimeoutError, withTimeoutThrow } from "../rendering/utils/stream-utils.
 import { withSpan } from "../observability/tracing/otlp-setup.js";
 import { CircuitBreakerOpen, getCircuitBreaker } from "../utils/circuit-breaker.js";
 export class ServerDataFetcher {
-    adapter;
-    constructor(adapter) {
-        this.adapter = adapter;
-    }
     fetch(pageModule, context) {
         if (typeof pageModule.getServerData !== "function") {
             return Promise.resolve({ props: {} });
@@ -22,10 +18,7 @@ export class ServerDataFetcher {
         return withSpan("data.fetch_server", async () => {
             const start = performance.now();
             try {
-                const getServerData = pageModule.getServerData;
-                if (!getServerData)
-                    throw new Error(`No getServerData function on ${pathname}`);
-                const result = await circuitBreaker.execute(() => withTimeoutThrow(Promise.resolve(getServerData(context)), DATA_FETCH_TIMEOUT_MS, `getServerData for ${pathname}`));
+                const result = await circuitBreaker.execute(() => withTimeoutThrow(Promise.resolve(pageModule.getServerData(context)), DATA_FETCH_TIMEOUT_MS, `getServerData for ${pathname}`));
                 if (result.redirect)
                     return { redirect: result.redirect };
                 if (result.notFound)

package/esm/src/data/static-data-fetcher.d.ts

@@ -1,11 +1,9 @@
-import type { RuntimeAdapter } from "../platform/adapters/base.js";
 import type { CacheManager } from "./data-fetching-cache.js";
 import type { DataContext, DataResult, PageWithData } from "./types.js";
 export declare class StaticDataFetcher {
     private cacheManager;
-    private adapter?;
     private pendingRevalidations;
-    constructor(cacheManager: CacheManager, adapter?: RuntimeAdapter | undefined);
+    constructor(cacheManager: CacheManager);
     fetch(pageModule: PageWithData, context: DataContext): Promise<DataResult>;
     private fetchFreshNoCache;
     private fetchFresh;

package/esm/src/data/static-data-fetcher.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"static-data-fetcher.d.ts","sourceRoot":"","sources":["../../../src/src/data/static-data-fetcher.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AACnE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAoDxE,qBAAa,iBAAiB;IAI1B,OAAO,CAAC,YAAY;IACpB,OAAO,CAAC,OAAO,CAAC;IAJlB,OAAO,CAAC,oBAAoB,CAAoC;gBAGtD,YAAY,EAAE,YAAY,EAC1B,OAAO,CAAC,EAAE,cAAc,YAAA;IAG5B,KAAK,CAAC,UAAU,EAAE,YAAY,EAAE,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC;YAuClE,iBAAiB;YA8BjB,UAAU;YAwEV,sBAAsB;IA2EpC;;;;;OAKG;IACH,OAAO,CAAC,QAAQ;CAIjB"}
+{"version":3,"file":"static-data-fetcher.d.ts","sourceRoot":"","sources":["../../../src/src/data/static-data-fetcher.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAoDxE,qBAAa,iBAAiB;IAGhB,OAAO,CAAC,YAAY;IAFhC,OAAO,CAAC,oBAAoB,CAAoC;gBAE5C,YAAY,EAAE,YAAY;IAExC,KAAK,CAAC,UAAU,EAAE,YAAY,EAAE,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC;YAuClE,iBAAiB;YA8BjB,UAAU;YAwEV,sBAAsB;IA2EpC;;;;;OAKG;IACH,OAAO,CAAC,QAAQ;CAIjB"}

package/esm/src/data/static-data-fetcher.js

@@ -39,11 +39,9 @@ function getProjectId(context, fallback) {
 }
 export class StaticDataFetcher {
     cacheManager;
-    adapter;
     pendingRevalidations = new Map();
-    constructor(cacheManager, adapter) {
+    constructor(cacheManager) {
         this.cacheManager = cacheManager;
-        this.adapter = adapter;
     }
     async fetch(pageModule, context) {
         if (typeof pageModule.getStaticData !== "function")

package/esm/src/discovery/discovery-engine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"discovery-engine.d.ts","sourceRoot":"","sources":["../../../src/src/discovery/discovery-engine.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAKH,OAAO,KAAK,EACV,eAAe,EAEf,eAAe,EAEhB,MAAM,YAAY,CAAC;AA2DpB;;GAEG;AACH,wBAAsB,WAAW,CAAC,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC,CAkDnF"}
+{"version":3,"file":"discovery-engine.d.ts","sourceRoot":"","sources":["../../../src/src/discovery/discovery-engine.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH,OAAO,KAAK,EACV,eAAe,EAEf,eAAe,EAEhB,MAAM,YAAY,CAAC;AA6DpB;;GAEG;AACH,wBAAsB,WAAW,CAAC,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC,CA0EnF"}

package/esm/src/discovery/discovery-engine.js

@@ -7,9 +7,11 @@
 import { detectPlatform } from "../platform/core-platform.js";
 import { agentLogger } from "../utils/logger/logger.js";
 import { ensureError } from "../errors/veryfront-error.js";
+import { registerSkill, skillRegistry } from "../skill/registry.js";
 import { importModule } from "./transpiler.js";
 import { findTypeScriptFiles } from "./file-discovery.js";
-import { agentHandler, promptHandler, resourceHandler, taskHandler, toolHandler, workflowHandler, } from "./handlers/index.js";
+import { agentHandler, discoverSkills, promptHandler, resourceHandler, taskHandler, toolHandler, workflowHandler, } from "./handlers/index.js";
+import { join } from "../platform/compat/path/index.js";
 const logger = agentLogger.component("discovery");
 /**
  * Discover items of a specific type in a directory
@@ -57,6 +59,7 @@ export async function discoverAll(config) {
     const result = {
         tools: new Map(),
         agents: new Map(),
+        skills: new Map(),
         resources: new Map(),
         prompts: new Map(),
         workflows: new Map(),
@@ -87,5 +90,20 @@ export async function discoverAll(config) {
     for (const dir of config.taskDirs ?? ["tasks"]) {
         await discoverItems(`${baseDir}/${dir}`, result, context, taskHandler, config.verbose);
     }
+    // Clear stale skills before rediscovery so deleted/renamed skills are removed.
+    skillRegistry.clear();
+    // Discover skills (parallel path — markdown-based, not TypeScript import)
+    for (const dir of config.skillDirs ?? ["skills"]) {
+        const skillResult = await discoverSkills(join(baseDir, dir), context, config.verbose);
+        for (const [id, skill] of skillResult.skills) {
+            if (result.skills.has(id)) {
+                logger.warn(`Duplicate skill "${id}" across discovery roots; keeping first registration`);
+                continue;
+            }
+            registerSkill(id, skill);
+            result.skills.set(id, skill);
+        }
+        result.errors.push(...skillResult.errors.map((e) => ({ file: e.file, error: e.error })));
+    }
     return result;
 }

package/esm/src/discovery/discovery-utils.d.ts

@@ -15,10 +15,6 @@ export declare function filePathToPattern(filePath: string, baseDir: string): st
  * Track an agent's file path for index generation
  */
 export declare function trackAgentPath(id: string, filePath: string): void;
-/**
- * Get all tracked agent paths
- */
-export declare function getTrackedAgentPaths(): Map<string, string>;
 /**
  * Clear tracked agent paths
  */

package/esm/src/discovery/discovery-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"discovery-utils.d.ts","sourceRoot":"","sources":["../../../src/src/discovery/discovery-utils.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;GAEG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAKrD;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAO3E;AAKD;;GAEG;AACH,wBAAgB,cAAc,CAAC,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAEjE;AAED;;GAEG;AACH,wBAAgB,oBAAoB,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAE1D;AAED;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,IAAI,CAEzC"}
+{"version":3,"file":"discovery-utils.d.ts","sourceRoot":"","sources":["../../../src/src/discovery/discovery-utils.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;GAEG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAKrD;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAO3E;AAKD;;GAEG;AACH,wBAAgB,cAAc,CAAC,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAEjE;AAED;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,IAAI,CAEzC"}

package/esm/src/discovery/discovery-utils.js

@@ -29,12 +29,6 @@ const discoveredAgentPaths = new Map();
 export function trackAgentPath(id, filePath) {
     discoveredAgentPaths.set(id, filePath);
 }
-/**
- * Get all tracked agent paths
- */
-export function getTrackedAgentPaths() {
-    return discoveredAgentPaths;
-}
 /**
  * Clear tracked agent paths
  */

package/esm/src/discovery/file-discovery.d.ts

@@ -9,7 +9,9 @@ import type { FileDiscoveryContext } from "./types.js";
  */
 export declare function findTypeScriptFiles(dir: string, context: FileDiscoveryContext): Promise<string[]>;
 /**
- * Get Node.js fs and path modules (cached on context)
+ * Get Node.js fs and path modules (cached on context).
+ *
+ * Only called when no fsAdapter is present — callers must guard accordingly.
  */
 export declare function getNodeDeps(context: FileDiscoveryContext): Promise<{
     fs: typeof import("node:fs");

package/esm/src/discovery/file-discovery.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"file-discovery.d.ts","sourceRoot":"","sources":["../../../src/src/discovery/file-discovery.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEvD;;GAEG;AACH,wBAAsB,mBAAmB,CACvC,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC,MAAM,EAAE,CAAC,CA2CnB;AAED;;GAEG;AACH,wBAAsB,WAAW,CAC/B,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC;IAAE,EAAE,EAAE,cAAc,SAAS,CAAC,CAAC;IAAC,IAAI,EAAE,cAAc,WAAW,CAAC,CAAA;CAAE,CAAC,CAc7E"}
+{"version":3,"file":"file-discovery.d.ts","sourceRoot":"","sources":["../../../src/src/discovery/file-discovery.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEvD;;GAEG;AACH,wBAAsB,mBAAmB,CACvC,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC,MAAM,EAAE,CAAC,CA2CnB;AAED;;;;GAIG;AACH,wBAAsB,WAAW,CAC/B,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC;IAAE,EAAE,EAAE,cAAc,SAAS,CAAC,CAAC;IAAC,IAAI,EAAE,cAAc,WAAW,CAAC,CAAA;CAAE,CAAC,CAM7E"}

package/esm/src/discovery/file-discovery.js

@@ -44,18 +44,13 @@ export async function findTypeScriptFiles(dir, context) {
     return files;
 }
 /**
- * Get Node.js fs and path modules (cached on context)
+ * Get Node.js fs and path modules (cached on context).
+ *
+ * Only called when no fsAdapter is present — callers must guard accordingly.
  */
 export async function getNodeDeps(context) {
     if (context.nodeDeps)
         return context.nodeDeps;
-    if (context.fsAdapter) {
-        context.nodeDeps = {
-            fs: {},
-            path: {},
-        };
-        return context.nodeDeps;
-    }
     const [fsModule, pathModule] = await Promise.all([import("node:fs"), import("node:path")]);
     context.nodeDeps = { fs: fsModule, path: pathModule };
     return context.nodeDeps;

package/esm/src/discovery/handlers/index.d.ts

@@ -9,4 +9,5 @@ export { resourceHandler } from "./resource-handler.js";
 export { promptHandler } from "./prompt-handler.js";
 export { workflowHandler } from "./workflow-handler.js";
 export { taskHandler } from "./task-handler.js";
+export { discoverSkills } from "./skill-handler.js";
 //# sourceMappingURL=index.d.ts.map

package/esm/src/discovery/handlers/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/src/discovery/handlers/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/src/discovery/handlers/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC"}

package/esm/src/discovery/handlers/index.js

@@ -9,3 +9,4 @@ export { resourceHandler } from "./resource-handler.js";
 export { promptHandler } from "./prompt-handler.js";
 export { workflowHandler } from "./workflow-handler.js";
 export { taskHandler } from "./task-handler.js";
+export { discoverSkills } from "./skill-handler.js";

package/esm/src/discovery/handlers/skill-handler.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Skill Discovery Handler
+ *
+ * Discovers skills from SKILL.md files in project directories.
+ * This is a parallel discovery path — it does NOT implement DiscoveryHandler<T>
+ * (which expects TypeScript import()). Instead, it operates on markdown files.
+ */
+import type { Skill } from "../../skill/index.js";
+import type { FileDiscoveryContext } from "../types.js";
+export interface SkillDiscoveryError {
+    file: string;
+    error: Error;
+}
+export interface SkillDiscoveryResult {
+    skills: Map<string, Skill>;
+    errors: SkillDiscoveryError[];
+}
+/**
+ * Discover skills from a directory.
+ *
+ * Scans for subdirectories containing SKILL.md files and parses them
+ * into Skill objects. Uses fsAdapter when available (for VFS/cloud),
+ * falling back to compat layer functions.
+ */
+export declare function discoverSkills(dir: string, context: FileDiscoveryContext, verbose?: boolean): Promise<SkillDiscoveryResult>;
+//# sourceMappingURL=skill-handler.d.ts.map

package/esm/src/discovery/handlers/skill-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skill-handler.d.ts","sourceRoot":"","sources":["../../../../src/src/discovery/handlers/skill-handler.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAQH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAIxD,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,KAAK,CAAC;CACd;AAED,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IAC3B,MAAM,EAAE,mBAAmB,EAAE,CAAC;CAC/B;AAED;;;;;;GAMG;AACH,wBAAsB,cAAc,CAClC,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,oBAAoB,EAC7B,OAAO,CAAC,EAAE,OAAO,GAChB,OAAO,CAAC,oBAAoB,CAAC,CAkF/B"}

package/esm/src/discovery/handlers/skill-handler.js

@@ -0,0 +1,87 @@
+/**
+ * Skill Discovery Handler
+ *
+ * Discovers skills from SKILL.md files in project directories.
+ * This is a parallel discovery path — it does NOT implement DiscoveryHandler<T>
+ * (which expects TypeScript import()). Instead, it operates on markdown files.
+ */
+import { exists, readDir, readTextFile } from "../../platform/compat/fs.js";
+import { join } from "../../platform/compat/path/index.js";
+import { agentLogger } from "../../utils/logger/logger.js";
+import { ensureError } from "../../errors/veryfront-error.js";
+import { parseSkillFrontmatter, validateSkillMetadata } from "../../skill/parser.js";
+import { SKILL_MD_FILENAME } from "../../skill/types.js";
+const logger = agentLogger.component("skill-discovery");
+/**
+ * Discover skills from a directory.
+ *
+ * Scans for subdirectories containing SKILL.md files and parses them
+ * into Skill objects. Uses fsAdapter when available (for VFS/cloud),
+ * falling back to compat layer functions.
+ */
+export async function discoverSkills(dir, context, verbose) {
+    const skills = new Map();
+    const errors = [];
+    const { fsAdapter } = context;
+    // Check if directory exists
+    const dirExists = fsAdapter ? await fsAdapter.exists(dir) : await exists(dir);
+    if (!dirExists) {
+        if (verbose) {
+            logger.info(`Skills directory does not exist: ${dir}`);
+        }
+        return { skills, errors };
+    }
+    // Iterate subdirectories
+    const entries = fsAdapter ? fsAdapter.readDir(dir) : readDir(dir);
+    for await (const entry of entries) {
+        if (!entry.isDirectory)
+            continue;
+        const skillDir = join(dir, entry.name);
+        const skillMdPath = join(skillDir, SKILL_MD_FILENAME);
+        try {
+            // Check if SKILL.md exists
+            const mdExists = fsAdapter ? await fsAdapter.exists(skillMdPath) : await exists(skillMdPath);
+            if (!mdExists) {
+                if (verbose) {
+                    logger.info(`Skipping ${entry.name}: no ${SKILL_MD_FILENAME}`);
+                }
+                continue;
+            }
+            // Read SKILL.md content
+            const content = fsAdapter
+                ? await fsAdapter.readFile(skillMdPath)
+                : await readTextFile(skillMdPath);
+            // Parse frontmatter
+            const parsed = await parseSkillFrontmatter(content);
+            // Validate metadata (directory name as fallback for skill name)
+            const metadata = validateSkillMetadata(parsed.frontmatter, entry.name);
+            // Warn if metadata name differs from directory name, use directory name as ID
+            const skillId = entry.name;
+            if (metadata.name !== entry.name) {
+                logger.warn(`Skill "${metadata.name}" in directory "${entry.name}" — using directory name as ID`);
+            }
+            // Check for duplicate IDs (first wins)
+            if (skills.has(skillId)) {
+                logger.warn(`Duplicate skill "${skillId}" — keeping first registration`);
+                continue;
+            }
+            const skill = {
+                id: skillId,
+                metadata,
+                rootPath: skillDir,
+                ...(fsAdapter && { fsAdapter }),
+            };
+            skills.set(skillId, skill);
+            if (verbose) {
+                logger.info(`Discovered skill: ${skillId}`);
+            }
+        }
+        catch (error) {
+            errors.push({ file: skillMdPath, error: ensureError(error) });
+            if (verbose) {
+                logger.error(`Error loading skill from ${entry.name}:`, error);
+            }
+        }
+    }
+    return { skills, errors };
+}

package/esm/src/discovery/handlers/task-handler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"task-handler.d.ts","sourceRoot":"","sources":["../../../../src/src/discovery/handlers/task-handler.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAE1D,OAAO,KAAK,EAAE,gBAAgB,EAAmB,MAAM,aAAa,CAAC;AAErE,eAAO,MAAM,WAAW,EAAE,gBAAgB,CAAC,cAAc,CAcxD,CAAC"}
+{"version":3,"file":"task-handler.d.ts","sourceRoot":"","sources":["../../../../src/src/discovery/handlers/task-handler.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAE1D,OAAO,KAAK,EAAE,gBAAgB,EAAmB,MAAM,aAAa,CAAC;AAErE,eAAO,MAAM,WAAW,EAAE,gBAAgB,CAAC,cAAc,CAUxD,CAAC"}

package/esm/src/discovery/handlers/task-handler.js

@@ -6,12 +6,8 @@ export const taskHandler = {
     typeName: "task",
     validate: (item) => isTaskDefinition(item),
     getId: (_task, file, dir) => {
-        // Derive ID from file path relative to tasks dir
-        let relative = file;
         const prefix = dir.endsWith("/") ? dir : `${dir}/`;
-        if (relative.startsWith(prefix)) {
-            relative = relative.slice(prefix.length);
-        }
+        const relative = file.startsWith(prefix) ? file.slice(prefix.length) : file;
         return relative.replace(/\.(ts|tsx|js|jsx)$/, "");
     },
     register: (_id, task) => task,

package/esm/src/discovery/transpiler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transpiler.d.ts","sourceRoot":"","sources":["../../../src/src/discovery/transpiler.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AA0HvD;;GAEG;AACH,wBAAsB,YAAY,CAChC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC,OAAO,CAAC,CAwFlB;AAED;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,IAAI,CAE1C"}
+{"version":3,"file":"transpiler.d.ts","sourceRoot":"","sources":["../../../src/src/discovery/transpiler.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AA6HvD;;GAEG;AACH,wBAAsB,YAAY,CAChC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC,OAAO,CAAC,CAwFlB;AAED;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,IAAI,CAE1C"}