@intrig/core 0.0.15-4 → 0.0.15-6

package/main.js

@@ -981,6 +981,8 @@ SourcesCommand = sources_command_ts_decorate([
     })
 ], SourcesCommand);
 
+;// external "proper-lockfile"
+const external_proper_lockfile_namespaceObject = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("proper-lockfile");
 ;// external "lodash"
 const external_lodash_namespaceObject = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("lodash");
 var external_lodash_default = /*#__PURE__*/__webpack_require__.n(external_lodash_namespaceObject);
@@ -1288,30 +1290,110 @@ function spec_management_service_ts_metadata(k, v) {
 
 
 
+
 class SpecManagementService {
     constructor(config){
         this.config = config;
+        this.logger = new common_namespaceObject.Logger(SpecManagementService.name);
         this.specsDir = this.config.get('specsDir') ?? external_path_namespaceObject.resolve(external_node_process_namespaceObject.cwd(), '.intrig', 'specs');
     }
     async save(apiName, content) {
-        const currentContent = await this.read(apiName);
-        if (currentContent) {
-            const differences = openapi3_diff(currentContent, JSON.parse(content));
-            if (!Object.keys(differences).length) {
-                return;
+        const filePath = external_path_namespaceObject.join(this.specsDir, `${apiName}-latest.json`);
+        const tempPath = external_path_namespaceObject.join(this.specsDir, `${apiName}-latest.json.tmp`);
+        let release;
+        try {
+            // Ensure directory exists
+            external_fs_namespaceObject.mkdirSync(this.specsDir, {
+                recursive: true
+            });
+            // Acquire lock for the file
+            release = await external_proper_lockfile_namespaceObject.lock(filePath, {
+                retries: {
+                    retries: 5,
+                    factor: 2,
+                    minTimeout: 100,
+                    maxTimeout: 2000
+                }
+            });
+            // Read current content with lock protection
+            const currentContent = await this.readWithoutLock(apiName);
+            if (currentContent) {
+                const differences = openapi3_diff(currentContent, JSON.parse(content));
+                if (!Object.keys(differences).length) {
+                    this.logger.debug(`No changes detected for ${apiName}, skipping save`);
+                    return;
+                }
+            }
+            // Atomic write: write to temp file first, then rename
+            external_fs_namespaceObject.writeFileSync(tempPath, content, 'utf-8');
+            external_fs_namespaceObject.renameSync(tempPath, filePath);
+            this.logger.debug(`Successfully saved spec for ${apiName}`);
+        } catch (error) {
+            // Clean up temp file if it exists
+            if (external_fs_namespaceObject.existsSync(tempPath)) {
+                try {
+                    external_fs_namespaceObject.unlinkSync(tempPath);
+                } catch (cleanupError) {
+                    this.logger.warn(`Failed to cleanup temp file ${tempPath}: ${cleanupError}`);
+                }
+            }
+            this.logger.error(`Failed to save spec for ${apiName}: ${error.message}`, error);
+            throw new Error(`Failed to save spec for ${apiName}: ${error.message}`);
+        } finally{
+            // Always release the lock
+            if (release) {
+                try {
+                    await release();
+                } catch (releaseError) {
+                    this.logger.warn(`Failed to release lock for ${filePath}: ${releaseError}`);
+                }
             }
         }
-        external_fs_namespaceObject.mkdirSync(this.specsDir, {
-            recursive: true
-        });
-        external_fs_namespaceObject.writeFileSync(external_path_namespaceObject.join(this.specsDir, `${apiName}-latest.json`), content, 'utf-8');
     }
     async read(apiName) {
+        const filePath = external_path_namespaceObject.join(this.specsDir, `${apiName}-latest.json`);
+        let release;
+        try {
+            // Acquire lock for reading
+            release = await external_proper_lockfile_namespaceObject.lock(filePath, {
+                retries: {
+                    retries: 3,
+                    factor: 2,
+                    minTimeout: 50,
+                    maxTimeout: 1000
+                }
+            });
+            return await this.readWithoutLock(apiName);
+        } catch (error) {
+            if (error.code === 'ENOENT' || !external_fs_namespaceObject.existsSync(filePath)) {
+                // File doesn't exist, this is normal for first-time sync
+                this.logger.debug(`Spec file not found for ${apiName}, returning undefined`);
+                return undefined;
+            }
+            this.logger.error(`Failed to read spec for ${apiName}: ${error.message}`, error);
+            throw new Error(`Failed to read spec for ${apiName}: ${error.message}`);
+        } finally{
+            // Always release the lock
+            if (release) {
+                try {
+                    await release();
+                } catch (releaseError) {
+                    this.logger.warn(`Failed to release lock for ${filePath}: ${releaseError}`);
+                }
+            }
+        }
+    }
+    async readWithoutLock(apiName) {
         const fileName = `${apiName}-latest.json`;
         const specPath = external_path_namespaceObject.join(this.specsDir, fileName);
         if (external_fs_namespaceObject.existsSync(specPath)) {
-            const content = external_fs_namespaceObject.readFileSync(specPath, 'utf-8');
-            return JSON.parse(content);
+            try {
+                const content = external_fs_namespaceObject.readFileSync(specPath, 'utf-8');
+                return JSON.parse(content);
+            } catch (error) {
+                this.logger.error(`Failed to parse JSON for ${apiName}: ${error.message}`);
+                throw new Error(`Invalid JSON in spec file for ${apiName}: ${error.message}`);
+            }
         }
         return undefined;
     }
@@ -5528,84 +5610,533 @@ ${"```"}
 <summary>Early Return</summary>
 Often times you may need to show the loading indicators while the actual network call is in progress. In that case, you can add a conditional early return.
 
-${"```tsx"}
+${"```tsx"}
+if (isPending(${camelCase(descriptor.name)}Resp)) {
+  return <LoadingIndicator />
+}
+${"```"}
+</details>
+
+<details>
+<summary>Inline rendering</summary>
+If you need to show a non-blocking/parallel loading indicator, or change the component behavior based on the loading state, you can inline the loading condition.
+ 
+${"```tsx"}
+<>{isPending(${camelCase(descriptor.name)}Resp) ? <LoadingIndicator /> : null}<MyComponent /></>
+${"```"}
+</details>
+
+#### Error state
+The error state extraction is done using the \`isError\` utility method. Make sure to import the method into your component.
+
+${"```tsx"}
+import { isError } from '@intrig/next';
+${"```"}
+
+<details>
+<summary>Early return</summary>
+In most cases, in an error state, you may want to show the error message to the user instead of real component. In that case, you can add a conditional early return.
+
+${"```tsx"}
+if (isError(${camelCase(descriptor.name)}Resp)) {
+return <ErrorMessage />
+}
+${"```"}
+</details>
+
+<details>
+<summary>Inline rendering</summary>
+If you need to show a non-blocking/parallel error indicator, or change the component behavior based on the error state, you can inline the error condition.
+
+${"```tsx"}
+<>{isError(${camelCase(descriptor.name)}Resp) ? <ErrorMessage /> : null}<MyComponent /></>
+${"```"}
+</details>
+
+<details>
+<summary>Side effect upon error</summary>
+
+Usually if the operation is an update, you may need to show an error message to the user. In such cases, you can add a side effect with useEffect, upon error.
+
+First import \`useEffect\` to your component.
+${"```tsx"}
+import { useEffect } from 'react'
+${"```"}
+
+Then add the side effect.
+${"```tsx"}
+useEffect(() => {
+  if (isError(${camelCase(descriptor.name)}Resp)) {
+    //TODO execute error related operation.
+  }
+}, [${camelCase(descriptor.name)}Resp])
+${"```"}
+</details>
+
+### Replications
+
+<details>
+<summary>Multiple instances for same hook.</summary>
+
+In some case you may need to instanciate multiple instances of the same request. For an example comparision of the products.
+In that cases, you can use \`key\` property to distinguish between these Network states. 
+
+${'```tsx'}
+const [${camelCase(descriptor.name)}Resp, ${camelCase(descriptor.name)}, clear${pascalCase(descriptor.name)}] = use${pascalCase(descriptor.name)}({ key: 'id1' });
+${'```'} 
+</details>
+
+
+`;
+}
+
+;// ../../lib/next-binding/src/lib/templates/source/controller/method/asyncFunctionHook.template.ts
+
+
+function extractAsyncHookShape(response, requestBody, imports) {
+    if (response) {
+        if (requestBody) {
+            imports.add(`import { BinaryFunctionAsyncHook } from "@intrig/next"`);
+            return `BinaryFunctionAsyncHook<Params, RequestBody, Response, _ErrorType>`;
+        } else {
+            imports.add(`import { UnaryFunctionAsyncHook } from "@intrig/next"`);
+            return `UnaryFunctionAsyncHook<Params, Response, _ErrorType>`;
+        }
+    } else {
+        if (requestBody) {
+            imports.add(`import { BinaryProduceAsyncHook } from "@intrig/next"`);
+            return `BinaryProduceAsyncHook<Params, RequestBody, _ErrorType>`;
+        } else {
+            imports.add(`import { UnaryProduceAsyncHook } from "@intrig/next"`);
+            return `UnaryProduceAsyncHook<Params, _ErrorType>`;
+        }
+    }
+}
+function asyncFunctionHook_template_extractErrorParams(errorTypes) {
+    switch(errorTypes.length){
+        case 0:
+            return `
+      export type _ErrorType = any
+      const errorSchema = z.any()`;
+        case 1:
+            return `
+      export type _ErrorType = ${errorTypes[0]}
+      const errorSchema = ${errorTypes[0]}Schema`;
+        default:
+            return `
+      export type _ErrorType = ${errorTypes.join(' | ')}
+      const errorSchema = z.union([${errorTypes.map((a)=>`${a}Schema`).join(', ')}])`;
+    }
+}
+function asyncFunctionHook_template_extractParamDeconstruction(variables, requestBody) {
+    const isParamMandatory = variables?.some((a)=>a.in === 'path') || false;
+    if (requestBody) {
+        if (isParamMandatory) {
+            return {
+                paramExpression: 'data, p',
+                paramType: 'data: RequestBody, params: Params'
+            };
+        } else {
+            return {
+                paramExpression: 'data, p = {}',
+                paramType: 'data: RequestBody, params?: Params'
+            };
+        }
+    } else {
+        if (isParamMandatory) {
+            return {
+                paramExpression: 'p',
+                paramType: 'params: Params'
+            };
+        } else {
+            return {
+                paramExpression: 'p = {}',
+                paramType: 'params?: Params'
+            };
+        }
+    }
+}
+async function nextAsyncFunctionHookTemplate({ source, data: { paths, operationId, response, requestUrl, variables, requestBody, contentType, responseType, errorResponses, method } }, _path, ctx) {
+    const postfix = ctx.potentiallyConflictingDescriptors.includes(operationId) ? generatePostfix(contentType, responseType) : '';
+    const ts = typescript(external_path_namespaceObject.resolve(_path, 'src', source, ...paths, camelCase(operationId), `use${pascalCase(operationId)}Async${postfix}.ts`));
+    const modifiedRequestUrl = `${requestUrl?.replace(/\{/g, "${")}`;
+    const imports = new Set();
+    // Basic imports
+    imports.add(`import { z } from 'zod'`);
+    imports.add(`import { useCallback } from 'react'`);
+    imports.add(`import { useTransientCall, encode, isError, isSuccess } from '@intrig/next'`);
+    // Hook signature type
+    const hookShape = extractAsyncHookShape(response, requestBody, imports);
+    // Add body/response param imports
+    if (requestBody) {
+        imports.add(`import { ${requestBody} as RequestBody, ${requestBody}Schema as requestBodySchema } from "@intrig/next/${source}/components/schemas/${requestBody}"`);
+    }
+    if (response) {
+        imports.add(`import { ${response} as Response, ${response}Schema as schema } from "@intrig/next/${source}/components/schemas/${response}"`);
+    }
+    imports.add(`import { ${pascalCase(operationId)}Params as Params } from './${pascalCase(operationId)}.params'`);
+    // Error types
+    const errorTypes = [
+        ...new Set(Object.values(errorResponses ?? {}).map((a)=>a.response))
+    ];
+    errorTypes.forEach((ref)=>imports.add(`import { ${ref}, ${ref}Schema } from "@intrig/next/${source}/components/schemas/${ref}"`));
+    // Error schema block
+    const errorSchemaBlock = asyncFunctionHook_template_extractErrorParams(errorTypes.map((a)=>a));
+    // Param deconstruction
+    const { paramExpression, paramType } = asyncFunctionHook_template_extractParamDeconstruction(variables ?? [], requestBody);
+    const paramExplode = [
+        ...variables?.filter((a)=>a.in === 'path').map((a)=>a.name) ?? [],
+        '...params'
+    ].join(',');
+    const finalRequestBodyBlock = requestBody ? `, data: encode(data, "${contentType}", requestBodySchema)` : '';
+    function responseTypePart() {
+        switch(responseType){
+            case "application/octet-stream":
+                return `responseType: 'blob', adapter: 'fetch',`;
+            case "text/event-stream":
+                return `responseType: 'stream', adapter: 'fetch',`;
+        }
+        return '';
+    }
+    return ts`
+${[
+        ...imports
+    ].join('\n')}
+
+${!response ? `
+type Response = any;
+const schema = z.any();
+` : ''}
+
+${errorSchemaBlock}
+
+const operation = "${method.toUpperCase()} ${requestUrl}| ${contentType} -> ${responseType}";
+const source = "${source}";
+
+function use${pascalCase(operationId)}AsyncHook(): [(${paramType}) => Promise<Response>, () => void] {
+  const [call, abort] = useTransientCall<Response, _ErrorType>({
+    schema,
+    errorSchema
+  });
+
+  const doExecute = useCallback<(${paramType}) => Promise<Response>>(async (${paramExpression}) => {
+    let { ${paramExplode} } = p;
+
+    ${requestBody ? `
+    const validationResult = requestBodySchema.safeParse(data);
+    if (!validationResult.success) {
+      return Promise.reject(validationResult.error);
+    }
+    ` : ''}
+
+    return await call({
+      method: '${method}',
+      url: \`${modifiedRequestUrl}\`,
+      headers: {
+        ${contentType ? `"Content-Type": "${contentType}",` : ''}
+      },
+      params,
+      key: \`${"${source}: ${operation}"}\`,
+      source: '${source}'
+      ${requestBody ? finalRequestBodyBlock : ''},
+      ${responseTypePart()}
+    });
+  }, [call]);
+
+  return [doExecute, abort];
+}
+
+use${pascalCase(operationId)}AsyncHook.key = \`${"${source}: ${operation}"}\`;
+
+export const use${pascalCase(operationId)}Async: ${hookShape} = use${pascalCase(operationId)}AsyncHook;
+  `;
+}
+
+;// ../../lib/next-binding/src/lib/templates/type-utils.template.ts
+
+
+function typeUtilsTemplate(_path) {
+    const ts = typescript(external_path_default().resolve(_path, 'src', 'type-utils.ts'));
+    return ts`import { z } from 'zod';
+
+export type BinaryData = Blob;
+export const BinaryDataSchema: z.ZodType<BinaryData> = z.instanceof(Blob);
+
+// Base64 helpers (browser + Node compatible; no Buffer required)
+export function base64ToUint8Array(b64: string): Uint8Array {
+  if (typeof atob === 'function') {
+    // Browser
+    const bin = atob(b64);
+    const bytes = new Uint8Array(bin.length);
+    for (let i = 0; i < bin.length; i++) bytes[i] = bin.charCodeAt(i);
+    return bytes;
+  } else {
+    // Node
+    const buf = Buffer.from(b64, 'base64');
+    return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+  }
+}
+
+  `;
+}
+
+;// ../../lib/next-binding/src/lib/templates/docs/sse-hook.ts
+
+function nextSseHookDocs(descriptor) {
+    const md = mdLiteral('sse-hook.md');
+    const requestBody = descriptor.data.requestBody ? camelCase(descriptor.data.requestBody) : undefined;
+    const params = descriptor.data.variables?.filter((a)=>a.in.toUpperCase() === 'PATH')?.length ? 'params' : undefined;
+    return md`
+> Intrig-generated hooks are intended for backend data integration. They follow the same tuple-based API pattern as React's built-in state hooks (e.g. useState). 
+
+## Imports
+
+#### Import the hook to the component.
+${"```ts"}
+import { use${pascalCase(descriptor.name)} } from '@intrig/next/${descriptor.path}/client';
+${"```"}
+
+#### Import the utility methods.
+${"```ts"}
+import { isSuccess } from '@intrig/next';
+${"```"}
+
+#### Use hook inside the component.
+
+${"```tsx"}
+const [${camelCase(descriptor.name)}Resp, ${camelCase(descriptor.name)}, clear${pascalCase(descriptor.name)}] = use${pascalCase(descriptor.name)}();
+${"```"}
+
+### Usage
+
+#### Execute data fetching.
+
+${"```tsx"}
+useEffect(() => {
+  ${camelCase(descriptor.name)}(${[
+        requestBody,
+        params ?? '{}'
+    ].filter(Boolean).join(', ')}); 
+}, [${[
+        requestBody,
+        params
+    ].filter(Boolean).join(', ')}/* Dependencies */])  
+${"```"}
+
+#### Extract data from the response.
+\`SSE\` hooks are a special kind of hook that delivers intermediate data updates as they are received.
+
+##### Minimal example.
+${"```tsx"}
+const ${camelCase(descriptor.name)} = isPending(${camelCase(descriptor.name)}Resp) ? ${camelCase(descriptor.name)}Resp.data : null;
+${"```"}
+
+### Full example.
+
+#### Short format.
+You can pass the request body and params as props to the hook for initial data binding. This will create the data to be tightly coupled
+with the component lifecycle.
+
+> Usually the SSE-hooks are combined with a collector mechanism to get the complete message. 
+
+<details>
+<summary>Implementation</summary>
+
+${"```tsx"}
+import { use${pascalCase(descriptor.name)} } from '@intrig/next/${descriptor.path}/client';
+import { isSuccess, isPending, isError } from '@intrig/next';
+${requestBody ? `import { ${pascalCase(requestBody)} } from '@intrig/next/${descriptor.source}/components/schemas/${pascalCase(requestBody)}';` : ''}
+${params ? `import { ${pascalCase(params)}Params } from '@intrig/next/${descriptor.path}/${pascalCase(descriptor.name)}.params';` : ''}
+import { useState, useEffect } from 'react';
+import { LoadingIndicator, ErrorDisplay } from '@/components/ui'; //import from your project.
+import {flushSync} from "react-dom";
+
+${requestBody || params ? `
+interface MyComponentProps {
+  ${requestBody ? `${camelCase(requestBody)}: ${pascalCase(requestBody)};` : ''}
+  ${params ? `${camelCase(params)}Params: ${pascalCase(params)}Params;` : ''}
+}
+` : ''}
+
+function MyComponent(${requestBody || params ? 'props: MyComponentProps' : ''}) { 
+const [${camelCase(descriptor.name)}Resp] = use${pascalCase(descriptor.name)}({
+  fetchOnMount: true,
+  clearOnUnmount: true,
+  ${requestBody ? `body: props.${camelCase(requestBody)},` : ''}
+  ${params ? `params: props.${camelCase(params)},` : 'params: {}'}
+});
+
+let [data, setData] = useState<${pascalCase(descriptor.name)}[]>([]);
+
+useEffect(() => {
+  if (isPending(${camelCase(descriptor.name)}Resp)) {
+    flushSync(() => {                                                     //Sometimes react tends to skip intermediate renders for the performance. Use flushSync if you need to keep track of messages. 
+      setData(data => [...data, ${camelCase(descriptor.name)}Resp.data]);
+    })
+  }
+}, [${camelCase(descriptor.name)}Resp])
+
+if (isPending(${camelCase(descriptor.name)}Resp)) {
+  return <>{data.map(a => <>{JSON.stringify(a)}</>)}</>
+}
+
+if (isError(${camelCase(descriptor.name)}Resp)) {
+  return <ErrorDisplay error={${camelCase(descriptor.name)}Resp.error}/> //TODO add your error view here.
+}
+
+return <> 
+  Completed: {JSON.stringify(data)}  
+</>
+}
+${"```"}
+</details>
+
+#### Controlled format.
+If you need more control over the data binding, where the data control is outside of the component lifecycle, 
+you can use the actions provided by the hook.
+
+<details>
+<summary>Implementation</summary>
+
+${"```tsx"}
+import { use${pascalCase(descriptor.name)} } from '@intrig/next/${descriptor.path}/client';
+import { isSuccess } from '@intrig/next';
+${requestBody ? `import { ${pascalCase(requestBody)} } from '@intrig/next/${descriptor.source}/components/schemas/${pascalCase(requestBody)}';` : ''}
+${params ? `import { ${pascalCase(params)}Params } from '@intrig/next/${descriptor.path}/${pascalCase(descriptor.name)}.params';` : ''}
+import {flushSync} from "react-dom";
+
+${requestBody || params ? `
+interface MyComponentProps {
+  ${requestBody ? `${camelCase(requestBody)}: ${pascalCase(requestBody)};` : ''}
+  ${params ? `${camelCase(params)}Params: ${pascalCase(params)}Params;` : ''}
+}
+` : ''}
+
+function MyComponent() {
+const [${camelCase(descriptor.name)}Resp, ${camelCase(descriptor.name)}, clear${pascalCase(descriptor.name)}] = use${pascalCase(descriptor.name)}();
+
+useEffect(() => { 
+  ${camelCase(descriptor.name)}(${requestBody ? `${camelCase(requestBody)},` : ''} ${params ? `${camelCase(params)},` : '{}'}) //Call the fetch function. 
+  return clear${pascalCase(descriptor.name)}; //Clear the data on unmount.
+}, [])
+
+let [data, setData] = useState<${pascalCase(descriptor.name)}[]>([]);
+
+useEffect(() => {
+  if (isPending(${camelCase(descriptor.name)}Resp)) {
+    flushSync(() => {                                                     //Sometimes react tends to skip intermediate renders for the performance. Use flushSync if you need to keep track of messages. 
+      setData(data => [...data, ${camelCase(descriptor.name)}Resp.data]);
+    })
+  }
+}, [${camelCase(descriptor.name)}Resp])
+
 if (isPending(${camelCase(descriptor.name)}Resp)) {
-  return <LoadingIndicator />
+  return <>{data.map(a => <>{JSON.stringify(a)}</>)}</>
 }
-${"```"}
-</details>
 
-<details>
-<summary>Inline rendering</summary>
-If you need to show a non-blocking/parallel loading indicator, or change the component behavior based on the loading state, you can inline the loading condition.
- 
-${"```tsx"}
-<>{isPending(${camelCase(descriptor.name)}Resp) ? <LoadingIndicator /> : null}<MyComponent /></>
+if (isError(${camelCase(descriptor.name)}Resp)) {
+  return <ErrorDisplay error={${camelCase(descriptor.name)}Resp.error}/> //TODO add your error view here.
+}
+
+return <> 
+  Completed: {JSON.stringify(data)}  
+</>
+}
 ${"```"}
 </details>
 
-#### Error state
-The error state extraction is done using the \`isError\` utility method. Make sure to import the method into your component.
+  `;
+}
 
-${"```tsx"}
-import { isError } from '@intrig/next';
-${"```"}
+;// ../../lib/next-binding/src/lib/templates/docs/async-hook.ts
 
-<details>
-<summary>Early return</summary>
-In most cases, in an error state, you may want to show the error message to the user instead of real component. In that case, you can add a conditional early return.
+function nextAsyncFunctionHookDocs(descriptor) {
+    const md = mdLiteral('async-hook.md');
+    const requestBody = descriptor.data.requestBody ? camelCase(descriptor.data.requestBody) : undefined;
+    const params = descriptor.data.variables?.filter((a)=>a.in.toUpperCase() === 'PATH')?.length ? 'params' : undefined;
+    return md`
+  
+> Intrig generated async hooks are intended to use for the rapid usecases like validations. This effectively bypasses the network-state management.
+> The async hooks follow the tuple-based API pattern as React's built-in state hooks (e.g. useState).
 
-${"```tsx"}
-if (isError(${camelCase(descriptor.name)}Resp)) {
-return <ErrorMessage />
-}
+## Imports
+
+#### Import the hook to the component.
+${"```ts"}
+import { use${pascalCase(descriptor.name)}Async } from '@intrig/next/${descriptor.path}/client';
 ${"```"}
-</details>
 
-<details>
-<summary>Inline rendering</summary>
-If you need to show a non-blocking/parallel error indicator, or change the component behavior based on the error state, you can inline the error condition.
+#### Use hook inside the component.
 
 ${"```tsx"}
-<>{isError(${camelCase(descriptor.name)}Resp) ? <ErrorMessage /> : null}<MyComponent /></>
+const [${camelCase(descriptor.name)}, abort${pascalCase(descriptor.name)}] = use${pascalCase(descriptor.name)}Async();
 ${"```"}
-</details>
-
-<details>
-<summary>Side effect upon error</summary>
 
-Usually if the operation is an update, you may need to show an error message to the user. In such cases, you can add a side effect with useEffect, upon error.
+#### Execute data fetching / calling.
 
-First import \`useEffect\` to your component.
 ${"```tsx"}
-import { useEffect } from 'react'
-${"```"}
+const fn = useCallback(async () => {
+  let ${camelCase(descriptor.name)}Data = await ${camelCase(descriptor.name)}(${[
+        requestBody,
+        params ?? '{}'
+    ].filter(Boolean).join(', ')});
+  //TODO do something with the ${camelCase(descriptor.name)}Data.
+  return ${camelCase(descriptor.name)}Data; 
+}, [${[
+        requestBody,
+        params
+    ].filter(Boolean).join(', ')}/* Dependencies */])
 
-Then add the side effect.
-${"```tsx"}
-useEffect(() => {
-  if (isError(${camelCase(descriptor.name)}Resp)) {
-    //TODO execute error related operation.
-  }
-}, [${camelCase(descriptor.name)}Resp])
 ${"```"}
-</details>
 
-### Replications
+## Full example
 
 <details>
-<summary>Multiple instances for same hook.</summary>
+<summary>Implementation</summary>
 
-In some case you may need to instanciate multiple instances of the same request. For an example comparision of the products.
-In that cases, you can use \`key\` property to distinguish between these Network states. 
+${"```tsx"}
+import { use${pascalCase(descriptor.name)}Async } from '@intrig/next/${descriptor.path}/client';
+${requestBody ? `import { ${pascalCase(requestBody)} } from '@intrig/next/${descriptor.source}/components/schemas/${pascalCase(requestBody)}';` : ''}
+${params ? `import { ${pascalCase(params)}Params } from '@intrig/next/${descriptor.path}/${pascalCase(descriptor.name)}.params';` : ''}
+import { useCallback } from 'react';
 
-${'```tsx'}
-const [${camelCase(descriptor.name)}Resp, ${camelCase(descriptor.name)}, clear${pascalCase(descriptor.name)}] = use${pascalCase(descriptor.name)}({ key: 'id1' });
-${'```'} 
-</details>
+${requestBody || params ? `
+interface MyComponentProps {
+  ${requestBody ? `${camelCase(requestBody)}: ${pascalCase(requestBody)};` : ''}
+  ${params ? `${camelCase(params)}Params: ${pascalCase(params)}Params;` : ''}
+}
+` : ''}
 
+function MyComponent(${requestBody || params ? 'props: MyComponentProps' : ''}) {
+const [${camelCase(descriptor.name)}, abort${pascalCase(descriptor.name)}] = use${pascalCase(descriptor.name)}Async();
 
-`;
+const fn = useCallback(async (${[
+        requestBody,
+        params
+    ].filter(Boolean).join(', ')}) => {
+  return await ${camelCase(descriptor.name)}(${[
+        requestBody,
+        params
+    ].filter(Boolean).join(', ')});
+}, [/* Dependencies */])
+
+//use fn where remote callback is needed.
+return <>
+  <button onClick={() => fn(${[
+        requestBody,
+        params
+    ].filter(Boolean).map((a)=>`props.${a}`).join(', ')})}>Call remote</button>  
+</>
+}
+ 
+${"```"}
+</details>
+
+<hint>
+//TODO improve with usecases
+</hint>
+  
+  `;
 }
 
 ;// ../../lib/next-binding/src/lib/next-binding.service.ts
@@ -5641,6 +6172,10 @@ function next_binding_service_ts_metadata(k, v) {
 
 
 
+
+
+
+
 
 
 
@@ -5650,11 +6185,12 @@ const nonDownloadMimePatterns = external_picomatch_default()([
     "application/json",
     "application/xml",
     "application/x-www-form-urlencoded",
+    "application/event-stream",
     "text/*"
 ]);
 class IntrigNextBindingService extends GeneratorBinding {
     constructor(sourceManagementService, config){
-        super(), this.sourceManagementService = sourceManagementService, this.config = config, this.dump = this.sourceManagementService.dump, this._path = this.config.get("generatedDir") ?? external_path_default().resolve(external_node_process_namespaceObject.cwd(), '.intrig', 'generated');
+        super(), this.sourceManagementService = sourceManagementService, this.config = config, this.logger = new common_namespaceObject.Logger(IntrigNextBindingService.name), this.dump = this.sourceManagementService.dump, this._path = this.config.get("generatedDir") ?? external_path_default().resolve(external_node_process_namespaceObject.cwd(), '.intrig', 'generated');
     }
     getRestOptions() {
         return {
@@ -5686,12 +6222,19 @@ class IntrigNextBindingService extends GeneratorBinding {
         await this.dump(nextExtraTemplate(this._path));
         await this.dump(nextLoggerTemplate(this._path));
         await this.dump(nextSwcrcTemplate(this._path));
+        await this.dump(typeUtilsTemplate(this._path));
     }
     async generateSource(descriptors, source) {
+        //TODO improve this logic to catch potential conflicts.
+        const potentiallyConflictingDescriptors = descriptors.filter(isRestDescriptor).sort((a, b)=>(a.data.contentType === "application/json" ? -1 : 0) - (b.data.contentType === "application/json" ? -1 : 0)).filter((descriptor, index, array)=>array.findIndex((other)=>other.data.operationId === descriptor.data.operationId) !== index).map((descriptor)=>descriptor.id);
+        const ctx = {
+            potentiallyConflictingDescriptors
+        };
         const groupedByPath = {};
         for (const descriptor of descriptors){
+            this.logger.log(`Generating source: ${descriptor.name}`);
             if (isRestDescriptor(descriptor)) {
-                await this.generateRestSource(source, descriptor);
+                await this.generateRestSource(source, descriptor, ctx);
                 groupedByPath[descriptor.data.requestUrl] = groupedByPath[descriptor.data.requestUrl] || [];
                 groupedByPath[descriptor.data.requestUrl].push(descriptor);
             } else if (isSchemaDescriptor(descriptor)) {
@@ -5702,14 +6245,14 @@ class IntrigNextBindingService extends GeneratorBinding {
             await this.dump(nextRequestRouteTemplate(requestUrl, matchingPaths, this._path));
         }
     }
-    async generateRestSource(source, descriptor) {
+    async generateRestSource(source, descriptor, ctx) {
         const clientExports = [];
         const serverExports = [];
         await this.dump(nextParamsTemplate(descriptor, clientExports, serverExports, this._path));
         await this.dump(nextRequestHookTemplate(descriptor, clientExports, serverExports, this._path));
         await this.dump(nextRequestMethodTemplate(descriptor, clientExports, serverExports, this._path));
-        //TODO incorporate rest options.
-        if (descriptor.data.method.toUpperCase() === 'GET' && !nonDownloadMimePatterns(descriptor.data.responseType)) {
+        await this.dump(nextAsyncFunctionHookTemplate(descriptor, this._path, ctx));
+        if (descriptor.data.method.toUpperCase() === 'GET' && (!nonDownloadMimePatterns(descriptor.data.responseType) || descriptor.data.responseType !== '*/*') || descriptor.data.responseHeaders?.['content-disposition']) {
             await this.dump(nextDownloadHookTemplate(descriptor, clientExports, serverExports, this._path));
         }
         await this.dump(nextClientIndexTemplate([
@@ -5796,16 +6339,20 @@ ${"```"}
             ]));
         const tabs = [];
         if (result.data.responseType === 'text/event-stream') {
-        // tabs.push({
-        //   name: 'SSE Hook',
-        //   content: (await sseHookDocs(result)).content
-        // })
+            tabs.push({
+                name: 'SSE Hook',
+                content: (await nextSseHookDocs(result)).content
+            });
         } else {
             tabs.push({
                 name: 'React Hook',
                 content: (await nextReactHookDocs(result)).content
             });
         }
+        tabs.push({
+            name: 'Async Hook',
+            content: (await nextAsyncFunctionHookDocs(result)).content
+        });
         return RestDocumentation.from({
             id: result.id,
             name: result.name,
@@ -7114,6 +7661,7 @@ function reactPackageJsonTemplate(_path) {
     "@swc/cli": "^0.7.7",
     "@swc/core": "^1.12.6",
     "@types/node": "^24.0.4",
+    "typescript": "${packageJson.devDependencies.typescript ?? packageJson.dependencies.typescript}",
     "react": "${packageJson.dependencies.react}",
     "react-dom": "${packageJson.dependencies['react-dom']}"
   },
@@ -7913,6 +8461,15 @@ async function reactRequestHookTemplate({ source, data: { paths, operationId, re
         "...params"
     ].join(",");
     const finalRequestBodyBlock = requestBody ? `,data: encode(data, "${contentType}", requestBodySchema)` : '';
+    function responseTypePart() {
+        switch(responseType){
+            case "application/octet-stream":
+                return `responseType: 'blob', adapter: 'fetch',`;
+            case "text/event-stream":
+                return `responseType: 'stream', adapter: 'fetch',`;
+        }
+        return '';
+    }
     return ts`
     ${[
         ...imports
@@ -7957,7 +8514,7 @@ async function reactRequestHookTemplate({ source, data: { paths, operationId, re
             key: \`${"${source}: ${operation}"}\`,
             source: '${source}'
             ${requestBody ? finalRequestBodyBlock : ''},
-            ${responseType === "text/event-stream" ? `responseType: 'stream', adapter: 'fetch',` : ''}
+            ${responseTypePart()}
           })
           return successfulDispatch();
       }, [dispatch])
@@ -8097,6 +8654,15 @@ async function reactDownloadHookTemplate({ source, data: { paths, operationId, r
         "...params"
     ].join(",");
     const finalRequestBodyBlock = requestBody ? `,data: encode(data, "${contentType}", requestBodySchema)` : '';
+    function responseTypePart() {
+        switch(responseType){
+            case "application/octet-stream":
+                return `responseType: 'blob', adapter: 'fetch',`;
+            case "text/event-stream":
+                return `responseType: 'stream', adapter: 'fetch',`;
+        }
+        return '';
+    }
     return ts`
     ${[
         ...imports
@@ -8175,7 +8741,7 @@ async function reactDownloadHookTemplate({ source, data: { paths, operationId, r
             key: \`${"${source}: ${operation}"}\`,
             source: '${source}'
             ${requestBody ? finalRequestBodyBlock : ''},
-            ${responseType === "text/event-stream" ? `responseType: 'stream', adapter: 'fetch',` : ''}
+            ${responseTypePart()}
           })
           return successfulDispatch();
       }, [dispatch])
@@ -9068,7 +9634,7 @@ ${"```"}
 ;// ../../lib/react-binding/src/lib/templates/source/controller/method/asyncFunctionHook.template.ts
 
 
-function extractAsyncHookShape(response, requestBody, imports) {
+function asyncFunctionHook_template_extractAsyncHookShape(response, requestBody, imports) {
     if (response) {
         if (requestBody) {
             imports.add(`import { BinaryFunctionAsyncHook } from "@intrig/react"`);
@@ -9087,7 +9653,7 @@ function extractAsyncHookShape(response, requestBody, imports) {
         }
     }
 }
-function asyncFunctionHook_template_extractErrorParams(errorTypes) {
+function method_asyncFunctionHook_template_extractErrorParams(errorTypes) {
     switch(errorTypes.length){
         case 0:
             return `
@@ -9103,7 +9669,7 @@ function asyncFunctionHook_template_extractErrorParams(errorTypes) {
       const errorSchema = z.union([${errorTypes.map((a)=>`${a}Schema`).join(', ')}])`;
     }
 }
-function asyncFunctionHook_template_extractParamDeconstruction(variables, requestBody) {
+function method_asyncFunctionHook_template_extractParamDeconstruction(variables, requestBody) {
     const isParamMandatory = variables?.some((a)=>a.in === 'path') || false;
     if (requestBody) {
         if (isParamMandatory) {
@@ -9141,7 +9707,7 @@ async function reactAsyncFunctionHookTemplate({ source, data: { paths, operation
     imports.add(`import { useCallback } from 'react'`);
     imports.add(`import { useTransientCall, encode, isError, isSuccess } from '@intrig/react'`);
     // Hook signature type
-    const hookShape = extractAsyncHookShape(response, requestBody, imports);
+    const hookShape = asyncFunctionHook_template_extractAsyncHookShape(response, requestBody, imports);
     // Add body/response param imports
     if (requestBody) {
         imports.add(`import { ${requestBody} as RequestBody, ${requestBody}Schema as requestBodySchema } from "@intrig/react/${source}/components/schemas/${requestBody}"`);
@@ -9156,14 +9722,23 @@ async function reactAsyncFunctionHookTemplate({ source, data: { paths, operation
     ];
     errorTypes.forEach((ref)=>imports.add(`import { ${ref}, ${ref}Schema } from "@intrig/react/${source}/components/schemas/${ref}"`));
     // Error schema block
-    const errorSchemaBlock = asyncFunctionHook_template_extractErrorParams(errorTypes.map((a)=>a));
+    const errorSchemaBlock = method_asyncFunctionHook_template_extractErrorParams(errorTypes.map((a)=>a));
     // Param deconstruction
-    const { paramExpression, paramType } = asyncFunctionHook_template_extractParamDeconstruction(variables ?? [], requestBody);
+    const { paramExpression, paramType } = method_asyncFunctionHook_template_extractParamDeconstruction(variables ?? [], requestBody);
     const paramExplode = [
         ...variables?.filter((a)=>a.in === 'path').map((a)=>a.name) ?? [],
         '...params'
     ].join(',');
     const finalRequestBodyBlock = requestBody ? `, data: encode(data, "${contentType}", requestBodySchema)` : '';
+    function responseTypePart() {
+        switch(responseType){
+            case "application/octet-stream":
+                return `responseType: 'blob', adapter: 'fetch',`;
+            case "text/event-stream":
+                return `responseType: 'stream', adapter: 'fetch',`;
+        }
+        return '';
+    }
     return ts`
 ${[
         ...imports
@@ -9205,7 +9780,7 @@ function use${pascalCase(operationId)}AsyncHook(): [(${paramType}) => Promise<Re
       key: \`${"${source}: ${operation}"}\`,
       source: '${source}'
       ${requestBody ? finalRequestBodyBlock : ''},
-      ${responseType === "text/event-stream" ? `responseType: 'stream', adapter: 'fetch',` : ''}
+      ${responseTypePart()}
     });
   }, [call]);
 
@@ -9312,27 +9887,12 @@ ${"```"}
 ;// ../../lib/react-binding/src/lib/templates/type-utils.template.ts
 
 
-function typeUtilsTemplate(_path) {
+function type_utils_template_typeUtilsTemplate(_path) {
     const ts = typescript(external_path_default().resolve(_path, 'src', 'type-utils.ts'));
     return ts`import { z } from 'zod';
 
-export type BinaryData = Blob | ArrayBuffer | Uint8Array;
-
-export const BinaryDataSchema = z.union([
-  // Blob in browsers
-  z.instanceof(Blob).optional(), // optional here so union below still validates if Blob is absent in Node
-  // Raw buffers
-  z.instanceof(ArrayBuffer),
-  z.custom<Uint8Array>((v) => v instanceof Uint8Array, { message: 'Expected Uint8Array' }),
-]).transform((v) => {
-  // Normalize to Blob if possible (nice for downloads in browser)
-  if (typeof Blob !== 'undefined') {
-    if (v instanceof Blob) return v;
-    if (v instanceof ArrayBuffer) return new Blob([v]);
-    if (v instanceof Uint8Array) return new Blob([v.buffer]);
-  }
-  return v;
-});
+export type BinaryData = Blob;
+export const BinaryDataSchema: z.ZodType<BinaryData> = z.instanceof(Blob);
 
 // Base64 helpers (browser + Node compatible; no Buffer required)
 export function base64ToUint8Array(b64: string): Uint8Array {
@@ -9412,7 +9972,7 @@ class ReactBindingService extends GeneratorBinding {
         await this.dump(reactPackageJsonTemplate(this._path));
         await this.dump(reactProviderTemplate(this._path, apisToSync));
         await this.dump(reactTsConfigTemplate(this._path));
-        await this.dump(typeUtilsTemplate(this._path));
+        await this.dump(type_utils_template_typeUtilsTemplate(this._path));
     }
     async generateSource(descriptors, source) {
         //TODO improve this logic to catch potential conflicts.
@@ -10742,10 +11302,13 @@ function deref(spec) {
     };
 }
 
+;// external "node:crypto"
+const external_node_crypto_namespaceObject = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("node:crypto");
 ;// ../../lib/openapi-source/src/lib/util/normalize.ts
 
 
 
+
 function generateTypeName(operationOb, postFix) {
     return [
         operationOb.tags?.[0],
@@ -10755,7 +11318,7 @@ function generateTypeName(operationOb, postFix) {
 }
 function normalize(spec) {
     const doDeref = deref(spec);
-    return (0,external_immer_namespaceObject.produce)(spec, (draft)=>{
+    const normalized = (0,external_immer_namespaceObject.produce)(spec, (draft)=>{
         const paths = draft.paths;
         for (const [path, pathItem] of Object.entries(paths)){
             const pathItemObject = pathItem;
@@ -10860,6 +11423,9 @@ function normalize(spec) {
         }
     //TODO implement fix schema types.
     });
+    return (0,external_immer_namespaceObject.produce)(normalized, (draft)=>{
+        draft.info['x-intrig-hash'] = (0,external_node_crypto_namespaceObject.createHash)('sha256').update(JSON.stringify(draft)).digest('hex');
+    });
 }
 
 ;// ../../lib/openapi-source/src/lib/util/extractRequestsFromSpec.ts
@@ -11003,26 +11569,47 @@ class IntrigOpenapiService {
     }
     async sync(config, id, ctx) {
         this.logger.log('Starting OpenAPI sync process');
+        const errors = [];
         if (!id) {
+            // Process all sources with better error isolation
             for (const source of config.sources){
                 this.logger.log(`Processing source: ${source.id}`);
                 try {
                     await this.doSync(source, config, ctx);
+                    this.logger.log(`Successfully synced source: ${source.id}`);
                 } catch (e) {
-                    this.logger.error(`Failed to sync source ${source.id}: ${e.message}`, e);
+                    const errorMsg = `Failed to sync source ${source.id}: ${e.message}`;
+                    this.logger.error(errorMsg, e);
+                    errors.push({
+                        sourceId: source.id,
+                        error: errorMsg
+                    });
+                // Continue with other sources instead of failing completely
                 }
             }
         } else {
             const source = config.sources.find((s)=>s.id === id);
             if (!source) {
-                this.logger.error(`Source ${id} not found`);
-                throw new Error(`Source ${id} not found`);
+                const error = `Source ${id} not found`;
+                this.logger.error(error);
+                throw new Error(error);
             }
             this.logger.log(`Processing specific source: ${id}`);
             try {
                 await this.doSync(source, config, ctx);
+                this.logger.log(`Successfully synced source: ${id}`);
             } catch (e) {
-                this.logger.error(`Failed to sync source ${id}: ${e.message}`, e);
+                const errorMsg = `Failed to sync source ${id}: ${e.message}`;
+                this.logger.error(errorMsg, e);
+                throw new Error(errorMsg);
+            }
+        }
+        if (errors.length > 0) {
+            const summary = `Sync completed with ${errors.length} errors: ${errors.map((e)=>e.sourceId).join(', ')}`;
+            this.logger.warn(summary);
+            // If all sources failed, throw an error
+            if (errors.length === config.sources.length) {
+                throw new Error(`All sources failed to sync: ${errors.map((e)=>e.error).join('; ')}`);
             }
         }
         this.logger.log('OpenAPI sync process completed');
@@ -11068,7 +11655,8 @@ class IntrigOpenapiService {
         const restData = extractRequestsFromSpec(document);
         const schemas = extractSchemas(document);
         const sha1 = (str)=>external_crypto_namespaceObject.createHash('sha1').update(str).digest('hex');
-        return [
+        const hash = document.info['x-intrig-hash'];
+        const descriptors = [
             ...restData.map((restData)=>ResourceDescriptor.from({
                     id: sha1(`${id}_${restData.method}_${restData.paths.join('_')}_${restData.operationId}_${restData.contentType}_${restData.responseType}`),
                     name: camelCase(restData.operationId),
@@ -11086,6 +11674,17 @@ class IntrigOpenapiService {
                     data: schema
                 }))
         ];
+        return {
+            descriptors,
+            hash
+        };
+    }
+    async getHash(id) {
+        const document = await this.specManagementService.read(id);
+        if (!document) {
+            throw new Error(`Spec ${id} not found`);
+        }
+        return document.info['x-intrig-hash'];
     }
     validate(normalized, restOptions) {
         function validateForConflictingVariables() {
@@ -11676,7 +12275,7 @@ class SearchService {
     async onModuleInit() {
         try {
             for (const source of this.configService.get().sources){
-                const descriptors = await this.openApiService.getResourceDescriptors(source.id);
+                const { descriptors } = await this.openApiService.getResourceDescriptors(source.id);
                 descriptors.forEach((descriptor)=>this.addDescriptor(descriptor));
             }
             // Update the CodeAnalyzer with all descriptors
@@ -11968,24 +12567,50 @@ class OperationsService {
         this.config = config;
         this.searchService = searchService;
         this.logger = new common_namespaceObject.Logger(OperationsService.name);
+        // Add sync coordination
+        this.syncInProgress = new Set();
+        this.SYNC_TIMEOUT = 300000; // 5 minutes timeout
         this.generateDir = this.config.get("generatedDir") ?? external_path_namespaceObject.resolve(process.cwd(), ".intrig", "generated");
     }
     async getConfig(ctx) {
         return this.configService.get();
     }
     async sync(ctx, id) {
-        const config = await this.getConfig(ctx);
-        const prevDescriptors = await this.getPreviousState(ctx, config);
-        const restOptions = this.generatorBinding.getRestOptions();
-        await this.openApiService.sync({
-            ...config,
-            restOptions: {
-                ...config.restOptions,
-                ...restOptions
-            }
-        }, id, ctx);
-        const newDescriptors = await this.getNewState(ctx, config);
-        await this.indexDiff(ctx, prevDescriptors, newDescriptors);
+        const syncKey = id || 'all';
+        // Check if sync is already in progress
+        if (this.syncInProgress.has(syncKey)) {
+            const error = `Sync already in progress for: ${syncKey}`;
+            this.logger.warn(error);
+            throw new Error(error);
+        }
+        // Add timeout protection
+        const timeoutId = setTimeout(()=>{
+            this.syncInProgress.delete(syncKey);
+            this.logger.error(`Sync timeout for ${syncKey} after ${this.SYNC_TIMEOUT}ms`);
+        }, this.SYNC_TIMEOUT);
+        this.syncInProgress.add(syncKey);
+        this.logger.log(`Starting sync operation for: ${syncKey}`);
+        try {
+            const config = await this.getConfig(ctx);
+            const prevDescriptors = await this.getPreviousState(ctx, config);
+            const restOptions = this.generatorBinding.getRestOptions();
+            await this.openApiService.sync({
+                ...config,
+                restOptions: {
+                    ...config.restOptions,
+                    ...restOptions
+                }
+            }, id, ctx);
+            const newDescriptors = await this.getNewState(ctx, config);
+            await this.indexDiff(ctx, prevDescriptors, newDescriptors);
+            this.logger.log(`Sync operation completed successfully for: ${syncKey}`);
+        } catch (error) {
+            this.logger.error(`Sync operation failed for ${syncKey}: ${error.message}`, error);
+            throw error;
+        } finally{
+            clearTimeout(timeoutId);
+            this.syncInProgress.delete(syncKey);
+        }
     }
     async indexDiff(ctx, prevDescriptors, newDescriptors) {
         this.searchService.clearAll();
@@ -11993,21 +12618,36 @@ class OperationsService {
     }
     async getPreviousState(ctx, config) {
         let prevDescriptors = [];
+        const errors = [];
         for (const source of config.sources){
             try {
-                const descriptors = await this.openApiService.getResourceDescriptors(source.id);
+                const { descriptors } = await this.openApiService.getResourceDescriptors(source.id);
                 prevDescriptors = [
                     ...prevDescriptors,
                     ...descriptors
                 ];
-            } catch (e) {}
+                this.logger.debug(`Loaded ${descriptors.length} descriptors from source ${source.id}`);
+            } catch (e) {
+                const errorMsg = `Failed to load previous state for source ${source.id}: ${e.message}`;
+                this.logger.warn(errorMsg);
+                errors.push(errorMsg);
+                // If it's a critical error (not just missing file), we might want to fail
+                if (e.message.includes('Invalid JSON') || e.message.includes('corrupted')) {
+                    throw new Error(`Critical error in getPreviousState: ${errorMsg}`);
+                }
+            }
+        }
+        if (errors.length > 0) {
+            this.logger.warn(`getPreviousState completed with ${errors.length} errors: ${errors.join('; ')}`);
         }
+        this.logger.log(`Loaded total of ${prevDescriptors.length} previous descriptors`);
         return prevDescriptors;
     }
     async getNewState(ctx, config) {
+        this.logger.log('Loading new state');
         let prevDescriptors = [];
         for (const source of config.sources){
-            const descriptors = await this.openApiService.getResourceDescriptors(source.id);
+            const { descriptors } = await this.openApiService.getResourceDescriptors(source.id);
             prevDescriptors = [
                 ...prevDescriptors,
                 ...descriptors
@@ -12039,8 +12679,10 @@ class OperationsService {
     async generate(ctx) {
         const config = await this.getConfig(ctx);
         await this.clearGenerateDir(ctx);
+        const hashes = {};
         for (const source of config.sources){
-            const descriptors = await this.getDescriptors(ctx, source);
+            const { descriptors, hash } = await this.getDescriptors(ctx, source);
+            hashes[source.id] = hash;
             await this.generateSourceContent(ctx, descriptors, source);
         }
         await this.generateGlobalContent(ctx, config.sources);
@@ -12048,9 +12690,9 @@ class OperationsService {
         await this.buildContent(ctx);
         const tempBuildContext = config.__dangorouslyOverrideBuild;
         if (tempBuildContext) {
-            this.copyContentToSource(ctx, tempBuildContext);
+            await this.copyContentToSource(ctx, tempBuildContext);
         } else {
-            await this.copyContentToNodeModules(ctx);
+            await this.copyContentToNodeModules(ctx, hashes);
         }
         await this.executePostBuild(ctx);
     }
@@ -12082,7 +12724,7 @@ class OperationsService {
             throw error;
         }
     }
-    async copyContentToNodeModules(ctx) {
+    async copyContentToNodeModules(ctx, hashes) {
         const targetLibDir = external_path_namespaceObject.join(this.config.get('rootDir') ?? process.cwd(), 'node_modules', '@intrig', this.generatorBinding.getLibName());
         try {
             if (await external_fs_extra_namespaceObject.pathExists(external_path_namespaceObject.join(targetLibDir, 'src'))) {
@@ -12094,6 +12736,10 @@ class OperationsService {
             this.logger.log(`Copied ${targetLibDir}`);
             await this.mergePackageJson(external_path_namespaceObject.join(this.generateDir, 'package.json'), external_path_namespaceObject.join(targetLibDir, 'package.json'));
             this.logger.log(`Merged package.json files`);
+            await external_fs_extra_namespaceObject.writeJson(external_path_namespaceObject.join(targetLibDir, 'hashes.json'), hashes, {
+                spaces: 2
+            });
+            this.logger.log(`Wrote hashes.json to ${targetLibDir}`);
         } catch (error) {
             this.logger.error(`Failed to copy content to node_modules: ${error}`);
             throw error;
@@ -12123,7 +12769,9 @@ class OperationsService {
         await this.generatorBinding.generateSource(descriptors, source);
     }
     async getDescriptors(ctx, source) {
-        return await this.openApiService.getResourceDescriptors(source.id);
+        const descriptors = await this.openApiService.getResourceDescriptors(source.id);
+        // Hash is now available for operations.service to use
+        return descriptors;
     }
     async clearGenerateDir(ctx) {
         if (external_fs_extra_namespaceObject.pathExistsSync(this.generateDir)) {
@@ -12142,6 +12790,74 @@ class OperationsService {
         external_fs_extra_namespaceObject.ensureDirSync(this.generateDir);
         return this.generateDir;
     }
+    async verify(hashes) {
+        this.logger.log('Verifying hashes');
+        try {
+            // 1. Load intrigConfig
+            const intrigConfig = this.configService.get();
+            const sources = intrigConfig.sources || [];
+            // 2. Check that each key in hashes has a matching source id
+            const sourceIds = new Set(sources.map((source)=>source.id));
+            const hashKeys = Object.keys(hashes);
+            for (const hashKey of hashKeys){
+                if (!sourceIds.has(hashKey)) {
+                    this.logger.error(`Hash key '${hashKey}' does not have a matching source id`);
+                    return {
+                        status: 'conflict',
+                        message: `Hash key '${hashKey}' does not have a matching source id`,
+                        statusCode: 409
+                    };
+                }
+            }
+            // 3. Check that there are no more sources than hashes
+            if (sources.length > hashKeys.length) {
+                const extraSources = sources.map((s)=>s.id).filter((id)=>!hashKeys.includes(id));
+                this.logger.error(`There are more sources than hashes. Extra sources: ${extraSources.join(', ')}`);
+                return {
+                    status: 'conflict',
+                    message: `There are more sources than hashes. Extra sources: ${extraSources.join(', ')}`,
+                    statusCode: 409
+                };
+            }
+            // 4. Get hash for each source and validate they match
+            for (const source of sources){
+                try {
+                    const actualHash = await this.openApiService.getHash(source.id);
+                    const expectedHash = hashes[source.id];
+                    if (actualHash !== expectedHash) {
+                        this.logger.error(`Hash mismatch for source '${source.id}'. Expected: ${expectedHash}, Actual: ${actualHash}`);
+                        return {
+                            status: 'conflict',
+                            message: `Hash mismatch for source '${source.id}'. Expected: ${expectedHash}, Actual: ${actualHash}`,
+                            statusCode: 409
+                        };
+                    }
+                } catch (error) {
+                    this.logger.error(`Failed to get hash for source '${source.id}': ${error.message}`);
+                    return {
+                        status: 'conflict',
+                        message: `Failed to get hash for source '${source.id}': ${error.message}`,
+                        statusCode: 409
+                    };
+                }
+            }
+            // 5. All validations passed
+            this.logger.log('All hash validations passed successfully');
+            return {
+                status: 'verified',
+                message: 'All hashes match successfully',
+                hashCount: Object.keys(hashes).length,
+                statusCode: 200
+            };
+        } catch (error) {
+            this.logger.error(`Verification failed with error: ${error.message}`);
+            return {
+                status: 'conflict',
+                message: `Verification failed: ${error.message}`,
+                statusCode: 409
+            };
+        }
+    }
 }
 operations_service_ts_decorate([
     WithStatus((event)=>({
@@ -12209,7 +12925,8 @@ operations_service_ts_decorate([
         })),
     operations_service_ts_metadata("design:type", Function),
     operations_service_ts_metadata("design:paramtypes", [
-        typeof GenerateEventContext === "undefined" ? Object : GenerateEventContext
+        typeof GenerateEventContext === "undefined" ? Object : GenerateEventContext,
+        typeof Record === "undefined" ? Object : Record
     ]),
     operations_service_ts_metadata("design:returntype", Promise)
 ], OperationsService.prototype, "copyContentToNodeModules", null);
@@ -12328,6 +13045,7 @@ function operations_controller_ts_param(paramIndex, decorator) {
 
 
 
+
 class OperationsController {
     constructor(operationsService){
         this.operationsService = operationsService;
@@ -12352,9 +13070,16 @@ class OperationsController {
             await this.operationsService.generate(generateEventContext);
             generateEventContext.done(new GenerateDoneEventDto(true));
             this.logger.log('Generate operation completed');
-        });
+        }, 0);
         return events$;
     }
+    async verify(hashes, res) {
+        this.logger.log('Starting verify operation');
+        const result = await this.operationsService.verify(hashes);
+        this.logger.log('Verify operation completed');
+        const statusCode = result.statusCode || 200;
+        return res.status(statusCode).json(result);
+    }
 }
 operations_controller_ts_decorate([
     (0,common_namespaceObject.Sse)('sync'),
@@ -12407,6 +13132,25 @@ operations_controller_ts_decorate([
     operations_controller_ts_metadata("design:paramtypes", []),
     operations_controller_ts_metadata("design:returntype", Promise)
 ], OperationsController.prototype, "generate", null);
+operations_controller_ts_decorate([
+    (0,common_namespaceObject.Post)('verify'),
+    (0,swagger_namespaceObject.ApiResponse)({
+        status: 200,
+        description: 'Verify hashes - successful verification'
+    }),
+    (0,swagger_namespaceObject.ApiResponse)({
+        status: 409,
+        description: 'Verify hashes - validation conflicts found'
+    }),
+    operations_controller_ts_param(0, (0,common_namespaceObject.Body)()),
+    operations_controller_ts_param(1, (0,common_namespaceObject.Res)()),
+    operations_controller_ts_metadata("design:type", Function),
+    operations_controller_ts_metadata("design:paramtypes", [
+        typeof Record === "undefined" ? Object : Record,
+        typeof external_express_namespaceObject.Response === "undefined" ? Object : external_express_namespaceObject.Response
+    ]),
+    operations_controller_ts_metadata("design:returntype", Promise)
+], OperationsController.prototype, "verify", null);
 OperationsController = operations_controller_ts_decorate([
     (0,swagger_namespaceObject.ApiTags)('Operations'),
     (0,swagger_namespaceObject.ApiExtraModels)(SyncStatusEventDto, SyncDoneEventDto, GenerateStatusEventDto, GenerateDoneEventDto),
@@ -13615,62 +14359,6 @@ DeamonModule = deamon_module_ts_decorate([
     };
 });
 
-;// external "url"
-const external_url_namespaceObject = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("url");
-;// external "process"
-const external_process_namespaceObject = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("process");
-;// ./src/app/debug/debug.controller.ts
-function debug_controller_ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-function debug_controller_ts_metadata(k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-
-
-
-
-// Get the directory name in ES modules
-const debug_controller_filename = (0,external_url_namespaceObject.fileURLToPath)("file:///home/tiran-intrigsoft/IdeaProjects/intrig-core/app/intrig/src/app/debug/debug.controller.ts");
-const debug_controller_dirname = (0,external_path_namespaceObject.dirname)(debug_controller_filename);
-class DebugController {
-    getDirname() {
-        // Calculate paths that might be relevant for debugging
-        const assetsPath = (0,external_path_namespaceObject.join)(external_process_namespaceObject.cwd(), 'dist', 'app', 'intrig', 'assets', 'insight');
-        const appDirname = (0,external_path_namespaceObject.dirname)(debug_controller_dirname);
-        return {
-            // ES Module specific values
-            dirname: debug_controller_dirname,
-            filename: debug_controller_filename,
-            meta_url: "file:///home/tiran-intrigsoft/IdeaProjects/intrig-core/app/intrig/src/app/debug/debug.controller.ts",
-            // Calculated paths
-            assetsPath,
-            appDirname,
-            // Process information
-            cwd: external_process_namespaceObject.cwd(),
-            execPath: external_process_namespaceObject.execPath,
-            // Environment
-            nodeEnv: external_process_namespaceObject.env.NODE_ENV,
-            // Module type
-            isESM: "function" === 'undefined',
-            // Timestamp for cache busting
-            timestamp: new Date().toISOString()
-        };
-    }
-}
-debug_controller_ts_decorate([
-    (0,common_namespaceObject.Get)('dirname'),
-    debug_controller_ts_metadata("design:type", Function),
-    debug_controller_ts_metadata("design:paramtypes", []),
-    debug_controller_ts_metadata("design:returntype", void 0)
-], DebugController.prototype, "getDirname", null);
-DebugController = debug_controller_ts_decorate([
-    (0,common_namespaceObject.Controller)('debug')
-], DebugController);
-
 ;// ./src/app/app.module.ts
 function app_module_ts_decorate(decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
@@ -13685,8 +14373,6 @@ function app_module_ts_decorate(decorators, target, key, desc) {
 
 
 
-// import {McpModule} from "./mcp/mcp.module";
-
 class AppModule {
 }
 AppModule = app_module_ts_decorate([
@@ -13703,9 +14389,7 @@ AppModule = app_module_ts_decorate([
             DiscoveryModule,
             DeamonModule
         ],
-        controllers: [
-            DebugController
-        ],
+        controllers: [],
         providers: []
     })
 ], AppModule);
@@ -13723,12 +14407,10 @@ const core_namespaceObject = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("
 
 
 
+
 const logger = new common_namespaceObject.Logger('Main');
 async function bootstrapDeamon() {
     const app = await core_namespaceObject.NestFactory.create(AppModule, {
-        logger: [
-            'error'
-        ]
     });
     app.enableShutdownHooks();
     app.enableCors();
@@ -13766,6 +14448,14 @@ async function bootstrap() {
         await app.init();
         process.stdin.resume();
     } else {
+        if (cmd === 'init') {
+            const configPath = './intrig.config.json';
+            if (external_fs_namespaceObject.existsSync(configPath)) {
+                throw new Error('Intrig is already initialized. Configuration file exists.');
+            }
+            external_fs_namespaceObject.writeFileSync(configPath, JSON.stringify({}, null, 2));
+            logger?.log('Initialized new Intrig project');
+        }
         try {
             await external_nest_commander_namespaceObject.CommandFactory.run(AppModule, {
                 logger: false,