@c15t/backend 1.2.0-canary.13 → 1.2.0-canary.2

package/dist/core.cjs

@@ -36,8 +36,10 @@ __webpack_require__.d(__webpack_exports__, {
     c15tInstance: ()=>c15tInstance
 });
 const logger_namespaceObject = require("@doubletie/logger");
+const openapi_namespaceObject = require("@orpc/openapi");
 const fetch_namespaceObject = require("@orpc/openapi/fetch");
 const plugins_namespaceObject = require("@orpc/server/plugins");
+const zod_namespaceObject = require("@orpc/zod");
 const external_neverthrow_namespaceObject = require("neverthrow");
 const server_namespaceObject = require("@orpc/server");
 const error_codes_ERROR_CODES = Object.freeze({
@@ -285,6 +287,7 @@ function createTelemetryOptions(appName = 'c15t', telemetryConfig) {
     };
     return config;
 }
+var package_namespaceObject = JSON.parse('{"i8":"1.2.0-canary.2"}');
 const resources_namespaceObject = require("@opentelemetry/resources");
 const sdk_node_namespaceObject = require("@opentelemetry/sdk-node");
 const sdk_trace_base_namespaceObject = require("@opentelemetry/sdk-trace-base");
@@ -1210,21 +1213,10 @@ function consentRegistry({ adapter, ...ctx }) {
     };
     return registry;
 }
