@azure-net/kit 4.1.0 → 5.0.0-1

package/dist/delivery/index.d.ts

@@ -0,0 +1,3 @@
+export { createAsyncHelpers, createErrorHandler, type AsyncHelperRetry, type AsyncResourceSettings, type AsyncActionResponse } from './injectable-dependencies/index.js';
+export { createSchemaFactory, schema, type Schema, type RequestErrors, type ISchemaError, type ValidationResult, type ValidationRuleResult, type ValidationParams, type ValidationMessage, type ValidationErrorsMap } from './schema/index.js';
+export { createRules, validationMessagesRu, validationMessagesI18n, validationMessagesEn, type ValidationRuleParams, type BaseValidationMessages } from './schema/rules/index.js';

package/dist/delivery/index.js

@@ -0,0 +1,3 @@
+export { createAsyncHelpers, createErrorHandler } from './injectable-dependencies/index.js';
+export { createSchemaFactory, schema } from './schema/index.js';
+export { createRules, validationMessagesRu, validationMessagesI18n, validationMessagesEn } from './schema/rules/index.js';

package/dist/{core/delivery/injectableDependencies → delivery/injectable-dependencies}/AsyncHelpers.d.ts

@@ -1,5 +1,5 @@
 import { createErrorHandler } from './ErrorHandler.js';