-async function generatePolicyPlaceholder(name, date) {
+const external_node_crypto_namespaceObject = require("node:crypto");
+function generatePolicyPlaceholder(name, date) {
     const content = `[PLACEHOLDER] This is an automatically generated version of the ${name} policy.\n\nThis placeholder content should be replaced with actual policy terms before being presented to users.\n\nGenerated on: ${date.toISOString()}`;
-    let contentHash;
-    try {
-        const encoder = new TextEncoder();
-        const data = encoder.encode(content);
-        const hashBuffer = await crypto.subtle.digest('SHA-256', data);
-        contentHash = Array.from(new Uint8Array(hashBuffer)).map((b)=>b.toString(16).padStart(2, '0')).join('');
-    } catch (error) {
-        throw new error_class_DoubleTieError('Failed to generate policy content hash', {
-            code: error_codes_ERROR_CODES.INTERNAL_SERVER_ERROR,
-            status: 500,
-            cause: error instanceof Error ? error : new Error(String(error))
-        });
-    }
+    const contentHash = (0, external_node_crypto_namespaceObject.createHash)('sha256').update(content).digest('hex');
     return {
         content,
         contentHash
@@ -1284,53 +1276,44 @@ function policyRegistry({ adapter, ...ctx }) {
             });
             return policy ? validateEntityOutput('consentPolicy', policy, ctx.options) : null;
         },
-        findOrCreatePolicy: async (type)=>await adapter.transaction({
+        findOrCreatePolicy: async (type)=>adapter.transaction({
                 callback: async (txAdapter)=>{
-                    try {
-                        const now = new Date();
-                        const txRegistry = policyRegistry({
-                            adapter: txAdapter,
-                            ...ctx
-                        });
-                        const rawLatestPolicy = await txAdapter.findOne({
-                            model: 'consentPolicy',
-                            where: [
-                                {
-                                    field: 'isActive',
-                                    value: true
-                                },
-                                {
-                                    field: 'type',
-                                    value: type
-                                }
-                            ],
-                            sortBy: {
-                                field: 'effectiveDate',
-                                direction: 'desc'
+                    const now = new Date();
+                    const txRegistry = policyRegistry({
+                        adapter: txAdapter,
+                        ...ctx
+                    });
+                    const rawLatestPolicy = await txAdapter.findOne({
+                        model: 'consentPolicy',
+                        where: [
+                            {
+                                field: 'isActive',
+                                value: true
+                            },
+                            {
+                                field: 'type',
+                                value: type
                             }
-                        });
-                        const latestPolicy = rawLatestPolicy ? validateEntityOutput('consentPolicy', rawLatestPolicy, ctx.options) : null;
-                        if (latestPolicy) return latestPolicy;
-                        const { content: defaultContent, contentHash } = await generatePolicyPlaceholder(type, now);
-                        return txRegistry.createConsentPolicy({
-                            version: '1.0.0',
-                            type,
-                            name: type,
-                            effectiveDate: now,
-                            content: defaultContent,
-                            contentHash,
-                            isActive: true,
-                            updatedAt: now,
-                            expirationDate: null
-                        });
-                    } catch (error) {
-                        ctx.logger.error('Error in findOrCreatePolicy transaction:', error);
-                        throw new error_class_DoubleTieError('Failed to find or create policy', {
-                            code: error_codes_ERROR_CODES.INTERNAL_SERVER_ERROR,
-                            status: 500,
-                            cause: error instanceof Error ? error : new Error(String(error))
-                        });
-                    }
+                        ],
+                        sortBy: {
+                            field: 'effectiveDate',
+                            direction: 'desc'
+                        }
+                    });
+                    const latestPolicy = rawLatestPolicy ? validateEntityOutput('consentPolicy', rawLatestPolicy, ctx.options) : null;
+                    if (latestPolicy) return latestPolicy;
+                    const { content: defaultContent, contentHash } = generatePolicyPlaceholder(type, now);
+                    return txRegistry.createConsentPolicy({
+                        version: '1.0.0',
+                        type,
+                        name: type,
+                        effectiveDate: now,
+                        content: defaultContent,
+                        contentHash,
+                        isActive: true,
+                        updatedAt: now,
+                        expirationDate: null
+                    });
                 }
             })
     };
@@ -2233,7 +2216,6 @@ function getBaseURL(url, path) {
     const fromEnv = env.C15T_URL || env.NEXT_PUBLIC_C15T_URL || env.PUBLIC_C15T_URL || env.NUXT_PUBLIC_C15T_URL || env.NUXT_PUBLIC_AUTH_URL || ('/' !== env.BASE_URL ? env.BASE_URL : void 0);
     if (fromEnv) return withPath(fromEnv, path);
 }
-var package_namespaceObject = JSON.parse('{"i8":"1.2.0-canary.13"}');
 const createRegistry = (ctx)=>({
         ...auditLogRegistry(ctx),
         ...consentRegistry(ctx),
@@ -2385,86 +2367,51 @@ function getInternalPlugins(_options) {
     const plugins = [];
     return plugins;
 }
-const WWW_REGEX = /^www\./;
-const PROTOCOL_WWW_REGEX = /^https?:\/\/(www\.)?/;
-const SUPPORTED_METHODS = [
-    'GET',
-    'POST',
-    'PUT',
-    'DELETE',
-    'PATCH',
-    'OPTIONS'
-];
-const SUPPORTED_HEADERS = [
-    'Content-Type',
-    'Authorization',
-    'x-request-id'
-];
-const DEFAULT_CORS_CONFIG = {
-    origin: async (origin)=>await Promise.resolve(origin || '*'),
-    credentials: true,
-    allowHeaders: SUPPORTED_HEADERS,
-    maxAge: 600,
-    methods: SUPPORTED_METHODS
+const API_ROUTER_TRACER_NAME = '@doubletie/api-router';
+const getTracer = (options)=>{
+    if (options?.telemetry?.tracer) return options.telemetry.tracer;
+    return api_namespaceObject.trace.getTracer(API_ROUTER_TRACER_NAME);
 };
-function createCORSOptions(trustedOrigins) {
-    if (!trustedOrigins) return DEFAULT_CORS_CONFIG;
-    const origins = Array.isArray(trustedOrigins) ? trustedOrigins : [
-        trustedOrigins
-    ];
-    if (0 === origins.length) return DEFAULT_CORS_CONFIG;
-    function normalizeOrigin(origin) {
-        try {
-            if (!origin.includes('://') && !origin.includes(':') && !origin.includes('/')) return origin.toLowerCase();
-            const originWithProtocol = origin.startsWith('http://') || origin.startsWith('https://') || origin.startsWith('ws://') || origin.startsWith('wss://') ? origin : `http://${origin}`;
-            const url = new URL(originWithProtocol);
-            const hostname = url.hostname.replace(WWW_REGEX, '');
-            return `${hostname}${url.port ? `:${url.port}` : ''}`;
-        } catch  {
-            return origin.replace(PROTOCOL_WWW_REGEX, '').replace(WWW_REGEX, '');
+const createRequestSpan = (method, path, options)=>{
+    if (options?.telemetry?.disabled) return null;
+    const tracer = getTracer(options);
+    const span = tracer.startSpan(`${method} ${path}`, {
+        attributes: {
+            'http.method': method,
+            'http.path': path,
+            ...options?.telemetry?.defaultAttributes || {}
         }
+    });
+    return span;
+};
+const withRequestSpan = async (method, path, operation, options)=>{
+    const span = createRequestSpan(method, path, options);
+    if (!span) return operation();
+    try {
+        const result = await operation();
+        span.setStatus({
+            code: api_namespaceObject.SpanStatusCode.OK
+        });
+        return result;
+    } catch (error) {
+        handleSpanError(span, error);
+        throw error;
+    } finally{
+        span.end();
     }
-    function expandWithWWW(origins) {
-        const expanded = new Set();
-        for (const origin of origins){
-            if ('*' === origin) {
-                expanded.add('*');
-                continue;
-            }
-            const normalized = normalizeOrigin(origin);
-            expanded.add(normalized);
-            if (!normalized.includes('www.')) expanded.add(`www.${normalized}`);
-        }
-        return Array.from(expanded);
+};
+const handleSpanError = (span, error)=>{
+    span.setStatus({
+        code: api_namespaceObject.SpanStatusCode.ERROR,
+        message: error instanceof Error ? error.message : String(error)
+    });
+    if (error instanceof Error) {
+        span.setAttribute('error.type', error.name);
+        span.setAttribute('error.message', error.message);
+        if (error.stack) span.setAttribute('error.stack', error.stack);
     }
-    const expandedTrusted = expandWithWWW(origins);
-    const returnConfig = {
-        origin: async (origin)=>{
-            if (!origin) return '*';
-            const normalizedOrigin = normalizeOrigin(origin);
-            if (expandedTrusted.includes('*')) return origin;
-            const isTrusted = expandedTrusted.some((trusted)=>{
-                const normalizedTrusted = normalizeOrigin(trusted);
-                if ('localhost' === normalizedTrusted) return 'localhost' === normalizedOrigin || normalizedOrigin.startsWith('localhost:') || '127.0.0.1' === normalizedOrigin || normalizedOrigin.startsWith('127.0.0.1:') || '[::1]' === normalizedOrigin || normalizedOrigin.startsWith('[::1]:');
-                return normalizedTrusted === normalizedOrigin;
-            });
-            return isTrusted ? origin : null;
-        },
-        credentials: true,
-        allowHeaders: SUPPORTED_HEADERS,
-        maxAge: 600,
-        methods: SUPPORTED_METHODS
-    };
-    return returnConfig;
-}
+};
 const STRIP_REGEX = /^(https?:\/\/)|(wss?:\/\/)|(\/+$)|:\d+/g;
-function matchesWildcard(hostname, wildcardPattern, logger) {
-    const wildcardDomain = wildcardPattern.slice(2);
-    const parts = hostname.split('.');
-    const isValid = parts.length > 2 && hostname.endsWith(wildcardDomain);
-    logger?.debug(`Wildcard match result: ${isValid} ${hostname} ends with ${wildcardDomain} ${parts.length > 2} ${hostname.endsWith(wildcardDomain)}`);
-    return isValid;
-}
 function isOriginTrusted(origin, trustedDomains, logger) {
     try {
         if (0 === trustedDomains.length) throw new Error('No trusted domains');
@@ -2483,7 +2430,13 @@ function isOriginTrusted(origin, trustedDomains, logger) {
             }
             const strippedDomain = domain.replace(STRIP_REGEX, '').toLowerCase();
             logger?.debug(`Checking against stripped domain: ${strippedDomain}`);
-            if (strippedDomain.startsWith('*.')) return matchesWildcard(originHostname, strippedDomain, logger);
+            if (strippedDomain.startsWith('*.')) {
+                const wildcardDomain = strippedDomain.slice(2);
+                const parts = originHostname.split('.');
+                const isValid = parts.length > 2 && originHostname.endsWith(wildcardDomain);
+                logger?.debug(`Wildcard match result: ${isValid} ${originHostname} ends with ${wildcardDomain} ${parts.length > 2} ${originHostname.endsWith(wildcardDomain)}`);
+                return isValid;
+            }
             const isMatch = originHostname === strippedDomain;
             logger?.debug(`Exact match result: ${isMatch} ${originHostname} === ${strippedDomain}`);
             return isMatch;
@@ -2493,58 +2446,38 @@ function isOriginTrusted(origin, trustedDomains, logger) {
         return false;
     }
 }
-function extractCORSInfo(request, trustedOrigins, logger) {
-    const origin = request.headers.get('origin');
-    if (!origin || !trustedOrigins) return {
-        origin: origin,
-        isTrusted: false
-    };
-    return {
-        origin,
-        isTrusted: isOriginTrusted(origin, trustedOrigins, logger)
-    };
-}
-const processCors = (request, context, trustedOrigins)=>{
-    const { origin, isTrusted } = extractCORSInfo(request, trustedOrigins, context.logger);
-    if (origin) {
-        context.origin = origin;
-        context.trustedOrigin = isTrusted;
+const DEFAULT_IP_HEADERS = [
+    'x-client-ip',
+    'x-forwarded-for',
+    'cf-connecting-ip',
+    'fastly-client-ip',
+    'x-real-ip',
+    'x-cluster-client-ip',
+    'x-forwarded',
+    'forwarded-for',
+    'forwarded'
+];
+function getIp(req, options) {
+    const advanced = options.advanced || {};
+    if (advanced?.ipAddress?.disableIpTracking) return null;
+    const testIP = '127.0.0.1';
+    if (isTest) return testIP;
+    const ipHeaders = advanced?.ipAddress?.ipAddressHeaders || DEFAULT_IP_HEADERS;
+    const headers = req instanceof Request ? req.headers : req;
+    for (const key of ipHeaders){
+        const value = headers.get(key);
+        if (value) {
+            const ip = value.split(',')[0]?.trim();
+            if (ip) return ip;
+        }
     }
-    return context;
-};
-const createOpenAPIConfig = (options)=>{
-    const basePath = options.basePath || '';
-    return {
-        enabled: true,
-        specPath: `${basePath}/spec.json`,
-        docsPath: `${basePath}/docs`,
-        ...options.openapi || {}
-    };
-};
-const createDefaultOpenAPIOptions = (options)=>({
-        info: {
-            title: options.appName || 'c15t API',
-            version: package_namespaceObject.i8,
-            description: 'API for consent management'
-        },
-        servers: [
-            {
-                url: options.basePath || '/'
-            }
-        ],
-        security: [
-            {
-                bearerAuth: []
-            }
-        ]
-    });
-const openapi_namespaceObject = require("@orpc/openapi");
-const zod_namespaceObject = require("@orpc/zod");
+    return null;
+}
 const contract_namespaceObject = require("@orpc/contract");
 const baseConsentSchema = external_zod_namespaceObject.z.object({
     subjectId: external_zod_namespaceObject.z.string().optional(),
     externalSubjectId: external_zod_namespaceObject.z.string().optional(),
-    domain: external_zod_namespaceObject.z.string(),
+    domain: external_zod_namespaceObject.z.string().regex(/^(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z]{2,}$/i, 'invalid domain'),
     type: PolicyTypeSchema,
     metadata: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.unknown()).optional()
 });
@@ -3134,7 +3067,7 @@ function checkJurisdiction(countryCode) {
             'KR'
         ])
     };
-    const showConsentBanner = true;
+    let showConsentBanner = false;
     let jurisdictionCode = 'NONE';
     if (countryCode) {
         const jurisdictionMap = [
@@ -3184,6 +3117,7 @@ function checkJurisdiction(countryCode) {
             }
         ];
         for (const { sets, code } of jurisdictionMap)if (sets.some((set)=>set.has(countryCode))) {
+            showConsentBanner = true;
             jurisdictionCode = code;
             break;
         }
@@ -3383,182 +3317,155 @@ const router = os.router({
     consent: consentHandlers,
     meta: metaHandlers
 });
-const mergeOpenAPIOptions = (defaultOptions, userOptions)=>{
-    const merged = {
-        ...defaultOptions
-    };
-    if (userOptions.info && 'object' == typeof userOptions.info) merged.info = {
-        ...merged.info,
-        ...userOptions.info
+const c15tInstance = (options)=>{
+    const contextPromise = init(options);
+    const corsOptions = options.trustedOrigins ? {
+        origin: options.trustedOrigins.includes('*') ? (origin)=>origin : options.trustedOrigins,
+        credentials: true,
+        methods: [
+            'GET',
+            'POST',
+            'PUT',
+            'DELETE',
+            'OPTIONS',
+            'PATCH'
+        ],
+        allowedHeaders: [
+            'Content-Type',
+            'Authorization',
+            'X-Request-ID'
+        ],
+        maxAge: 86400
+    } : {
+        origin: '*',
+        credentials: false,
+        methods: [
+            'GET',
+            'POST',
+            'PUT',
+            'DELETE',
+            'OPTIONS',
+            'PATCH'
+        ],
+        allowedHeaders: [
+            'Content-Type',
+            'Authorization',
+            'X-Request-ID'
+        ],
+        maxAge: 86400
     };
-    for (const [key, value] of Object.entries(userOptions))if ('info' !== key) merged[key] = value;
-    return merged;
-};
-const createOpenAPISpec = (context, options)=>{
+    const rpcHandler = new fetch_namespaceObject.OpenAPIHandler(router, {
+        plugins: [
+            new plugins_namespaceObject.CORSPlugin({
+                ...corsOptions,
+                origin: (origin)=>{
+                    if (!origin) return null;
+                    if (options.trustedOrigins?.includes('*')) return origin;
+                    if (options.trustedOrigins?.includes(origin)) return origin;
+                    return null;
+                },
+                credentials: true,
+                exposeHeaders: [
+                    'Content-Type',
+                    'Authorization',
+                    'X-Request-ID'
+                ]
+            })
+        ]
+    });
     const openAPIGenerator = new openapi_namespaceObject.OpenAPIGenerator({
         schemaConverters: [
             new zod_namespaceObject.ZodToJsonSchemaConverter()
         ]
     });
+    const openApiConfig = {
+        enabled: true,
+        specPath: '/spec.json',
+        docsPath: '/docs',
+        ...options.openapi || {}
+    };
+    const defaultOpenApiOptions = {
+        info: {
+            title: options.appName || 'c15t API',
+            version: package_namespaceObject.i8,
+            description: 'API for consent management'
+        },
+        servers: [
+            {
+                url: '/'
+            }
+        ],
+        security: [
+            {
+                bearerAuth: []
+            }
+        ]
+    };
+    const processIp = (request, context)=>{
+        const ip = getIp(request, options);
+        if (ip) context.ipAddress = ip;
+        return context;
+    };
+    const processCors = (request, context)=>{
+        const origin = request.headers.get('origin');
+        if (origin && options.trustedOrigins) {
+            const trusted = isOriginTrusted(origin, options.trustedOrigins, context.logger);
+            context.origin = origin;
+            context.trustedOrigin = trusted;
+        }
+        return context;
+    };
+    const processTelemetry = (request, context)=>{
+        const url = new URL(request.url);
+        const path = url.pathname;
+        const method = request.method;
+        withRequestSpan(method, path, async ()=>{}, options);
+        context.path = path;
+        context.method = method;
+        context.headers = request.headers;
+        context.userAgent = request.headers.get('user-agent') || void 0;
+        return context;
+    };
     const getOpenAPISpec = async ()=>{
         if (getOpenAPISpec.cached) return getOpenAPISpec.cached;
-        const defaultOptions = createDefaultOpenAPIOptions(options);
-        const mergedOptions = options.openapi?.options ? mergeOpenAPIOptions(defaultOptions, options.openapi.options) : defaultOptions;
-        try {
-            const spec = await openAPIGenerator.generate(router, mergedOptions);
-            getOpenAPISpec.cached = spec;
-            return spec;
-        } catch (error) {
-            context.logger?.error('Failed to generate OpenAPI spec:', error);
-            return {
-                openapi: '3.0.0',
-                info: {
-                    title: options.appName || 'c15t API',
-                    version: '0.0.0'
-                },
-                paths: {}
+        const mergedOptions = {
+            ...defaultOpenApiOptions
+        };
+        if (openApiConfig.options) {
+            const userOptions = openApiConfig.options;
+            if (userOptions.info) mergedOptions.info = {
+                ...defaultOpenApiOptions.info,
+                ...userOptions.info
             };
+            for (const [key, value] of Object.entries(userOptions))if ('info' !== key) mergedOptions[key] = value;
         }
+        const spec = await openAPIGenerator.generate(router, mergedOptions);
+        getOpenAPISpec.cached = spec;
+        return spec;
     };
-    return getOpenAPISpec;
-};
-const createDocsUI = (options)=>{
-    const config = createOpenAPIConfig(options);
-    if (config.customUiTemplate) return config.customUiTemplate;
-    return `
+    const getDocsUI = ()=>{
+        if (openApiConfig.customUiTemplate) return openApiConfig.customUiTemplate;
+        return `
     <!doctype html>
     <html>
       <head>
         <title>${options.appName || 'c15t API'} Documentation</title>
         <meta charset="utf-8" />
         <meta name="viewport" content="width=device-width, initial-scale=1" />
-        <link rel="icon" type="image/svg+xml" href="https://c15t.com/icon.svg" />
+        <link rel="icon" type="image/svg+xml" href="https://orpc.unnoq.com/icon.svg" />
       </head>
       <body>
         <script
           id="api-reference"
-          data-url="${encodeURI(config.specPath)}">
+          data-url="${encodeURI(openApiConfig.specPath)}">
         </script>
         <script src="https://cdn.jsdelivr.net/npm/@scalar/api-reference"></script>
       </body>
     </html>
-  `;
-};
-const API_ROUTER_TRACER_NAME = '@doubletie/api-router';
-const getTracer = (options)=>{
-    if (options?.telemetry?.tracer) return options.telemetry.tracer;
-    return api_namespaceObject.trace.getTracer(API_ROUTER_TRACER_NAME);
-};
-const createRequestSpan = (method, path, options)=>{
-    if (options?.telemetry?.disabled) return null;
-    const tracer = getTracer(options);
-    const span = tracer.startSpan(`${method} ${path}`, {
-        attributes: {
-            'http.method': method,
-            'http.path': path,
-            ...options?.telemetry?.defaultAttributes || {}
-        }
-    });
-    return span;
-};
-const withRequestSpan = async (method, path, operation, options)=>{
-    const span = createRequestSpan(method, path, options);
-    if (!span) return operation();
-    try {
-        const result = await operation();
-        span.setStatus({
-            code: api_namespaceObject.SpanStatusCode.OK
-        });
-        return result;
-    } catch (error) {
-        handleSpanError(span, error);
-        throw error;
-    } finally{
-        span.end();
-    }
-};
-const handleSpanError = (span, error)=>{
-    span.setStatus({
-        code: api_namespaceObject.SpanStatusCode.ERROR,
-        message: error instanceof Error ? error.message : String(error)
-    });
-    if (error instanceof Error) {
-        span.setAttribute('error.type', error.name);
-        span.setAttribute('error.message', error.message);
-        if (error.stack) span.setAttribute('error.stack', error.stack);
-    }
-};
-const DEFAULT_IP_HEADERS = [
-    'x-client-ip',
-    'x-forwarded-for',
-    'cf-connecting-ip',
-    'fastly-client-ip',
-    'x-real-ip',
-    'x-cluster-client-ip',
-    'x-forwarded',
-    'forwarded-for',
-    'forwarded'
-];
-function getIp(req, options) {
-    const advanced = options.advanced || {};
-    if (advanced?.ipAddress?.disableIpTracking) return null;
-    const testIP = '127.0.0.1';
-    if (isTest) return testIP;
-    const ipHeaders = advanced?.ipAddress?.ipAddressHeaders || DEFAULT_IP_HEADERS;
-    const headers = req instanceof Request ? req.headers : req;
-    for (const key of ipHeaders){
-        const value = headers.get(key);
-        if (value) {
-            const ip = value.split(',')[0]?.trim();
-            if (ip) return ip;
-        }
-    }
-    return null;
-}
-const c15tInstance = (options)=>{
-    const contextPromise = init(options);
-    const corsOptions = createCORSOptions(options.trustedOrigins);
-    const rpcHandler = new fetch_namespaceObject.OpenAPIHandler(router, {
-        plugins: [
-            new plugins_namespaceObject.CORSPlugin(corsOptions)
-        ]
-    });
-    const openApiConfig = createOpenAPIConfig(options);
-    const getDocsUI = ()=>createDocsUI(options);
-    const processIp = (request, context)=>{
-        const ip = getIp(request, options);
-        if (ip) context.ipAddress = ip;
-        return context;
-    };
-    const processTelemetry = (request, context)=>{
-        const url = new URL(request.url);
-        const path = url.pathname;
-        const method = request.method;
-        withRequestSpan(method, path, async ()=>{}, options);
-        context.path = path;
-        context.method = method;
-        context.headers = request.headers;
-        context.userAgent = request.headers.get('user-agent') || void 0;
-        return context;
+    `;
     };
     const handleOpenApiSpecRequest = async (url)=>{
         if (openApiConfig.enabled && url.pathname === openApiConfig.specPath) {
-            const ctxResult = await contextPromise;
-            if (!ctxResult.isOk()) throw ctxResult.error;
-            const ctx = ctxResult.value;
-            const orpcContext = {
-                adapter: ctx.adapter,
-                registry: ctx.registry,
-                logger: ctx.logger,
-                generateId: ctx.generateId,
-                headers: new Headers(),
-                appName: options.appName || 'c15t',
-                options,
-                trustedOrigins: options.trustedOrigins || [],
-                baseURL: options.baseURL || '/',
-                tables: ctx.tables
-            };
-            const getOpenAPISpec = createOpenAPISpec(orpcContext, options);
             const spec = await getOpenAPISpec();
             return new Response(JSON.stringify(spec), {
                 status: 200,
@@ -3624,37 +3531,17 @@ const c15tInstance = (options)=>{
             logger: ctx.logger,
             generateId: ctx.generateId,
             headers: request.headers,
-            userAgent: request.headers.get('user-agent') || void 0,
-            appName: options.appName || 'c15t',
-            options,
-            trustedOrigins: options.trustedOrigins || [],
-            baseURL: options.baseURL || '/',
-            tables: ctx.tables
+            userAgent: request.headers.get('user-agent') || void 0
         };
         processIp(request, orpcContext);
-        processCors(request, orpcContext, options.trustedOrigins);
+        processCors(request, orpcContext);
         processTelemetry(request, orpcContext);
         const handlerContext = orpcContext;
-        orpcContext.logger.debug?.('Handling prefix', {
-            prefix: options.basePath || '/'
-        });
         const { matched, response } = await rpcHandler.handle(request, {
-            prefix: options.basePath || '/',
+            prefix: '/',
             context: handlerContext
         });
-        if (matched && response) {
-            orpcContext.logger.debug('Handler matched', {
-                request,
-                matched,
-                response
-            });
-            return response;
-        }
-        orpcContext.logger.debug('No handler matched', {
-            request,
-            matched,
-            response
-        });
+        if (matched && response) return response;
         return new Response('Not Found', {
             status: 404
         });
@@ -3662,10 +3549,6 @@ const c15tInstance = (options)=>{
     const handler = async (request)=>{
         try {
             const url = new URL(request.url);
-            (0, logger_namespaceObject.createLogger)(options.logger)?.debug?.('Incoming request', {
-                method: request.method,
-                pathname: url.pathname
-            });
             const openApiResponse = await handleOpenApiSpecRequest(url);
             if (openApiResponse) return openApiResponse;
             const docsResponse = handleDocsUiRequest(url);
@@ -3673,15 +3556,6 @@ const c15tInstance = (options)=>{
             const ctxResult = await contextPromise;
             if (!ctxResult.isOk()) throw ctxResult.error;
             const ctx = ctxResult.value;
-            const basePath = options.basePath || options.baseURL || '/';
-            (0, logger_namespaceObject.createLogger)(options.logger)?.debug?.('[c15t] Using basePath/baseURL', {
-                basePath
-            });
-            (0, logger_namespaceObject.createLogger)(options.logger)?.debug?.('[c15t] Routing request', {
-                method: request.method,
-                url: request.url,
-                prefix: basePath
-            });
             return await handleApiRequest(request, ctx);
         } catch (error) {
             const logger = options.logger ? (0, logger_namespaceObject.createLogger)(options.logger) : console;
@@ -3711,25 +3585,7 @@ const c15tInstance = (options)=>{
         router: router,
         handler,
         ...createNextHandlers(),
-        getOpenAPISpec: async ()=>{
-            const ctxResult = await contextPromise;
-            if (!ctxResult.isOk()) throw ctxResult.error;
-            const ctx = ctxResult.value;
-            const orpcContext = {
-                adapter: ctx.adapter,
-                registry: ctx.registry,
-                logger: ctx.logger,
-                generateId: ctx.generateId,
-                headers: new Headers(),
-                appName: options.appName || 'c15t',
-                options,
-                trustedOrigins: options.trustedOrigins || [],
-                baseURL: options.baseURL || '/',
-                tables: ctx.tables
-            };
-            const getOpenAPISpec = createOpenAPISpec(orpcContext, options);
-            return getOpenAPISpec();
-        },
+        getOpenAPISpec,
         getDocsUI
     };
 };