-import { type AppError, type IAppError } from '../../shared/appError/AppError.js';
+import { type AppError, type IAppError } from '../../shared/app-error/AppError.js';
 export interface AsyncActionResponse<T, D = never, ErrorResult = Record<never, never>> {
     success: boolean;
     response: T;

package/dist/{core/delivery/injectableDependencies → delivery/injectable-dependencies}/AsyncHelpers.js

@@ -1,5 +1,5 @@
 import { createErrorHandler } from './ErrorHandler.js';
-import {} from '../../shared/appError/AppError.js';
+import {} from '../../shared/app-error/AppError.js';
 export class AsyncHelperError extends Error {
 }
 export const createAsyncHelpers = (opts) => {

package/dist/{core/delivery/injectableDependencies → delivery/injectable-dependencies}/ErrorHandler.d.ts

@@ -1,5 +1,5 @@
-import { AppError, type IAppError } from '../../shared/appError/AppError.js';
-import { AppEvents } from '../../shared/appEventBus/index.js';
+import { AppError, type IAppError } from '../../shared/app-error/AppError.js';
+import { AppEvents } from '../../shared/event-bus/EventBus.js';
 import type { AsyncHelperRetry } from './AsyncHelpers.js';
 export type ErrorHandlerContext = {
     AppEvents: typeof AppEvents;

package/dist/{core/delivery/injectableDependencies → delivery/injectable-dependencies}/ErrorHandler.js

@@ -1,5 +1,5 @@
-import { AppError } from '../../shared/appError/AppError.js';
-import { AppEvents } from '../../shared/appEventBus/index.js';
+import { AppError } from '../../shared/app-error/AppError.js';
+import { AppEvents } from '../../shared/event-bus/EventBus.js';
 export const createErrorHandler = (handle) => {
     return async (error, asyncHelperRetry) => {
         const appError = new AppError(error);

package/dist/{core/delivery → delivery}/schema/Schema.js

@@ -1,5 +1,5 @@
-import { FormDataUtil } from '@azure-net/tools';
-import { AzureNetKitInternalError } from '../../shared/appError/AppError.js';
+import { FormDataUtil } from '../../external/tools/index.js';
+import { AzureNetKitInternalError } from '../../shared/app-error/AppError.js';
 export class SchemaFail extends Error {
     _errors;
     data;

package/dist/{core/delivery → delivery}/schema/rules/Rules.d.ts

@@ -1,4 +1,4 @@
-import type { BaseValidationMessages } from './messages/types.js';
+import type { BaseValidationMessages } from './messages/Types.js';
 import type { ValidationParams, ValidationRuleResult } from '../index.js';
 export type ValidationRuleParams<T extends keyof BaseValidationMessages, D = object> = D & {
     message?: BaseValidationMessages[T];

package/dist/{core/delivery → delivery}/schema/rules/Rules.js

@@ -1,4 +1,4 @@
-import { DateUtil } from '@azure-net/tools';
+import { DateUtil } from '../../../external/tools/index.js';
 /**
  *
  * @param validationMessages - BaseValidationMessages

package/dist/{core/delivery → delivery}/schema/rules/messages/En.d.ts

@@ -1,2 +1,2 @@
-import type { BaseValidationMessages } from './types.js';
+import type { BaseValidationMessages } from './Types.js';
 export declare const validationMessagesEn: BaseValidationMessages;

package/dist/{core/delivery → delivery}/schema/rules/messages/Ru.d.ts

@@ -1,2 +1,2 @@
-import type { BaseValidationMessages } from './types.js';
+import type { BaseValidationMessages } from './Types.js';
 export declare const validationMessagesRu: BaseValidationMessages;

package/dist/{core/delivery → delivery}/schema/rules/messages/WithI18n.d.ts

@@ -1,2 +1,2 @@
-import type { BaseValidationMessages } from './types.js';
+import type { BaseValidationMessages } from './Types.js';
 export declare const validationMessagesI18n: BaseValidationMessages;

package/dist/{core/delivery → delivery}/schema/rules/messages/index.d.ts

@@ -1,4 +1,4 @@
 export * from './Ru.js';
 export * from './En.js';
 export * from './WithI18n.js';
-export * from './types.js';
+export * from './Types.js';

package/dist/{core/delivery → delivery}/schema/rules/messages/index.js

@@ -1,4 +1,4 @@
 export * from './Ru.js';
 export * from './En.js';
 export * from './WithI18n.js';
-export * from './types.js';
+export * from './Types.js';

package/dist/delivery.d.ts

@@ -0,0 +1,2 @@
+export * from './external/edges/Edges.js';
+export * from './delivery/index.js';

package/dist/delivery.js

@@ -0,0 +1,2 @@
+export * from './external/edges/Edges.js';
+export * from './delivery/index.js';

package/dist/errors.d.ts

@@ -0,0 +1,4 @@
+export { AppError, ErrorTypes, AzureNetKitInternalError, type IAppError } from './shared/app-error/AppError.js';
+export { HttpServiceError } from './infra/http-service/HttpServiceInstance.js';
+export { AsyncHelperError } from './delivery/injectable-dependencies/AsyncHelpers.js';
+export { SchemaFail } from './delivery/schema/Schema.js';

package/dist/errors.js

@@ -0,0 +1,4 @@
+export { AppError, ErrorTypes, AzureNetKitInternalError } from './shared/app-error/AppError.js';
+export { HttpServiceError } from './infra/http-service/HttpServiceInstance.js';
+export { AsyncHelperError } from './delivery/injectable-dependencies/AsyncHelpers.js';
+export { SchemaFail } from './delivery/schema/Schema.js';

package/dist/external/edges/Dev.d.ts

@@ -0,0 +1 @@
+export * from '@azure-net/edges/dev';

package/dist/external/edges/Dev.js

@@ -0,0 +1 @@
+export * from '@azure-net/edges/dev';

package/dist/external/edges/Edges.d.ts

@@ -0,0 +1 @@
+export { clearCache, createPresenter, createPresenterFactory, createStore, createStoreFactory, batch, transaction } from '@azure-net/edges';

package/dist/external/edges/Edges.js

@@ -0,0 +1 @@
+export { clearCache, createPresenter, createPresenterFactory, createStore, createStoreFactory, batch, transaction } from '@azure-net/edges';

package/dist/external/edges/ServerContext.d.ts

@@ -0,0 +1 @@
+export { RequestContext, type ContextData } from '@azure-net/edges/context';

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-export * from './core/index.js';
-export { __withEdgesUniversalLoad } from './edges/index.js';
+export * from './shared/index.js';
+export * from './svelte/index.js';

package/dist/index.js

@@ -1,2 +1,2 @@
-export * from './core/index.js';
-export { __withEdgesUniversalLoad } from './edges/index.js';
+export * from './shared/index.js';
+export * from './svelte/index.js';

package/dist/{core/infra → infra}/datasource/BaseDatasource.d.ts

@@ -1,4 +1,4 @@
-import { type IHttpServiceInstance, type IHttpServiceResponse } from '../httpService/HttpServiceInstance.js';
+import { type IHttpServiceInstance, type IHttpServiceResponse } from '../http-service/HttpServiceInstance.js';
 import { type IQueryBuilderInstance } from '../query/index.js';
 export type CreateRequestCallbackType<T> = (params: {
     http: IHttpServiceInstance;

package/dist/{core/infra → infra}/datasource/BaseDatasource.js

@@ -1,4 +1,4 @@
-import { createHttpServiceInstance } from '../httpService/HttpServiceInstance.js';
+import { createHttpServiceInstance } from '../http-service/HttpServiceInstance.js';
 import { createQueryInstance } from '../query/index.js';
 export class BaseHttpDatasource {
     httpClient;

package/dist/{core/infra/httpService → infra/http-service}/HttpServiceInstance.js

@@ -1,5 +1,5 @@
-import { BROWSER } from '@azure-net/tools/environment';
-import { RequestContext } from '@azure-net/edges/context';
+import { BROWSER } from '../../external/tools/index.js';
+import { RequestContext } from '../../external/edges/ServerContext.js';
 export var HttpInstanceFetchMethods;
 (function (HttpInstanceFetchMethods) {
     HttpInstanceFetchMethods["GET"] = "GET";

package/dist/infra/index.d.ts

@@ -0,0 +1,5 @@
+export { BaseHttpDatasource, type CreateRequestCallbackType } from './datasource/index.js';
+export { DTOMapper, type IDTOMapper } from './resource/index.js';
+export { HttpStatusCode, createHttpServiceInstance, HttpInstanceFetchMethods, HttpErrorTypes, HttpServiceResponse, HttpServiceError, type IHttpServiceError, type IHttpServiceResponse, type IHttpServiceInstance, type IHttpInstanceOptions, type HttpInstanceNormalizedRequest, type HttpInstanceOnRequest, type HttpInstanceOnError, type HttpInstanceDoFetch, type HttpInstanceRequestMethod } from './http-service/index.js';
+export { ResponseBuilder } from './response/index.js';
+export { createQueryInstance, type IQueryBuilderInstance, type ArrayFormat, type ObjectFormat, type IQueryBuilderSettings } from './query/QueryBuilder.js';

package/dist/infra/index.js

@@ -0,0 +1,5 @@
+export { BaseHttpDatasource } from './datasource/index.js';
+export { DTOMapper } from './resource/index.js';
+export { HttpStatusCode, createHttpServiceInstance, HttpInstanceFetchMethods, HttpErrorTypes, HttpServiceResponse, HttpServiceError } from './http-service/index.js';
+export { ResponseBuilder } from './response/index.js';
+export { createQueryInstance } from './query/QueryBuilder.js';

package/dist/{core/infra → infra}/query/QueryBuilder.js

@@ -1,4 +1,4 @@
-import { AzureNetKitInternalError } from '../../shared/appError/AppError.js';
+import { AzureNetKitInternalError } from '../../shared/app-error/AppError.js';
 const normalizeSettings = (base, override) => {
     return {
         delimiter: override?.delimiter ?? base?.delimiter ?? true,

package/dist/{core/infra → infra}/response/BaseResponse.d.ts

@@ -1,4 +1,4 @@
-import type { HttpServiceResponse } from '../httpService/index.js';
+import type { HttpServiceResponse } from '../http-service/index.js';
 type DeepKeys<T> = T extends object ? {
     [K in keyof T & string]: T[K] extends object ? K | `${K}.${DeepKeys<T[K]>}` : K;
 }[keyof T & string] : never;

package/dist/{core/infra → infra}/response/BaseResponse.js

@@ -1,4 +1,4 @@
-import { AzureNetKitInternalError } from '../../shared/appError/AppError.js';
+import { AzureNetKitInternalError } from '../../shared/app-error/AppError.js';
 export class ResponseBuilder {
     response;
     state;

package/dist/infra.d.ts

@@ -0,0 +1 @@
+export * from './infra/index.js';

package/dist/infra.js

@@ -0,0 +1 @@
+export * from './infra/index.js';

package/dist/plugin/AzureNetPlugin.d.ts

@@ -0,0 +1,7 @@
+import type { Plugin } from 'vite';
+export interface AzureNetPluginOptions {
+    silentChromeDevtools?: boolean;
+    syncFromServer?: boolean;
+    syncTransformMode?: 'ast' | 'regex' | 'hybrid';
+}
+export declare const AzureNetPlugin: (options?: AzureNetPluginOptions) => Plugin;

package/dist/plugin/AzureNetPlugin.js

@@ -0,0 +1,402 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import ts from 'typescript';
+const VIRTUAL_SERVER_UTILS_ID = 'virtual:azure-net-kit/server-utils';
+const VIRTUAL_UNIVERSAL_UTILS_ID = 'virtual:azure-net-kit/universal-utils';
+const RESOLVED_VIRTUAL_SERVER_UTILS_ID = `\0${VIRTUAL_SERVER_UTILS_ID}`;
+const RESOLVED_VIRTUAL_UNIVERSAL_UTILS_ID = `\0${VIRTUAL_UNIVERSAL_UTILS_ID}`;
+const VIRTUAL_SERVER_HOOKS_ID = 'virtual:azure-net-kit/hooks.server';
+const VIRTUAL_CLIENT_HOOKS_ID = 'virtual:azure-net-kit/hooks.client';
+const RESOLVED_VIRTUAL_SERVER_HOOKS_ID = `\0${VIRTUAL_SERVER_HOOKS_ID}`;
+const RESOLVED_VIRTUAL_CLIENT_HOOKS_ID = `\0${VIRTUAL_CLIENT_HOOKS_ID}`;
+const VIRTUAL_PROGRAM_ID = 'virtual:azure-net-kit/program';
+const RESOLVED_VIRTUAL_PROGRAM_ID = `\0${VIRTUAL_PROGRAM_ID}`;
+const GENERATED_MARKER = '__AZURE_NET_KIT_VIRTUAL_HOOK__';
+const SYNC_MARKER = "void '__EDGES_SYNC_WRAPPED__';";
+const LOAD_EXPORT_PATTERN = /export\s+const\s+load\s*(?::\s*[^=]+)?=/;
+const ACTIONS_EXPORT_PATTERN = /export\s+const\s+actions\s*(?::\s*[^=]+)?=/;
+const SERVER_ROUTE_PATTERN = /[\\/]\+((page|layout)\.server)\.(t|j)s$/;
+const UNIVERSAL_ROUTE_PATTERN = /[\\/]\+((page|layout))\.(t|j)s$/;
+const AST_SERVER_LOAD_ALIAS = '__edgesWrappedServerLoad';
+const AST_ACTIONS_ALIAS = '__edgesWrappedActions';
+const AST_UNIVERSAL_LOAD_ALIAS = '__edgesWrappedUniversalLoad';
+const applyEdits = (sourceCode, edits) => {
+    if (edits.length === 0)
+        return sourceCode;
+    const sorted = edits.sort((a, b) => b.start - a.start);
+    let result = sourceCode;
+    for (const edit of sorted) {
+        result = result.slice(0, edit.start) + edit.text + result.slice(edit.end);
+    }
+    return result;
+};
+const findImportInsertPosition = (sourceCode) => {
+    const importRegex = /(?:^|\n)((?:import|export)\s+(?:type\s+)?(?:\{[^}]*\}|\*|\w+)(?:\s+from)?\s+['"][^'"]+['"];?)/gm;
+    let lastMatch = null;
+    let match;
+    while ((match = importRegex.exec(sourceCode)) !== null) {
+        lastMatch = match;
+    }
+    return lastMatch ? lastMatch.index + lastMatch[0].length : 0;
+};
+const findStaticImportInsertPosition = (sourceCode) => {
+    const importRegex = /(?:^|\n)(import\s+(?:type\s+)?(?:\{[^}]*\}|\*|\w+)(?:\s+from)?\s+['"][^'"]+['"];?)/gm;
+    let lastMatch = null;
+    let match;
+    while ((match = importRegex.exec(sourceCode)) !== null) {
+        lastMatch = match;
+    }
+    return lastMatch ? lastMatch.index + lastMatch[0].length : 0;
+};
+const ensureSyncImport = (sourceCode, importLine) => {
+    if (sourceCode.includes('__EDGES_SYNC_WRAPPED__'))
+        return sourceCode;
+    const insertPos = findImportInsertPosition(sourceCode);
+    const beforeImports = sourceCode.slice(0, insertPos);
+    const afterImports = sourceCode.slice(insertPos);
+    return `${beforeImports}\n${SYNC_MARKER}\n${importLine}\n${afterImports}`;
+};
+const ensureAstServerImport = (sourceCode) => ensureSyncImport(sourceCode, `import { __withEdgesServerLoad as ${AST_SERVER_LOAD_ALIAS}, __withEdgesActions as ${AST_ACTIONS_ALIAS} } from '${VIRTUAL_SERVER_UTILS_ID}';`);
+const ensureAstUniversalImport = (sourceCode) => ensureSyncImport(sourceCode, `import { __withEdgesUniversalLoad as ${AST_UNIVERSAL_LOAD_ALIAS} } from '${VIRTUAL_UNIVERSAL_UTILS_ID}';`);
+const ensureRegexServerImport = (sourceCode) => ensureSyncImport(sourceCode, `import { __withEdgesServerLoad, __withEdgesActions } from '${VIRTUAL_SERVER_UTILS_ID}';`);
+const ensureRegexUniversalImport = (sourceCode) => ensureSyncImport(sourceCode, `import { __withEdgesUniversalLoad } from '${VIRTUAL_UNIVERSAL_UTILS_ID}';`);
+const findExportedLocal = (sourceFile, code, exportedName) => {
+    const edits = [];
+    let localName = null;
+    let found = false;
+    for (const stmt of sourceFile.statements) {
+        if (ts.isVariableStatement(stmt)) {
+            const exportModifier = stmt.modifiers?.find((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword);
+            if (!exportModifier)
+                continue;
+            for (const declaration of stmt.declarationList.declarations) {
+                if (!ts.isIdentifier(declaration.name) || declaration.name.text !== exportedName)
+                    continue;
+                localName = declaration.name.text;
+                found = true;
+                const modifierStart = exportModifier.getStart(sourceFile);
+                let modifierEnd = exportModifier.end;
+                while (modifierEnd < code.length && /\s/.test(code[modifierEnd]))
+                    modifierEnd += 1;
+                edits.push({ start: modifierStart, end: modifierEnd, text: '' });
+                break;
+            }
+        }
+        if (!ts.isExportDeclaration(stmt) || !stmt.exportClause || !ts.isNamedExports(stmt.exportClause) || stmt.moduleSpecifier)
+            continue;
+        const keepSpecs = [];
+        let statementHasTarget = false;
+        for (const element of stmt.exportClause.elements) {
+            const exportName = element.name.text;
+            const sourceName = element.propertyName?.text ?? element.name.text;
+            if (exportName === exportedName) {
+                statementHasTarget = true;
+                found = true;
+                localName = sourceName;
+                continue;
+            }
+            keepSpecs.push(code.slice(element.getStart(sourceFile), element.end).trim());
+        }
+        if (!statementHasTarget)
+            continue;
+        if (keepSpecs.length === 0) {
+            edits.push({ start: stmt.getStart(sourceFile), end: stmt.end, text: '' });
+        }
+        else {
+            edits.push({ start: stmt.getStart(sourceFile), end: stmt.end, text: `export { ${keepSpecs.join(', ')} };` });
+        }
+    }
+    return { localName, edits, found };
+};
+const wrapServerRouteModuleRegex = (sourceCode) => {
+    if (!LOAD_EXPORT_PATTERN.test(sourceCode) && !ACTIONS_EXPORT_PATTERN.test(sourceCode))
+        return null;
+    let wrapped = ensureRegexServerImport(sourceCode);
+    if (LOAD_EXPORT_PATTERN.test(wrapped)) {
+        wrapped = wrapped
+            .replace(LOAD_EXPORT_PATTERN, (match) => match.replace('export const load', 'const __userLoad'))
+            .concat('\n\nexport const load = __withEdgesServerLoad(__userLoad);');
+    }
+    if (ACTIONS_EXPORT_PATTERN.test(wrapped)) {
+        wrapped = wrapped
+            .replace(ACTIONS_EXPORT_PATTERN, (match) => match.replace('export const actions', 'const __userActions'))
+            .concat('\n\nexport const actions = __withEdgesActions(__userActions);');
+    }
+    return wrapped;
+};
+const wrapUniversalRouteModuleRegex = (sourceCode) => {
+    if (!LOAD_EXPORT_PATTERN.test(sourceCode))
+        return null;
+    return ensureRegexUniversalImport(sourceCode)
+        .replace(LOAD_EXPORT_PATTERN, (match) => match.replace('export const load', 'const __userUniversalLoad'))
+        .concat('\n\nexport const load = __withEdgesUniversalLoad(__userUniversalLoad);');
+};
+const wrapServerRouteModuleAst = (sourceCode) => {
+    if (sourceCode.includes('__EDGES_SYNC_WRAPPED__'))
+        return null;
+    let sourceFile;
+    try {
+        sourceFile = ts.createSourceFile('route.ts', sourceCode, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    }
+    catch {
+        return null;
+    }
+    const loadInfo = findExportedLocal(sourceFile, sourceCode, 'load');
+    const actionsInfo = findExportedLocal(sourceFile, sourceCode, 'actions');
+    if (!loadInfo.found && !actionsInfo.found)
+        return null;
+    if ((loadInfo.found && !loadInfo.localName) || (actionsInfo.found && !actionsInfo.localName))
+        return null;
+    let nextCode = applyEdits(sourceCode, [...loadInfo.edits, ...actionsInfo.edits]);
+    nextCode = ensureAstServerImport(nextCode);
+    const append = [];
+    if (loadInfo.localName) {
+        append.push(`const __edgesServerLoad = ${AST_SERVER_LOAD_ALIAS}(${loadInfo.localName});`);
+        append.push('export { __edgesServerLoad as load };');
+    }
+    if (actionsInfo.localName) {
+        append.push(`const __edgesServerActions = ${AST_ACTIONS_ALIAS}(${actionsInfo.localName});`);
+        append.push('export { __edgesServerActions as actions };');
+    }
+    return `${nextCode}\n\n${append.join('\n')}`;
+};
+const wrapUniversalRouteModuleAst = (sourceCode) => {
+    if (sourceCode.includes('__EDGES_SYNC_WRAPPED__'))
+        return null;
+    let sourceFile;
+    try {
+        sourceFile = ts.createSourceFile('route.ts', sourceCode, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    }
+    catch {
+        return null;
+    }
+    const loadInfo = findExportedLocal(sourceFile, sourceCode, 'load');
+    if (!loadInfo.found || !loadInfo.localName)
+        return null;
+    let nextCode = applyEdits(sourceCode, [...loadInfo.edits]);
+    nextCode = ensureAstUniversalImport(nextCode);
+    return `${nextCode}\n\nconst __edgesUniversalLoad = ${AST_UNIVERSAL_LOAD_ALIAS}(${loadInfo.localName});\nexport { __edgesUniversalLoad as load };`;
+};
+const createVirtualServerHooks = (silentChromeDevtools) => `// ${GENERATED_MARKER}
+import { edgesHandle } from '${VIRTUAL_SERVER_UTILS_ID}';
+import { register } from '${VIRTUAL_PROGRAM_ID}';
+
+export const init = register.serverInit;
+
+export const handle = edgesHandle(({ serialize, edgesEvent, resolve }) =>
+	register.handle({
+		event: edgesEvent,
+		resolve: (event, options) =>
+			resolve(event, {
+				...options,
+				transformPageChunk: async (chunk) => {
+					const html = options?.transformPageChunk ? await options.transformPageChunk(chunk) : chunk.html;
+					return serialize(html);
+				}
+			})
+	})
+${silentChromeDevtools ? ')' : ', false)'};
+
+export const handleError = register.serverError;
+`;
+const createVirtualServerUtils = () => "export { edgesHandle, edgesHandleRaw, __autoWrapHandle, __withEdgesServerLoad, __withEdgesActions } from '@azure-net/edges/server';";
+const createVirtualUniversalUtils = () => `const EDGES_STATE_FIELD = '__edges_state__';
+const EDGES_REV_FIELD = '__edges_rev__';
+
+const isObjectRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+
+export const __withEdgesUniversalLoad = (load) => {
+\tconst wrapped = async (...args) => {
+\t\tconst event = args[0];
+\t\tconst result = await load(...args);
+\t\tif (!isObjectRecord(event?.data)) return result;
+
+\t\tconst inheritedState = event.data[EDGES_STATE_FIELD];
+\t\tconst inheritedRev = event.data[EDGES_REV_FIELD];
+\t\tif (!inheritedState) return result;
+
+\t\tif (isObjectRecord(result)) {
+\t\t\treturn {
+\t\t\t\t...result,
+\t\t\t\t[EDGES_STATE_FIELD]: inheritedState,
+\t\t\t\t[EDGES_REV_FIELD]: inheritedRev
+\t\t\t};
+\t\t}
+
+\t\tif (result === undefined) {
+\t\t\treturn {
+\t\t\t\t[EDGES_STATE_FIELD]: inheritedState,
+\t\t\t\t[EDGES_REV_FIELD]: inheritedRev
+\t\t\t};
+\t\t}
+
+\t\treturn result;
+\t};
+
+\treturn wrapped;
+};
+`;
+const createVirtualClientHooks = () => `// ${GENERATED_MARKER}
+import { register } from '${VIRTUAL_PROGRAM_ID}';
+
+export const init = register.clientInit;
+export const handleError = register.clientError;
+`;
+const createVirtualProgram = (root) => {
+    const tsProgram = path.join(root, 'src', 'program.ts');
+    const jsProgram = path.join(root, 'src', 'program.js');
+    if (fs.existsSync(tsProgram))
+        return `export { register } from '/src/program.ts';`;
+    if (fs.existsSync(jsProgram))
+        return `export { register } from '/src/program.js';`;
+    return `import { createApp } from '@azure-net/kit';
+
+export const { register, App } = createApp((app) => app);
+`;
+};
+const hasUserHook = (root, hookName) => {
+    const srcPath = path.join(root, 'src');
+    const candidates = ['.ts', '.js'].map((extension) => path.join(srcPath, `${hookName}${extension}`));
+    for (const candidate of candidates) {
+        if (fs.existsSync(candidate))
+            return candidate;
+    }
+    return null;
+};
+const assertNoUserHooks = (root) => {
+    const serverHook = hasUserHook(root, 'hooks.server');
+    const clientHook = hasUserHook(root, 'hooks.client');
+    const hook = serverHook ?? clientHook;
+    if (!hook)
+        return;
+    throw new Error(`[AzureNetPlugin] ${path.relative(root, hook)} is not allowed when AzureNetPlugin is enabled. ` +
+        'Move your lifecycle code to src/program.ts via createApp().');
+};
+const ensureVirtualImport = (sourceCode, importLine) => {
+    if (sourceCode.includes(importLine))
+        return sourceCode;
+    const insertPos = findStaticImportInsertPosition(sourceCode);
+    return `${sourceCode.slice(0, insertPos)}\n${importLine}\n${sourceCode.slice(insertPos)}`;
+};
+const transformGeneratedServerInternal = (sourceCode) => {
+    if (sourceCode.includes(GENERATED_MARKER))
+        return null;
+    const universalImportMatch = sourceCode.match(/\(\{\s*reroute,\s*transport\s*\}\s*=\s*await\s*import\([^)]+\)\);/);
+    const universalImport = universalImportMatch?.[0] ? `\n\t${universalImportMatch[0]}` : '';
+    const importLine = `import * as __azureNetServerHooks from '${VIRTUAL_SERVER_HOOKS_ID}';`;
+    const getHooksReplacement = `export async function get_hooks() {
+\tlet reroute;
+\tlet transport;${universalImport}
+
+\treturn {
+\t\thandle: __azureNetServerHooks.handle,
+\t\thandleFetch: undefined,
+\t\thandleError: __azureNetServerHooks.handleError,
+\t\thandleValidationError: undefined,
+\t\tinit: __azureNetServerHooks.init,
+\t\treroute,
+\t\ttransport
+\t};
+}`;
+    const transformed = ensureVirtualImport(sourceCode, `// ${GENERATED_MARKER}\n${importLine}`).replace(/export\s+async\s+function\s+get_hooks\s*\(\)\s*\{[\s\S]*?\n\}/m, getHooksReplacement);
+    return transformed;
+};
+const transformGeneratedClientApp = (sourceCode) => {
+    if (sourceCode.includes(GENERATED_MARKER))
+        return null;
+    let transformed = ensureVirtualImport(sourceCode, `// ${GENERATED_MARKER}\nimport * as __azureNetClientHooks from '${VIRTUAL_CLIENT_HOOKS_ID}';`);
+    transformed = transformed.replace(/import\s+\*\s+as\s+client_hooks\s+from\s+['"][^'"]*hooks\.client\.(?:ts|js)['"];\s*\n*/g, '');
+    transformed = transformed.replace(/handleError:\s*(?:client_hooks\.handleError\s*\|\|\s*)?\(\(\{\s*error\s*\}\)\s*=>\s*\{\s*console\.error\(error\)\s*\}\)/m, 'handleError: __azureNetClientHooks.handleError');
+    if (/^\s*init:\s*[^,\n]+,?/m.test(transformed)) {
+        transformed = transformed.replace(/^\s*init:\s*[^,\n]+,?/m, '\tinit: __azureNetClientHooks.init,');
+    }
+    else {
+        transformed = transformed.replace(/handleError:\s*__azureNetClientHooks\.handleError,?/m, 'handleError: __azureNetClientHooks.handleError,\n\tinit: __azureNetClientHooks.init,');
+    }
+    return transformed;
+};
+export const AzureNetPlugin = (options) => {
+    const { silentChromeDevtools = true, syncFromServer = true, syncTransformMode = 'hybrid' } = options || {};
+    let root = process.cwd();
+    let isTestMode = false;
+    return {
+        name: 'azure-net-kit-plugin',
+        enforce: 'pre',
+        config(config, env) {
+            root = path.resolve(config.root ?? process.cwd());
+            isTestMode = env.mode === 'test';
+            assertNoUserHooks(root);
+        },
+        configResolved(config) {
+            root = config.root;
+            isTestMode ||= config.mode === 'test';
+            assertNoUserHooks(root);
+        },
+        buildStart() {
+            assertNoUserHooks(root);
+        },
+        resolveId(id) {
+            if (id === VIRTUAL_SERVER_UTILS_ID)
+                return RESOLVED_VIRTUAL_SERVER_UTILS_ID;
+            if (id === VIRTUAL_UNIVERSAL_UTILS_ID)
+                return RESOLVED_VIRTUAL_UNIVERSAL_UTILS_ID;
+            if (id === VIRTUAL_SERVER_HOOKS_ID)
+                return RESOLVED_VIRTUAL_SERVER_HOOKS_ID;
+            if (id === VIRTUAL_CLIENT_HOOKS_ID)
+                return RESOLVED_VIRTUAL_CLIENT_HOOKS_ID;
+            if (id === VIRTUAL_PROGRAM_ID)
+                return RESOLVED_VIRTUAL_PROGRAM_ID;
+            return null;
+        },
+        load(id) {
+            if (id === RESOLVED_VIRTUAL_SERVER_UTILS_ID)
+                return createVirtualServerUtils();
+            if (id === RESOLVED_VIRTUAL_UNIVERSAL_UTILS_ID)
+                return createVirtualUniversalUtils();
+            if (id === RESOLVED_VIRTUAL_SERVER_HOOKS_ID)
+                return createVirtualServerHooks(silentChromeDevtools);
+            if (id === RESOLVED_VIRTUAL_CLIENT_HOOKS_ID)
+                return createVirtualClientHooks();
+            if (id === RESOLVED_VIRTUAL_PROGRAM_ID)
+                return createVirtualProgram(root);
+            return null;
+        },
+        transform(code, id) {
+            const normalizedId = id.split(path.sep).join('/');
+            if (!isTestMode && normalizedId.endsWith('/.svelte-kit/generated/server/internal.js')) {
+                const transformed = transformGeneratedServerInternal(code);
+                if (transformed)
+                    return { code: transformed, map: null };
+                return null;
+            }
+            if (!isTestMode &&
+                (normalizedId.endsWith('/.svelte-kit/generated/client/app.js') || normalizedId.endsWith('/.svelte-kit/generated/client-optimized/app.js'))) {
+                const transformed = transformGeneratedClientApp(code);
+                if (transformed)
+                    return { code: transformed, map: null };
+                return null;
+            }
+            if (code.includes('__EDGES_SYNC_WRAPPED__'))
+                return null;
+            if (syncFromServer && SERVER_ROUTE_PATTERN.test(id) && !id.includes('hooks.server')) {
+                const wrapped = syncTransformMode === 'regex'
+                    ? wrapServerRouteModuleRegex(code)
+                    : syncTransformMode === 'ast'
+                        ? wrapServerRouteModuleAst(code)
+                        : (wrapServerRouteModuleAst(code) ?? wrapServerRouteModuleRegex(code));
+                if (wrapped)
+                    return { code: wrapped, map: null };
+            }
+            if (syncFromServer && UNIVERSAL_ROUTE_PATTERN.test(id) && !id.includes('.server.')) {
+                const wrapped = syncTransformMode === 'regex'
+                    ? wrapUniversalRouteModuleRegex(code)
+                    : syncTransformMode === 'ast'
+                        ? wrapUniversalRouteModuleAst(code)
+                        : (wrapUniversalRouteModuleAst(code) ?? wrapUniversalRouteModuleRegex(code));
+                if (wrapped)
+                    return { code: wrapped, map: null };
+            }
+            return null;
+        }
+    };
+};

package/dist/plugin/index.d.ts

@@ -0,0 +1 @@
+export { AzureNetPlugin, type AzureNetPluginOptions } from './AzureNetPlugin.js';

package/dist/plugin/index.js

@@ -0,0 +1 @@
+export { AzureNetPlugin } from './AzureNetPlugin.js';