@c15t/backend 1.0.5 → 1.2.0-canary.0

package/dist/{index.js → core.js}

@@ -1,3 +1,11 @@
+import * as __WEBPACK_EXTERNAL_MODULE__doubletie_logger_91c58a8f__ from "@doubletie/logger";
+import * as __WEBPACK_EXTERNAL_MODULE__orpc_openapi_a95cc8e7__ from "@orpc/openapi";
+import * as __WEBPACK_EXTERNAL_MODULE__orpc_openapi_fetch_89b49e61__ from "@orpc/openapi/fetch";
+import * as __WEBPACK_EXTERNAL_MODULE__orpc_server_plugins_e445fd4f__ from "@orpc/server/plugins";
+import * as __WEBPACK_EXTERNAL_MODULE__orpc_zod_716a28d4__ from "@orpc/zod";
+import * as __WEBPACK_EXTERNAL_MODULE_neverthrow__ from "neverthrow";
+import * as __WEBPACK_EXTERNAL_MODULE__orpc_server_0dae8408__ from "@orpc/server";
+import * as __WEBPACK_EXTERNAL_MODULE__opentelemetry_api_87359e78__ from "@opentelemetry/api";
 import * as __WEBPACK_EXTERNAL_MODULE__opentelemetry_resources_c7ac8648__ from "@opentelemetry/resources";
 import * as __WEBPACK_EXTERNAL_MODULE__opentelemetry_sdk_node_50b75088__ from "@opentelemetry/sdk-node";
 import * as __WEBPACK_EXTERNAL_MODULE__opentelemetry_sdk_trace_base_5031a705__ from "@opentelemetry/sdk-trace-base";
@@ -5,372 +13,10 @@ import * as __WEBPACK_EXTERNAL_MODULE_defu__ from "defu";
 import * as __WEBPACK_EXTERNAL_MODULE_superjson__ from "superjson";
 import * as __WEBPACK_EXTERNAL_MODULE_base_x_aeb88370__ from "base-x";
 import * as __WEBPACK_EXTERNAL_MODULE_zod__ from "zod";
-import * as __WEBPACK_EXTERNAL_MODULE_neverthrow__ from "neverthrow";
-import * as __WEBPACK_EXTERNAL_MODULE_h3__ from "h3";
-import * as __WEBPACK_EXTERNAL_MODULE__opentelemetry_api_87359e78__ from "@opentelemetry/api";
 import * as __WEBPACK_EXTERNAL_MODULE_node_crypto_9ba42079__ from "node:crypto";
 import * as __WEBPACK_EXTERNAL_MODULE_kysely__ from "kysely";
 import "drizzle-orm";
-var __webpack_modules__ = {
-    "../../node_modules/.pnpm/zod@3.24.2/node_modules/zod/lib/ZodError.js": function(__unused_webpack_module, exports, __webpack_require__) {
-        exports.ZodError = void 0;
-        const util_1 = __webpack_require__("../../node_modules/.pnpm/zod@3.24.2/node_modules/zod/lib/helpers/util.js");
-        util_1.util.arrayToEnum([
-            "invalid_type",
-            "invalid_literal",
-            "custom",
-            "invalid_union",
-            "invalid_union_discriminator",
-            "invalid_enum_value",
-            "unrecognized_keys",
-            "invalid_arguments",
-            "invalid_return_type",
-            "invalid_date",
-            "invalid_string",
-            "too_small",
-            "too_big",
-            "invalid_intersection_types",
-            "not_multiple_of",
-            "not_finite"
-        ]);
-        class ZodError extends Error {
-            get errors() {
-                return this.issues;
-            }
-            constructor(issues){
-                super();
-                this.issues = [];
-                this.addIssue = (sub)=>{
-                    this.issues = [
-                        ...this.issues,
-                        sub
-                    ];
-                };
-                this.addIssues = (subs = [])=>{
-                    this.issues = [
-                        ...this.issues,
-                        ...subs
-                    ];
-                };
-                const actualProto = new.target.prototype;
-                if (Object.setPrototypeOf) Object.setPrototypeOf(this, actualProto);
-                else this.__proto__ = actualProto;
-                this.name = "ZodError";
-                this.issues = issues;
-            }
-            format(_mapper) {
-                const mapper = _mapper || function(issue) {
-                    return issue.message;
-                };
-                const fieldErrors = {
-                    _errors: []
-                };
-                const processError = (error)=>{
-                    for (const issue of error.issues)if ("invalid_union" === issue.code) issue.unionErrors.map(processError);
-                    else if ("invalid_return_type" === issue.code) processError(issue.returnTypeError);
-                    else if ("invalid_arguments" === issue.code) processError(issue.argumentsError);
-                    else if (0 === issue.path.length) fieldErrors._errors.push(mapper(issue));
-                    else {
-                        let curr = fieldErrors;
-                        let i = 0;
-                        while(i < issue.path.length){
-                            const el = issue.path[i];
-                            const terminal = i === issue.path.length - 1;
-                            if (terminal) {
-                                curr[el] = curr[el] || {
-                                    _errors: []
-                                };
-                                curr[el]._errors.push(mapper(issue));
-                            } else curr[el] = curr[el] || {
-                                _errors: []
-                            };
-                            curr = curr[el];
-                            i++;
-                        }
-                    }
-                };
-                processError(this);
-                return fieldErrors;
-            }
-            static assert(value) {
-                if (!(value instanceof ZodError)) throw new Error(`Not a ZodError: ${value}`);
-            }
-            toString() {
-                return this.message;
-            }
-            get message() {
-                return JSON.stringify(this.issues, util_1.util.jsonStringifyReplacer, 2);
-            }
-            get isEmpty() {
-                return 0 === this.issues.length;
-            }
-            flatten(mapper = (issue)=>issue.message) {
-                const fieldErrors = {};
-                const formErrors = [];
-                for (const sub of this.issues)if (sub.path.length > 0) {
-                    fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];
-                    fieldErrors[sub.path[0]].push(mapper(sub));
-                } else formErrors.push(mapper(sub));
-                return {
-                    formErrors,
-                    fieldErrors
-                };
-            }
-            get formErrors() {
-                return this.flatten();
-            }
-        }
-        exports.ZodError = ZodError;
-        ZodError.create = (issues)=>{
-            const error = new ZodError(issues);
-            return error;
-        };
-    },
-    "../../node_modules/.pnpm/zod@3.24.2/node_modules/zod/lib/helpers/util.js": function(__unused_webpack_module, exports) {
-        Object.defineProperty(exports, "__esModule", {
-            value: true
-        });
-        exports.getParsedType = exports.ZodParsedType = exports.objectUtil = exports.util = void 0;
-        var util;
-        (function(util) {
-            util.assertEqual = (val)=>val;
-            function assertIs(_arg) {}
-            util.assertIs = assertIs;
-            function assertNever(_x) {
-                throw new Error();
-            }
-            util.assertNever = assertNever;
-            util.arrayToEnum = (items)=>{
-                const obj = {};
-                for (const item of items)obj[item] = item;
-                return obj;
-            };
-            util.getValidEnumValues = (obj)=>{
-                const validKeys = util.objectKeys(obj).filter((k)=>"number" != typeof obj[obj[k]]);
-                const filtered = {};
-                for (const k of validKeys)filtered[k] = obj[k];
-                return util.objectValues(filtered);
-            };
-            util.objectValues = (obj)=>util.objectKeys(obj).map(function(e) {
-                    return obj[e];
-                });
-            util.objectKeys = "function" == typeof Object.keys ? (obj)=>Object.keys(obj) : (object)=>{
-                const keys = [];
-                for(const key in object)if (Object.prototype.hasOwnProperty.call(object, key)) keys.push(key);
-                return keys;
-            };
-            util.find = (arr, checker)=>{
-                for (const item of arr)if (checker(item)) return item;
-            };
-            util.isInteger = "function" == typeof Number.isInteger ? (val)=>Number.isInteger(val) : (val)=>"number" == typeof val && isFinite(val) && Math.floor(val) === val;
-            function joinValues(array, separator = " | ") {
-                return array.map((val)=>"string" == typeof val ? `'${val}'` : val).join(separator);
-            }
-            util.joinValues = joinValues;
-            util.jsonStringifyReplacer = (_, value)=>{
-                if ("bigint" == typeof value) return value.toString();
-                return value;
-            };
-        })(util || (exports.util = util = {}));
-        var objectUtil;
-        (function(objectUtil) {
-            objectUtil.mergeShapes = (first, second)=>({
-                    ...first,
-                    ...second
-                });
-        })(objectUtil || (exports.objectUtil = objectUtil = {}));
-        exports.ZodParsedType = util.arrayToEnum([
-            "string",
-            "nan",
-            "number",
-            "integer",
-            "float",
-            "boolean",
-            "date",
-            "bigint",
-            "symbol",
-            "function",
-            "undefined",
-            "null",
-            "array",
-            "object",
-            "unknown",
-            "promise",
-            "void",
-            "never",
-            "map",
-            "set"
-        ]);
-        const getParsedType = (data)=>{
-            const t = typeof data;
-            switch(t){
-                case "undefined":
-                    return exports.ZodParsedType.undefined;
-                case "string":
-                    return exports.ZodParsedType.string;
-                case "number":
-                    return isNaN(data) ? exports.ZodParsedType.nan : exports.ZodParsedType.number;
-                case "boolean":
-                    return exports.ZodParsedType.boolean;
-                case "function":
-                    return exports.ZodParsedType.function;
-                case "bigint":
-                    return exports.ZodParsedType.bigint;
-                case "symbol":
-                    return exports.ZodParsedType.symbol;
-                case "object":
-                    if (Array.isArray(data)) return exports.ZodParsedType.array;
-                    if (null === data) return exports.ZodParsedType.null;
-                    if (data.then && "function" == typeof data.then && data.catch && "function" == typeof data.catch) return exports.ZodParsedType.promise;
-                    if ("undefined" != typeof Map && data instanceof Map) return exports.ZodParsedType.map;
-                    if ("undefined" != typeof Set && data instanceof Set) return exports.ZodParsedType.set;
-                    if ("undefined" != typeof Date && data instanceof Date) return exports.ZodParsedType.date;
-                    return exports.ZodParsedType.object;
-                default:
-                    return exports.ZodParsedType.unknown;
-            }
-        };
-        exports.getParsedType = getParsedType;
-    }
-};
-var __webpack_module_cache__ = {};
-function __webpack_require__(moduleId) {
-    var cachedModule = __webpack_module_cache__[moduleId];
-    if (void 0 !== cachedModule) return cachedModule.exports;
-    var module = __webpack_module_cache__[moduleId] = {
-        exports: {}
-    };
-    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
-    return module.exports;
-}
-(()=>{
-    __webpack_require__.r = (exports)=>{
-        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports, Symbol.toStringTag, {
-            value: 'Module'
-        });
-        Object.defineProperty(exports, '__esModule', {
-            value: true
-        });
-    };
-})();
-var pkgs_types_namespaceObject = {};
-__webpack_require__.r(pkgs_types_namespaceObject);
-function utils_applyDefaultValue(inputValue, field, operation) {
-    if ('update' === operation) return inputValue;
-    if (null == inputValue && field.defaultValue) {
-        if ('function' == typeof field.defaultValue) return field.defaultValue();
-        return field.defaultValue;
-    }
-    return inputValue;
-}
-const COMMON_TIMEZONES = {
-    UTC: 'UTC',
-    GMT: 'GMT',
-    EASTERN: 'America/New_York',
-    CENTRAL: 'America/Chicago',
-    MOUNTAIN: 'America/Denver',
-    PACIFIC: 'America/Los_Angeles',
-    LONDON: 'Europe/London',
-    PARIS: 'Europe/Paris',
-    BERLIN: 'Europe/Berlin',
-    TOKYO: 'Asia/Tokyo',
-    SHANGHAI: 'Asia/Shanghai',
-    SINGAPORE: 'Asia/Singapore',
-    SYDNEY: 'Australia/Sydney',
-    SAO_PAULO: 'America/Sao_Paulo'
-};
-const b58 = (0, __WEBPACK_EXTERNAL_MODULE_base_x_aeb88370__["default"])('123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz');
-function id_generator_generateId(prefix) {
-    const buf = crypto.getRandomValues(new Uint8Array(20));
-    const EPOCH_TIMESTAMP = 1700000000000;
-    const t = Date.now() - EPOCH_TIMESTAMP;
-    const high = Math.floor(t / 0x100000000);
-    const low = t >>> 0;
-    buf[0] = high >>> 24 & 255;
-    buf[1] = high >>> 16 & 255;
-    buf[2] = high >>> 8 & 255;
-    buf[3] = 255 & high;
-    buf[4] = low >>> 24 & 255;
-    buf[5] = low >>> 16 & 255;
-    buf[6] = low >>> 8 & 255;
-    buf[7] = 255 & low;
-    return `${prefix}_${b58.encode(buf)}`;
-}
-const fieldConfigSchema = __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
-    required: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean().default(true),
-    returned: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean().default(true),
-    input: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean().default(true),
-    defaultValue: __WEBPACK_EXTERNAL_MODULE_zod__.z.union([
-        __WEBPACK_EXTERNAL_MODULE_zod__.z.any(),
-        __WEBPACK_EXTERNAL_MODULE_zod__.z["function"]().returns(__WEBPACK_EXTERNAL_MODULE_zod__.z.any())
-    ]).optional(),
-    transform: __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
-        input: __WEBPACK_EXTERNAL_MODULE_zod__.z["function"]().args(__WEBPACK_EXTERNAL_MODULE_zod__.z.any()).returns(__WEBPACK_EXTERNAL_MODULE_zod__.z.union([
-            __WEBPACK_EXTERNAL_MODULE_zod__.z.any(),
-            __WEBPACK_EXTERNAL_MODULE_zod__.z.promise(__WEBPACK_EXTERNAL_MODULE_zod__.z.any())
-        ])).optional(),
-        output: __WEBPACK_EXTERNAL_MODULE_zod__.z["function"]().args(__WEBPACK_EXTERNAL_MODULE_zod__.z.any()).returns(__WEBPACK_EXTERNAL_MODULE_zod__.z.union([
-            __WEBPACK_EXTERNAL_MODULE_zod__.z.any(),
-            __WEBPACK_EXTERNAL_MODULE_zod__.z.promise(__WEBPACK_EXTERNAL_MODULE_zod__.z.any())
-        ])).optional()
-    }).optional(),
-    validator: __WEBPACK_EXTERNAL_MODULE_zod__.z["function"]().args(__WEBPACK_EXTERNAL_MODULE_zod__.z.any()).returns(__WEBPACK_EXTERNAL_MODULE_zod__.z.union([
-        __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
-        __WEBPACK_EXTERNAL_MODULE_zod__.z["null"]()
-    ])).optional(),
-    unique: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean().optional(),
-    indexed: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean().optional(),
-    sortable: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean().default(true),
-    fieldName: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().optional(),
-    bigint: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean().default(false)
-});
-const stringFieldSchema = fieldConfigSchema.extend({
-    type: __WEBPACK_EXTERNAL_MODULE_zod__.z.literal('string'),
-    minLength: __WEBPACK_EXTERNAL_MODULE_zod__.z.number().optional(),
-    maxLength: __WEBPACK_EXTERNAL_MODULE_zod__.z.number().optional(),
-    pattern: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().optional()
-});
-const numberFieldSchema = fieldConfigSchema.extend({
-    type: __WEBPACK_EXTERNAL_MODULE_zod__.z.literal('number'),
-    min: __WEBPACK_EXTERNAL_MODULE_zod__.z.number().optional(),
-    max: __WEBPACK_EXTERNAL_MODULE_zod__.z.number().optional()
-});
-const booleanFieldSchema = fieldConfigSchema.extend({
-    type: __WEBPACK_EXTERNAL_MODULE_zod__.z.literal('boolean')
-});
-const dateFieldSchema = fieldConfigSchema.extend({
-    type: __WEBPACK_EXTERNAL_MODULE_zod__.z.literal('date'),
-    minDate: __WEBPACK_EXTERNAL_MODULE_zod__.z.date().optional(),
-    maxDate: __WEBPACK_EXTERNAL_MODULE_zod__.z.date().optional(),
-    dateOnly: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean().default(false),
-    format: __WEBPACK_EXTERNAL_MODULE_zod__.z.record(__WEBPACK_EXTERNAL_MODULE_zod__.z.unknown()).optional()
-});
-const timezoneFieldSchema = fieldConfigSchema.extend({
-    type: __WEBPACK_EXTERNAL_MODULE_zod__.z.literal('timezone'),
-    validateTimezone: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean().default(true),
-    suggestedValues: __WEBPACK_EXTERNAL_MODULE_zod__.z.array(__WEBPACK_EXTERNAL_MODULE_zod__.z.string()).optional(),
-    restrictToSuggestedValues: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean().default(false)
-});
-const jsonFieldSchema = fieldConfigSchema.extend({
-    type: __WEBPACK_EXTERNAL_MODULE_zod__.z.literal('json'),
-    validateJson: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean().default(true)
-});
-const stringArrayFieldSchema = fieldConfigSchema.extend({
-    type: __WEBPACK_EXTERNAL_MODULE_zod__.z.literal('string[]')
-});
-const numberArrayFieldSchema = fieldConfigSchema.extend({
-    type: __WEBPACK_EXTERNAL_MODULE_zod__.z.literal('number[]')
-});
-__WEBPACK_EXTERNAL_MODULE_zod__.z.discriminatedUnion('type', [
-    stringFieldSchema,
-    numberFieldSchema,
-    booleanFieldSchema,
-    dateFieldSchema,
-    timezoneFieldSchema,
-    jsonFieldSchema,
-    stringArrayFieldSchema,
-    numberArrayFieldSchema
-]);
+import * as __WEBPACK_EXTERNAL_MODULE__orpc_contract_5a058524__ from "@orpc/contract";
 const error_codes_ERROR_CODES = Object.freeze({
     NOT_FOUND: 'Resource not found',
     BAD_REQUEST: 'Bad request',
@@ -436,10 +82,10 @@ async function tracing_withSpan(name, fn, attributes = {}) {
         }
     });
 }
-class error_class_DoubleTieError extends __WEBPACK_EXTERNAL_MODULE_h3__.H3Error {
-    code;
+class error_class_DoubleTieError extends __WEBPACK_EXTERNAL_MODULE__orpc_server_0dae8408__.ORPCError {
     category;
     meta;
+    statusCode;
     constructor(message, options = {
         code: error_codes_ERROR_CODES.UNKNOWN_ERROR,
         status: 500,
@@ -447,22 +93,18 @@ class error_class_DoubleTieError extends __WEBPACK_EXTERNAL_MODULE_h3__.H3Error
         cause: void 0,
         meta: {}
     }){
-        super(message, {
-            cause: options.cause
+        super(options.code ?? error_codes_ERROR_CODES.UNKNOWN_ERROR, {
+            message,
+            cause: options.cause,
+            data: options.meta ?? {}
         });
-        this.name = this.constructor.name;
-        this.code = options.code ?? error_codes_ERROR_CODES.UNKNOWN_ERROR;
-        this.statusCode = options.status ?? 500;
+        this.name = 'DoubleTieError';
         this.category = options.category ?? ERROR_CATEGORIES.UNEXPECTED;
         this.meta = options.meta ?? {};
-        this.data = {
-            code: this.code,
-            category: this.category,
-            meta: this.meta
-        };
+        this.statusCode = options.status ?? 500;
         tracing_withSpan('create_doubletie_error', async (span)=>{
             span.setAttributes({
-                'error.name': this.name,
+                'error.name': this.constructor.name,
                 'error.message': message,
                 'error.code': this.code,
                 'error.status': this.statusCode,
@@ -482,11 +124,11 @@ class error_class_DoubleTieError extends __WEBPACK_EXTERNAL_MODULE_h3__.H3Error
         const validationErrorMessage = this.meta?.validationErrors ? String(this.meta.validationErrors) : void 0;
         const stackTrace = this.stack ? this.stack.split('\n').map((line)=>line.trim()).filter((line)=>line && !line.includes('Error: ')) : [];
         return {
-            statusCode: this.statusCode,
+            code: this.code,
             message: validationErrorMessage || this.message,
-            statusMessage: this.statusMessage,
+            status: this.statusCode,
+            defined: true,
             data: {
-                code: this.code,
                 category: this.category,
                 meta: this.meta,
                 ...'production' === process.env.NODE_ENV ? {} : {
@@ -537,7 +179,9 @@ class error_class_DoubleTieError extends __WEBPACK_EXTERNAL_MODULE_h3__.H3Error
         const ErrorSubclass = class extends error_class_DoubleTieError {
             constructor(message, options){
                 super(message, options);
-                this.name = name;
+                Object.defineProperty(this, 'name', {
+                    value: name
+                });
             }
         };
         Object.defineProperty(ErrorSubclass, 'name', {
@@ -604,94 +248,6 @@ function promiseToResult(promise, errorCode = error_codes_ERROR_CODES.UNKNOWN_ER
         return result;
     });
 }
-const validationPipeline = (schema, transformer)=>(data)=>{
-        const preprocessData = (value)=>{
-            if ('object' != typeof value || null === value) {
-                if ('string' == typeof value) try {
-                    if (value.startsWith('[') && value.endsWith(']')) return JSON.parse(value);
-                    if ('true' === value.toLowerCase()) return true;
-                    if ('false' === value.toLowerCase()) return false;
-                    if (value.startsWith('{') && value.endsWith('}')) return JSON.parse(value);
-                } catch  {}
-                return value;
-            }
-            if (Array.isArray(value)) return value.map(preprocessData);
-            const processed = {};
-            for (const [key, val] of Object.entries(value))processed[key] = preprocessData(val);
-            return processed;
-        };
-        const preprocessedData = preprocessData(data);
-        const parseResult = schema.safeParse(preprocessedData);
-        if (!parseResult.success) return fail('Validation failed', {
-            code: error_codes_ERROR_CODES.INVALID_REQUEST,
-            status: 400,
-            meta: {
-                validationErrors: parseResult.error.issues
-            }
-        });
-        try {
-            return (0, __WEBPACK_EXTERNAL_MODULE_neverthrow__.ok)(transformer(parseResult.data));
-        } catch (error) {
-            return fail('Error transforming data after validation', {
-                code: error_codes_ERROR_CODES.BAD_REQUEST,
-                status: 400,
-                cause: error instanceof Error ? error : void 0,
-                meta: {
-                    inputData: parseResult.data
-                }
-            });
-        }
-    };
-function createH3ErrorHandler() {
-    return (0, __WEBPACK_EXTERNAL_MODULE_h3__.eventHandler)((event)=>{
-        event.context._onError = (error)=>{
-            event.context.logger.error('Error in H3 error handler', {
-                error
-            });
-            if (error instanceof error_class_DoubleTieError) {
-                event.context.logger.error('Handling DoubleTieError:', error.statusCode, error.message);
-                return (0, __WEBPACK_EXTERNAL_MODULE_h3__.sendError)(event, error);
-            }
-            event.context.logger.error('Handling generic error', {
-                error
-            });
-            const dtError = new error_class_DoubleTieError(error instanceof Error ? error.message : String(error), {
-                code: error_codes_ERROR_CODES.INTERNAL_SERVER_ERROR,
-                status: 500,
-                cause: error instanceof Error ? error : void 0
-            });
-            return (0, __WEBPACK_EXTERNAL_MODULE_h3__.sendError)(event, dtError);
-        };
-        event.node.req.on('error', (err)=>{
-            event.context.logger.error('Request error event triggered:', {
-                err
-            });
-            if (event.context._onError) event.context._onError(err);
-        });
-    });
-}
-function withH3ErrorHandling(handler) {
-    return (0, __WEBPACK_EXTERNAL_MODULE_h3__.eventHandler)(async (event)=>{
-        try {
-            return await handler(event);
-        } catch (error) {
-            event.context.logger.error('Error caught in withH3ErrorHandling:', {
-                error
-            });
-            if (error instanceof error_class_DoubleTieError) {
-                event.context.logger.error('Handling DoubleTieError in wrapper:', error.statusCode, error.message);
-                return (0, __WEBPACK_EXTERNAL_MODULE_h3__.sendError)(event, error);
-            }
-            if (event.context._onError && 'function' == typeof event.context._onError) return event.context._onError(error);
-            const dtError = new error_class_DoubleTieError(error instanceof Error ? error.message : String(error), {
-                code: error_codes_ERROR_CODES.INTERNAL_SERVER_ERROR,
-                status: 500,
-                cause: error instanceof Error ? error : void 0
-            });
-            return (0, __WEBPACK_EXTERNAL_MODULE_h3__.sendError)(event, dtError);
-        }
-    });
-}
 function createTelemetryOptions(appName = 'c15t', telemetryConfig) {
     const serviceVersion = process.env.npm_package_version || '1.0.0';
     const config = {
@@ -705,138 +261,123 @@ function createTelemetryOptions(appName = 'c15t', telemetryConfig) {
     };
     return config;
 }
-var ZodError = __webpack_require__("../../node_modules/.pnpm/zod@3.24.2/node_modules/zod/lib/ZodError.js");
-const levels = [
-    'error',
-    'warn',
-    'info',
-    'success',
-    'debug'
-];
-function shouldPublishLog(currentLogLevel, logLevel) {
-    const currentLevelIndex = levels.indexOf(currentLogLevel);
-    const messageLevelIndex = levels.indexOf(logLevel);
-    if ('debug' === currentLogLevel) return 'debug' === logLevel;
-    return messageLevelIndex <= currentLevelIndex;
-}
-const colors = {
-    reset: '\x1b[0m',
-    bright: '\x1b[1m',
-    dim: '\x1b[2m',
-    underscore: '\x1b[4m',
-    blink: '\x1b[5m',
-    reverse: '\x1b[7m',
-    hidden: '\x1b[8m',
-    fg: {
-        black: '\x1b[30m',
-        red: '\x1b[31m',
-        green: '\x1b[32m',
-        yellow: '\x1b[33m',
-        blue: '\x1b[34m',
-        magenta: '\x1b[35m',
-        cyan: '\x1b[36m',
-        white: '\x1b[37m'
-    },
-    bg: {
-        black: '\x1b[40m',
-        red: '\x1b[41m',
-        green: '\x1b[42m',
-        yellow: '\x1b[43m',
-        blue: '\x1b[44m',
-        magenta: '\x1b[45m',
-        cyan: '\x1b[46m',
-        white: '\x1b[47m'
-    }
-};
-const levelColors = {
-    info: colors.fg.blue,
-    success: colors.fg.green,
-    warn: colors.fg.yellow,
-    error: colors.fg.red,
-    debug: colors.fg.magenta
-};
-const formatMessage = (level, message, appName = 'c15t')=>{
-    const timestamp = new Date().toISOString();
-    return `${colors.dim}${timestamp}${colors.reset} ${levelColors[level]}${level.toUpperCase()}${colors.reset} ${colors.bright}[${appName}]:${colors.reset} ${message}`;
-};
-const LOGGER_TRACER_NAME = '@doubletie/logger';
-const LOG_LEVEL_TO_SPAN_STATUS = {
-    error: __WEBPACK_EXTERNAL_MODULE__opentelemetry_api_87359e78__.SpanStatusCode.ERROR,
-    warn: __WEBPACK_EXTERNAL_MODULE__opentelemetry_api_87359e78__.SpanStatusCode.OK,
-    info: __WEBPACK_EXTERNAL_MODULE__opentelemetry_api_87359e78__.SpanStatusCode.OK,
-    success: __WEBPACK_EXTERNAL_MODULE__opentelemetry_api_87359e78__.SpanStatusCode.OK,
-    debug: __WEBPACK_EXTERNAL_MODULE__opentelemetry_api_87359e78__.SpanStatusCode.OK
-};
-const telemetry_getTracer = (options)=>{
-    if (options?.telemetry?.tracer) return options.telemetry.tracer;
-    return __WEBPACK_EXTERNAL_MODULE__opentelemetry_api_87359e78__.trace.getTracer(LOGGER_TRACER_NAME);
-};
-const createLogSpan = (level, message, args = [], options)=>{
-    if (options?.telemetry?.disabled) return null;
-    const tracer = telemetry_getTracer(options);
-    const span = tracer.startSpan('log_entry', {
-        attributes: {
-            'log.level': level,
-            'log.message': message,
-            'log.has_args': args.length > 0,
-            ...options?.telemetry?.defaultAttributes || {}
-        }
-    });
-    if (args.length > 0 && 'object' == typeof args[0] && null !== args[0]) {
-        const data = args[0];
-        for (const [key, value] of Object.entries(data))if (null != value) span.setAttribute(`log.data.${key}`, String(value));
+var package_namespaceObject = JSON.parse('{"i8":"1.2.0-canary.0"}');
+function utils_applyDefaultValue(inputValue, field, operation) {
+    if ('update' === operation) return inputValue;
+    if (null == inputValue && field.defaultValue) {
+        if ('function' == typeof field.defaultValue) return field.defaultValue();
+        return field.defaultValue;
     }
-    span.setStatus({
-        code: LOG_LEVEL_TO_SPAN_STATUS[level],
-        message: 'error' === level || 'warn' === level ? message : void 0
-    });
-    return span;
+    return inputValue;
+}
+const COMMON_TIMEZONES = {
+    UTC: 'UTC',
+    GMT: 'GMT',
+    EASTERN: 'America/New_York',
+    CENTRAL: 'America/Chicago',
+    MOUNTAIN: 'America/Denver',
+    PACIFIC: 'America/Los_Angeles',
+    LONDON: 'Europe/London',
+    PARIS: 'Europe/Paris',
+    BERLIN: 'Europe/Berlin',
+    TOKYO: 'Asia/Tokyo',
+    SHANGHAI: 'Asia/Shanghai',
+    SINGAPORE: 'Asia/Singapore',
+    SYDNEY: 'Australia/Sydney',
+    SAO_PAULO: 'America/Sao_Paulo'
 };
-const withLogSpan = async (level, message, args, operation, options)=>{
-    const span = createLogSpan(level, message, args, options);
-    if (!span) return operation();
-    try {
-        const result = await operation();
-        return result;
-    } catch (error) {
-        span.setStatus({
-            code: __WEBPACK_EXTERNAL_MODULE__opentelemetry_api_87359e78__.SpanStatusCode.ERROR,
-            message: error instanceof Error ? error.message : String(error)
-        });
-        throw error;
-    } finally{
-        span.end();
-    }
-};
-const createLogger = (options)=>{
-    if (options && 'object' == typeof options && levels.every((level)=>'function' == typeof options[level])) return options;
-    const loggerOptions = options;
-    const enabled = loggerOptions?.disabled !== true;
-    const logLevel = loggerOptions?.level ?? 'error';
-    const appName = loggerOptions?.appName ?? 'c15t';
-    const logFunc = async (level, message, args = [])=>{
-        if (!enabled || !shouldPublishLog(logLevel, level)) return;
-        await withLogSpan(level, message, args, async ()=>{
-            const formattedMessage = formatMessage(level, message, appName);
-            if (!loggerOptions || 'function' != typeof loggerOptions.log) {
-                if ('error' === level) console.error(formattedMessage, ...args);
-                else if ('warn' === level) console.warn(formattedMessage, ...args);
-                else if ('info' === level) console.log(formattedMessage, ...args);
-                else if ('debug' === level) console.debug(formattedMessage, ...args);
-                else if ('success' === level) console.log(formattedMessage, ...args);
-                return;
-            }
-            loggerOptions.log('success' === level ? 'info' : level, message, ...args);
-        });
-    };
-    return Object.fromEntries(levels.map((level)=>[
-            level,
-            (...[message, ...args])=>logFunc(level, message, args).catch((error)=>{
-                    console.error('Logger error:', error);
-                })
-        ]));
-};
-const logger_factory_logger = createLogger();
+const b58 = (0, __WEBPACK_EXTERNAL_MODULE_base_x_aeb88370__["default"])('123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz');
+function id_generator_generateId(prefix) {
+    const buf = crypto.getRandomValues(new Uint8Array(20));
+    const EPOCH_TIMESTAMP = 1700000000000;
+    const t = Date.now() - EPOCH_TIMESTAMP;
+    const high = Math.floor(t / 0x100000000);
+    const low = t >>> 0;
+    buf[0] = high >>> 24 & 255;
+    buf[1] = high >>> 16 & 255;
+    buf[2] = high >>> 8 & 255;
+    buf[3] = 255 & high;
+    buf[4] = low >>> 24 & 255;
+    buf[5] = low >>> 16 & 255;
+    buf[6] = low >>> 8 & 255;
+    buf[7] = 255 & low;
+    return `${prefix}_${b58.encode(buf)}`;
+}
+const fieldConfigSchema = __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+    required: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean().default(true),
+    returned: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean().default(true),
+    input: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean().default(true),
+    defaultValue: __WEBPACK_EXTERNAL_MODULE_zod__.z.union([
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.any(),
+        __WEBPACK_EXTERNAL_MODULE_zod__.z["function"]().returns(__WEBPACK_EXTERNAL_MODULE_zod__.z.any())
+    ]).optional(),
+    transform: __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+        input: __WEBPACK_EXTERNAL_MODULE_zod__.z["function"]().args(__WEBPACK_EXTERNAL_MODULE_zod__.z.any()).returns(__WEBPACK_EXTERNAL_MODULE_zod__.z.union([
+            __WEBPACK_EXTERNAL_MODULE_zod__.z.any(),
+            __WEBPACK_EXTERNAL_MODULE_zod__.z.promise(__WEBPACK_EXTERNAL_MODULE_zod__.z.any())
+        ])).optional(),
+        output: __WEBPACK_EXTERNAL_MODULE_zod__.z["function"]().args(__WEBPACK_EXTERNAL_MODULE_zod__.z.any()).returns(__WEBPACK_EXTERNAL_MODULE_zod__.z.union([
+            __WEBPACK_EXTERNAL_MODULE_zod__.z.any(),
+            __WEBPACK_EXTERNAL_MODULE_zod__.z.promise(__WEBPACK_EXTERNAL_MODULE_zod__.z.any())
+        ])).optional()
+    }).optional(),
+    validator: __WEBPACK_EXTERNAL_MODULE_zod__.z["function"]().args(__WEBPACK_EXTERNAL_MODULE_zod__.z.any()).returns(__WEBPACK_EXTERNAL_MODULE_zod__.z.union([
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+        __WEBPACK_EXTERNAL_MODULE_zod__.z["null"]()
+    ])).optional(),
+    unique: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean().optional(),
+    indexed: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean().optional(),
+    sortable: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean().default(true),
+    fieldName: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().optional(),
+    bigint: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean().default(false)
+});
+const stringFieldSchema = fieldConfigSchema.extend({
+    type: __WEBPACK_EXTERNAL_MODULE_zod__.z.literal('string'),
+    minLength: __WEBPACK_EXTERNAL_MODULE_zod__.z.number().optional(),
+    maxLength: __WEBPACK_EXTERNAL_MODULE_zod__.z.number().optional(),
+    pattern: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().optional()
+});
+const numberFieldSchema = fieldConfigSchema.extend({
+    type: __WEBPACK_EXTERNAL_MODULE_zod__.z.literal('number'),
+    min: __WEBPACK_EXTERNAL_MODULE_zod__.z.number().optional(),
+    max: __WEBPACK_EXTERNAL_MODULE_zod__.z.number().optional()
+});
+const booleanFieldSchema = fieldConfigSchema.extend({
+    type: __WEBPACK_EXTERNAL_MODULE_zod__.z.literal('boolean')
+});
+const dateFieldSchema = fieldConfigSchema.extend({
+    type: __WEBPACK_EXTERNAL_MODULE_zod__.z.literal('date'),
+    minDate: __WEBPACK_EXTERNAL_MODULE_zod__.z.date().optional(),
+    maxDate: __WEBPACK_EXTERNAL_MODULE_zod__.z.date().optional(),
+    dateOnly: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean().default(false),
+    format: __WEBPACK_EXTERNAL_MODULE_zod__.z.record(__WEBPACK_EXTERNAL_MODULE_zod__.z.unknown()).optional()
+});
+const timezoneFieldSchema = fieldConfigSchema.extend({
+    type: __WEBPACK_EXTERNAL_MODULE_zod__.z.literal('timezone'),
+    validateTimezone: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean().default(true),
+    suggestedValues: __WEBPACK_EXTERNAL_MODULE_zod__.z.array(__WEBPACK_EXTERNAL_MODULE_zod__.z.string()).optional(),
+    restrictToSuggestedValues: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean().default(false)
+});
+const jsonFieldSchema = fieldConfigSchema.extend({
+    type: __WEBPACK_EXTERNAL_MODULE_zod__.z.literal('json'),
+    validateJson: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean().default(true)
+});
+const stringArrayFieldSchema = fieldConfigSchema.extend({
+    type: __WEBPACK_EXTERNAL_MODULE_zod__.z.literal('string[]')
+});
+const numberArrayFieldSchema = fieldConfigSchema.extend({
+    type: __WEBPACK_EXTERNAL_MODULE_zod__.z.literal('number[]')
+});
+__WEBPACK_EXTERNAL_MODULE_zod__.z.discriminatedUnion('type', [
+    stringFieldSchema,
+    numberFieldSchema,
+    booleanFieldSchema,
+    dateFieldSchema,
+    timezoneFieldSchema,
+    jsonFieldSchema,
+    stringArrayFieldSchema,
+    numberArrayFieldSchema
+]);
 const schema_auditLogSchema = __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
     id: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
     entityType: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
@@ -1442,7 +983,7 @@ function validateEntityOutput(tableName, data, options) {
     try {
         return table.schema.parse(processedData);
     } catch (error) {
-        if (error instanceof ZodError.ZodError) logger_factory_logger.error(`[validateEntityOutput] Validation failed for table ${String(tableName)}`, {
+        if (error instanceof __WEBPACK_EXTERNAL_MODULE_zod__.ZodError) __WEBPACK_EXTERNAL_MODULE__doubletie_logger_91c58a8f__.logger.error(`[validateEntityOutput] Validation failed for table ${String(tableName)}`, {
             table,
             issues: error.issues
         });
@@ -2567,9 +2108,23 @@ const memoryAdapter = (db)=>(options)=>{
             }
         };
     };
+let globalLogger;
+function getLogger(options) {
+    if (!globalLogger) globalLogger = (0, __WEBPACK_EXTERNAL_MODULE__doubletie_logger_91c58a8f__.createLogger)({
+        level: 'info',
+        appName: 'c15t',
+        ...options
+    });
+    return globalLogger;
+}
+function initLogger(options) {
+    globalLogger = (0, __WEBPACK_EXTERNAL_MODULE__doubletie_logger_91c58a8f__.createLogger)(options);
+    return globalLogger;
+}
 async function getAdapter(options) {
-    const logger = createLogger({
-        appName: 'c15t'
+    const logger = getLogger({
+        appName: options.appName ?? 'c15t',
+        ...options.logger
     });
     if (!options.database) {
         const tables = definition_getConsentTables(options);
@@ -2639,7 +2194,7 @@ const init = async (options)=>{
         const basePathStr = options.basePath;
         const databaseHooks = options.databaseHooks || [];
         const appName = options.appName || 'c15t';
-        const logger = createLogger({
+        const logger = initLogger({
             ...loggerOptions,
             appName: String(appName)
         });
@@ -2655,7 +2210,7 @@ const init = async (options)=>{
             } else {
                 const resource = new __WEBPACK_EXTERNAL_MODULE__opentelemetry_resources_c7ac8648__.Resource({
                     'service.name': String(appName),
-                    'service.version': String(process.env.npm_package_version || '1.0.0'),
+                    'service.version': String(package_namespaceObject.i8 || '1.0.0'),
                     ...telemetryOptions?.defaultAttributes || {}
                 });
                 logger.debug('Initializing telemetry with resource attributes', {
@@ -2728,7 +2283,7 @@ const init = async (options)=>{
             return runPluginInit(ctx);
         });
     } catch (error) {
-        const errorLogger = createLogger(options.logger);
+        const errorLogger = getLogger(options.logger);
         errorLogger.error('Initialization failed', {
             error: error instanceof Error ? error.message : String(error),
             stack: error instanceof Error ? error.stack : void 0
@@ -2774,167 +2329,116 @@ function getInternalPlugins(_options) {
     const plugins = [];
     return plugins;
 }
-function defineRoute(pathOrConfig, handlerOrUndefined, options) {
-    if ('string' == typeof pathOrConfig && handlerOrUndefined) return {
-        path: pathOrConfig,
-        handler: handlerOrUndefined,
-        options
-    };
-    const config = pathOrConfig;
-    const handler = (0, __WEBPACK_EXTERNAL_MODULE_h3__.defineEventHandler)(async (event)=>{
-        const logger = event.context.logger || createLogger();
-        logger.debug(`Handling request for ${config.method} ${config.path}`);
-        if (!event.context.logger) event.context.logger = logger;
-        const validated = {
-            body: void 0,
-            query: void 0,
-            params: void 0
-        };
-        try {
-            if (config.validations?.body) {
-                const contentType = event.headers.get('content-type');
-                const body = contentType?.includes('multipart/form-data') ? Object.fromEntries(await (0, __WEBPACK_EXTERNAL_MODULE_h3__.readFormData)(event)) : await (0, __WEBPACK_EXTERNAL_MODULE_h3__.readBody)(event);
-                logger.debug('Validating request body', {
-                    body
-                });
-                const validateBody = validationPipeline(config.validations.body, (data)=>data);
-                const result = await validateBody(body);
-                result.match((data)=>{
-                    validated.body = data;
-                }, (error)=>{
-                    logger.error('Validation error (body)', {
-                        error
-                    });
-                    throw new error_class_DoubleTieError('Body validation failed', {
-                        code: error_codes_ERROR_CODES.BAD_REQUEST,
-                        status: 422,
-                        cause: error instanceof Error ? error : void 0,
-                        meta: {
-                            validationErrors: error,
-                            requestPath: config.path,
-                            requestMethod: config.method
-                        }
-                    });
-                });
-            }
-            if (config.validations?.query) {
-                const query = getQuery(event);
-                logger.debug('Validating query parameters', {
-                    query
-                });
-                const validateQuery = validationPipeline(config.validations.query, (data)=>data);
-                const result = await validateQuery(query);
-                result.match((data)=>{
-                    validated.query = data;
-                }, (error)=>{
-                    logger.error('Query validation failed', {
-                        error
-                    });
-                    throw new error_class_DoubleTieError('Query validation failed', {
-                        code: error_codes_ERROR_CODES.BAD_REQUEST,
-                        status: 422,
-                        cause: error instanceof Error ? error : void 0,
-                        meta: {
-                            validationErrors: error,
-                            requestPath: config.path,
-                            requestMethod: config.method
-                        }
-                    });
-                });
-            }
-            if (config.validations?.params) {
-                const params = getRouterParams(event);
-                logger.debug('Validating route parameters', {
-                    params
-                });
-                const validateParams = validationPipeline(config.validations.params, (data)=>data);
-                const result = await validateParams(params);
-                result.match((data)=>{
-                    validated.params = data;
-                }, (error)=>{
-                    logger.error('Path parameters validation failed', {
-                        error
-                    });
-                    throw new error_class_DoubleTieError('Path parameters validation failed', {
-                        code: error_codes_ERROR_CODES.BAD_REQUEST,
-                        status: 422,
-                        cause: error instanceof Error ? error : void 0,
-                        meta: {
-                            validationErrors: error,
-                            requestPath: config.path,
-                            requestMethod: config.method
-                        }
-                    });
-                });
-            }
-            const eventWithContext = event;
-            eventWithContext.context = {
-                ...event.context,
-                validated
-            };
-            logger.debug(`Executing handler for ${config.method} ${config.path}`);
-            const response = await config.handler(eventWithContext);
-            logger.debug(`Handler execution complete for ${config.method} ${config.path}, response type: ${typeof response}`);
-            if (null == response) {
-                logger.warn(`Handler for ${config.method} ${config.path} returned ${null === response ? 'null' : 'undefined'}`);
-                return {};
-            }
-            if ('boolean' == typeof response || 'number' == typeof response || 'string' == typeof response) {
-                logger.warn(`Handler for ${config.method} ${config.path} returned primitive ${typeof response}, wrapping in object`);
-                return {
-                    value: response
-                };
-            }
-            return response;
-        } catch (error) {
-            if (error instanceof error_class_DoubleTieError) throw error;
-            logger.error('Validation failed', {
-                error
-            });
-            let validationErrors = 'Unknown validation error';
-            let statusCode = 422;
-            if (error instanceof Error) {
-                validationErrors = error.message;
-                if ('ZodError' === error.name && 'format' in error && 'function' == typeof error.format) try {
-                    validationErrors = error.format();
-                    statusCode = 422;
-                } catch  {
-                    validationErrors = `Validation error: ${error.message}`;
-                }
-            }
-            logger.error('Validation failed', {
-                error,
-                validationErrors
-            });
-            throw new error_class_DoubleTieError('Validation failed', {
-                code: error_codes_ERROR_CODES.BAD_REQUEST,
-                status: statusCode,
-                cause: error instanceof Error ? error : void 0,
-                meta: {
-                    validationErrors,
-                    requestPath: config.path,
-                    requestMethod: config.method
-                }
-            });
+const API_ROUTER_TRACER_NAME = '@doubletie/api-router';
+const getTracer = (options)=>{
+    if (options?.telemetry?.tracer) return options.telemetry.tracer;
+    return __WEBPACK_EXTERNAL_MODULE__opentelemetry_api_87359e78__.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 {
-        path: config.path,
-        method: config.method,
-        handler,
-        responseType: {}
-    };
-}
-function getQuery(event) {
-    return (0, __WEBPACK_EXTERNAL_MODULE_h3__.getQuery)(event);
+    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: __WEBPACK_EXTERNAL_MODULE__opentelemetry_api_87359e78__.SpanStatusCode.OK
+        });
+        return result;
+    } catch (error) {
+        handleSpanError(span, error);
+        throw error;
+    } finally{
+        span.end();
+    }
+};
+const handleSpanError = (span, error)=>{
+    span.setStatus({
+        code: __WEBPACK_EXTERNAL_MODULE__opentelemetry_api_87359e78__.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 STRIP_REGEX = /^(https?:\/\/)|(wss?:\/\/)|(\/+$)|:\d+/g;
+function isOriginTrusted(origin, trustedDomains, logger) {
+    try {
+        if (0 === trustedDomains.length) throw new Error('No trusted domains');
+        logger?.debug(`Checking if origin ${origin} is trusted in ${trustedDomains}`);
+        if (trustedDomains.includes('*')) {
+            logger?.debug('Allowing all origins');
+            return true;
+        }
+        const url = new URL(origin);
+        const originHostname = url.hostname.toLowerCase();
+        logger?.debug(`Parsed origin hostname: ${originHostname}`);
+        return trustedDomains.some((domain)=>{
+            if (!domain || '' === domain.trim()) {
+                logger?.debug('Skipping empty domain');
+                return false;
+            }
+            const strippedDomain = domain.replace(STRIP_REGEX, '').toLowerCase();
+            logger?.debug(`Checking against stripped domain: ${strippedDomain}`);
+            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;
+        });
+    } catch (error) {
+        logger?.error('Error validating origin:', error);
+        return false;
+    }
 }
-function getRouterParams(event) {
-    return (0, __WEBPACK_EXTERNAL_MODULE_h3__.getRouterParams)(event) || {};
+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 baseConsentSchema = __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
     subjectId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().optional(),
     externalSubjectId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().optional(),
-    domain: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    domain: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().regex(/^(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z]{2,}$/i, 'invalid domain'),
     type: PolicyTypeSchema,
     metadata: __WEBPACK_EXTERNAL_MODULE_zod__.z.record(__WEBPACK_EXTERNAL_MODULE_zod__.z.unknown()).optional()
 });
@@ -2959,210 +2463,513 @@ const otherConsentSchema = baseConsentSchema.extend({
     ]),
     preferences: __WEBPACK_EXTERNAL_MODULE_zod__.z.record(__WEBPACK_EXTERNAL_MODULE_zod__.z.boolean()).optional()
 });
-const SetConsentRequestBody = __WEBPACK_EXTERNAL_MODULE_zod__.z.discriminatedUnion('type', [
-    cookieBannerSchema,
-    policyBasedSchema,
-    otherConsentSchema
-]);
-const setConsent = defineRoute({
+const postConsentContract = __WEBPACK_EXTERNAL_MODULE__orpc_contract_5a058524__.oc.route({
+    method: 'POST',
     path: '/consent/set',
-    method: 'post',
-    validations: {
-        body: SetConsentRequestBody
+    description: `Records a user's consent preferences and creates necessary consent records.
+This endpoint handles various types of consent submissions:
+
+1. Cookie Banner Consent:
+   - Records granular cookie preferences
+   - Supports multiple consent purposes
+   - Creates audit trail for compliance
+
+2. Policy-Based Consent:
+   - Privacy Policy acceptance
+   - Data Processing Agreement (DPA) consent
+   - Terms and Conditions acceptance
+   - Links consent to specific policy versions
+
+3. Other Consent Types:
+   - Marketing communications preferences
+   - Age verification consent
+   - Custom consent types
+
+The endpoint performs the following operations:
+- Creates or retrieves subject records
+- Validates domain and policy information
+- Creates consent records with audit trails
+- Records consent purposes and preferences
+- Generates audit logs for compliance
+
+Use this endpoint to record user consent and maintain a compliant consent management system.`,
+    tags: [
+        'consent',
+        'cookie-banner'
+    ]
+}).errors({
+    INPUT_VALIDATION_FAILED: {
+        status: 422,
+        message: 'Invalid input parameters',
+        data: __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+            formErrors: __WEBPACK_EXTERNAL_MODULE_zod__.z.array(__WEBPACK_EXTERNAL_MODULE_zod__.z.string()),
+            fieldErrors: __WEBPACK_EXTERNAL_MODULE_zod__.z.record(__WEBPACK_EXTERNAL_MODULE_zod__.z.string(), __WEBPACK_EXTERNAL_MODULE_zod__.z.array(__WEBPACK_EXTERNAL_MODULE_zod__.z.string()))
+        })
     },
-    handler: async (event)=>{
-        const logger = event.context.logger || createLogger();
-        logger.info('Handling set-consent request');
-        const { body } = event.context.validated;
-        const { registry, adapter } = event.context;
-        const { type, subjectId, externalSubjectId, domain, metadata } = body;
-        logger.debug('Request parameters', {
-            type,
-            subjectId,
-            externalSubjectId,
-            domain
-        });
-        try {
-            const subject = await registry.findOrCreateSubject({
-                subjectId,
-                externalSubjectId,
-                ipAddress: event.context.ipAddress || 'unknown'
-            });
-            if (!subject) {
-                const errMsg = 'Subject not found or could not be created';
-                logger.error(errMsg, {
-                    subjectId,
-                    externalSubjectId
-                });
-                throw new error_class_DoubleTieError(errMsg, {
-                    code: error_codes_ERROR_CODES.BAD_REQUEST,
-                    status: 400,
-                    meta: {
-                        subjectId,
-                        externalSubjectId
-                    }
-                });
+    SUBJECT_CREATION_FAILED: {
+        status: 400,
+        message: 'Failed to create or find subject',
+        data: __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+            subjectId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().optional(),
+            externalSubjectId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().optional()
+        })
+    },
+    DOMAIN_CREATION_FAILED: {
+        status: 500,
+        message: 'Failed to create or find domain',
+        data: __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+            domain: __WEBPACK_EXTERNAL_MODULE_zod__.z.string()
+        })
+    },
+    POLICY_NOT_FOUND: {
+        status: 404,
+        message: 'Policy not found',
+        data: __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+            policyId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+            type: __WEBPACK_EXTERNAL_MODULE_zod__.z.string()
+        })
+    },
+    POLICY_INACTIVE: {
+        status: 409,
+        message: 'Policy is not active',
+        data: __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+            policyId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+            type: __WEBPACK_EXTERNAL_MODULE_zod__.z.string()
+        })
+    },
+    POLICY_CREATION_FAILED: {
+        status: 500,
+        message: 'Failed to create or find policy',
+        data: __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+            type: __WEBPACK_EXTERNAL_MODULE_zod__.z.string()
+        })
+    },
+    PURPOSE_CREATION_FAILED: {
+        status: 500,
+        message: 'Failed to create consent purpose',
+        data: __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+            purposeCode: __WEBPACK_EXTERNAL_MODULE_zod__.z.string()
+        })
+    },
+    CONSENT_CREATION_FAILED: {
+        status: 500,
+        message: 'Failed to create consent record',
+        data: __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+            subjectId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+            domain: __WEBPACK_EXTERNAL_MODULE_zod__.z.string()
+        })
+    }
+}).input(__WEBPACK_EXTERNAL_MODULE_zod__.z.discriminatedUnion('type', [
+    cookieBannerSchema,
+    policyBasedSchema,
+    otherConsentSchema
+])).output(__WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+    id: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    subjectId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().optional(),
+    externalSubjectId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().optional(),
+    domainId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    domain: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    type: PolicyTypeSchema,
+    status: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    recordId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    metadata: __WEBPACK_EXTERNAL_MODULE_zod__.z.record(__WEBPACK_EXTERNAL_MODULE_zod__.z.unknown()).optional(),
+    givenAt: __WEBPACK_EXTERNAL_MODULE_zod__.z.date()
+}));
+const JurisdictionMessages = {
+    GDPR: 'GDPR or equivalent regulations require a cookie banner.',
+    CH: 'Switzerland requires similar data protection measures.',
+    BR: "Brazil's LGPD requires consent for cookies.",
+    PIPEDA: 'PIPEDA requires consent for data collection.',
+    AU: "Australia's Privacy Act mandates transparency about data collection.",
+    APPI: "Japan's APPI requires consent for data collection.",
+    PIPA: "South Korea's PIPA requires consent for data collection.",
+    NONE: 'No specific requirements'
+};
+const JurisdictionCodeSchema = __WEBPACK_EXTERNAL_MODULE_zod__.z["enum"]([
+    'GDPR',
+    'CH',
+    'BR',
+    'PIPEDA',
+    'AU',
+    'APPI',
+    'PIPA',
+    'NONE'
+]);
+const JurisdictionInfoSchema = __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+    code: JurisdictionCodeSchema,
+    message: __WEBPACK_EXTERNAL_MODULE_zod__.z.string()
+});
+const showConsentBannerContract = __WEBPACK_EXTERNAL_MODULE__orpc_contract_5a058524__.oc.route({
+    method: 'GET',
+    path: '/show-consent-banner',
+    description: `Determines if a user should see a consent banner based on their location and applicable privacy regulations.
+This endpoint performs the following checks:
+
+1. Detects the user's location using various header information:
+   - Cloudflare country headers
+   - Vercel IP country headers
+   - AWS CloudFront headers
+   - Custom country code headers
+
+2. Determines the applicable jurisdiction based on the location:
+   - GDPR (EU/EEA/UK)
+   - Swiss Data Protection Act
+   - LGPD (Brazil)
+   - PIPEDA (Canada)
+   - Australian Privacy Principles
+   - APPI (Japan)
+   - PIPA (South Korea)
+
+3. Returns detailed information about:
+   - Whether to show the consent banner
+   - The applicable jurisdiction and its requirements
+   - The user's detected location (country and region)
+
+Use this endpoint to implement geo-targeted consent banners and ensure compliance with regional privacy regulations.`,
+    tags: [
+        'cookie-banner'
+    ]
+}).output(__WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+    showConsentBanner: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean(),
+    jurisdiction: JurisdictionInfoSchema,
+    location: __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+        countryCode: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullable(),
+        regionCode: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullable()
+    })
+}));
+const verifyConsentInputSchema = __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+    subjectId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().optional(),
+    externalSubjectId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().optional(),
+    domain: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    type: PolicyTypeSchema,
+    policyId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().optional(),
+    preferences: __WEBPACK_EXTERNAL_MODULE_zod__.z.array(__WEBPACK_EXTERNAL_MODULE_zod__.z.string()).optional()
+}).strict();
+const verify_contract_consentSchema = __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+    id: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    purposeIds: __WEBPACK_EXTERNAL_MODULE_zod__.z.array(__WEBPACK_EXTERNAL_MODULE_zod__.z.string())
+}).passthrough();
+const verifyConsentContract = __WEBPACK_EXTERNAL_MODULE__orpc_contract_5a058524__.oc.route({
+    method: 'POST',
+    path: '/consent/verify',
+    description: `Verifies if a user has given valid consent for a specific policy and domain.
+This endpoint performs comprehensive consent verification by:
+
+1. Validating the subject's identity (using subjectId or externalSubjectId)
+2. Verifying the domain's existence and validity
+3. Checking if the specified policy exists and is active
+4. Validating that all required purposes have been consented to
+5. Ensuring the consent record is current and valid
+
+The endpoint supports different types of consent verification:
+- Cookie banner consent verification
+- Privacy policy consent verification
+- Terms and conditions verification
+- Marketing communications consent verification
+- Age verification
+- Custom consent types
+
+Use this endpoint to ensure compliance with privacy regulations and to verify user consent before processing personal data.`,
+    tags: [
+        'consent'
+    ]
+}).errors({
+    INPUT_VALIDATION_FAILED: {
+        status: 422,
+        message: 'Invalid input parameters',
+        data: __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+            formErrors: __WEBPACK_EXTERNAL_MODULE_zod__.z.array(__WEBPACK_EXTERNAL_MODULE_zod__.z.string()),
+            fieldErrors: __WEBPACK_EXTERNAL_MODULE_zod__.z.record(__WEBPACK_EXTERNAL_MODULE_zod__.z.string(), __WEBPACK_EXTERNAL_MODULE_zod__.z.array(__WEBPACK_EXTERNAL_MODULE_zod__.z.string()).optional())
+        })
+    },
+    SUBJECT_NOT_FOUND: {
+        status: 404,
+        message: 'Subject not found',
+        data: __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+            subjectId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().optional(),
+            externalSubjectId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().optional()
+        })
+    },
+    DOMAIN_NOT_FOUND: {
+        status: 404,
+        message: 'Domain not found',
+        data: __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+            domain: __WEBPACK_EXTERNAL_MODULE_zod__.z.string()
+        })
+    },
+    POLICY_NOT_FOUND: {
+        status: 404,
+        message: 'Policy not found or invalid',
+        data: __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+            policyId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+            type: __WEBPACK_EXTERNAL_MODULE_zod__.z.string()
+        })
+    },
+    PURPOSES_NOT_FOUND: {
+        status: 404,
+        message: 'Could not find all specified purposes',
+        data: __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+            preferences: __WEBPACK_EXTERNAL_MODULE_zod__.z.array(__WEBPACK_EXTERNAL_MODULE_zod__.z.string()),
+            foundPurposes: __WEBPACK_EXTERNAL_MODULE_zod__.z.array(__WEBPACK_EXTERNAL_MODULE_zod__.z.string())
+        })
+    },
+    COOKIE_BANNER_PREFERENCES_REQUIRED: {
+        status: 400,
+        message: 'Preferences are required for cookie banner consent',
+        data: __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+            type: __WEBPACK_EXTERNAL_MODULE_zod__.z.literal('cookie_banner')
+        })
+    },
+    NO_CONSENT_FOUND: {
+        status: 404,
+        message: 'No consent found for the given policy',
+        data: __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+            policyId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+            subjectId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+            domainId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string()
+        })
+    }
+}).input(verifyConsentInputSchema).output(__WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+    isValid: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean(),
+    reasons: __WEBPACK_EXTERNAL_MODULE_zod__.z.array(__WEBPACK_EXTERNAL_MODULE_zod__.z.string()).optional(),
+    consent: verify_contract_consentSchema.optional()
+}));
+const consentContracts = {
+    post: postConsentContract,
+    showBanner: showConsentBannerContract,
+    verify: verifyConsentContract
+};
+const statusContract = __WEBPACK_EXTERNAL_MODULE__orpc_contract_5a058524__.oc.route({
+    method: 'GET',
+    path: '/status',
+    description: `Returns the current operational status and health metrics of the service.
+This endpoint provides real-time information about:
+- Overall service status (ok/error)
+- Current API version
+- Server timestamp
+- Storage system status and availability
+- Client information (IP, User Agent, Region)
+
+Use this endpoint for health checks, monitoring, and service status verification.`,
+    tags: [
+        'meta'
+    ]
+}).output(__WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+    status: __WEBPACK_EXTERNAL_MODULE_zod__.z["enum"]([
+        'ok',
+        'error'
+    ]),
+    version: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    timestamp: __WEBPACK_EXTERNAL_MODULE_zod__.z.date(),
+    storage: __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+        type: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+        available: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean()
+    }),
+    client: __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+        ip: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullable(),
+        userAgent: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullable(),
+        region: __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+            countryCode: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullable(),
+            regionCode: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullable()
+        })
+    })
+}));
+const metaContracts = {
+    status: statusContract
+};
+const contracts_config = {
+    consent: consentContracts,
+    meta: metaContracts
+};
+const os = (0, __WEBPACK_EXTERNAL_MODULE__orpc_server_0dae8408__.implement)(contracts_config);
+const postConsent = os.consent.post.handler(async ({ input, context })=>{
+    const typedContext = context;
+    const logger = typedContext.logger;
+    logger.info('Handling post-consent request');
+    const { type, subjectId, externalSubjectId, domain, metadata, preferences } = input;
+    logger.debug('Request parameters', {
+        type,
+        subjectId,
+        externalSubjectId,
+        domain
+    });
+    try {
+        const subject = await typedContext.registry.findOrCreateSubject({
+            subjectId,
+            externalSubjectId,
+            ipAddress: typedContext.ipAddress || 'unknown'
+        });
+        if (!subject) throw new __WEBPACK_EXTERNAL_MODULE__orpc_server_0dae8408__.ORPCError('SUBJECT_CREATION_FAILED', {
+            data: {
+                subjectId,
+                externalSubjectId
             }
-            logger.debug('Subject found/created', {
-                subjectId: subject.id
-            });
-            const domainRecord = await registry.findOrCreateDomain(domain);
-            const now = new Date();
-            let policyId;
-            let purposeIds = [];
-            if ('policyId' in body) {
-                const { policyId: pid } = body;
-                policyId = pid;
-                if (!policyId) throw new error_class_DoubleTieError('Policy ID is required', {
-                    code: error_codes_ERROR_CODES.BAD_REQUEST,
-                    status: 400,
-                    meta: {
-                        type
-                    }
-                });
-                const policy = await registry.findConsentPolicyById(policyId);
-                if (!policy) throw new error_class_DoubleTieError('Policy not found', {
-                    code: error_codes_ERROR_CODES.NOT_FOUND,
-                    status: 404,
-                    meta: {
-                        policyId
-                    }
-                });
-                if (!policy.isActive) throw new error_class_DoubleTieError('Policy is not active', {
-                    code: error_codes_ERROR_CODES.CONFLICT,
-                    status: 409,
-                    meta: {
-                        policyId
-                    }
-                });
-            } else {
-                const policy = await registry.findOrCreatePolicy(type);
-                if (!policy) throw new error_class_DoubleTieError('Failed to create or find policy', {
-                    code: error_codes_ERROR_CODES.INTERNAL_SERVER_ERROR,
-                    status: 500,
-                    meta: {
-                        type
-                    }
-                });
-                policyId = policy.id;
+        });
+        logger.debug('Subject found/created', {
+            subjectId: subject.id
+        });
+        const domainRecord = await typedContext.registry.findOrCreateDomain(domain);
+        if (!domainRecord) throw new __WEBPACK_EXTERNAL_MODULE__orpc_server_0dae8408__.ORPCError('DOMAIN_CREATION_FAILED', {
+            data: {
+                domain
             }
-            if ('preferences' in body && body.preferences) purposeIds = await Promise.all(Object.entries(body.preferences).filter(([_, isConsented])=>isConsented).map(async ([purposeCode])=>{
-                let existingPurpose = await registry.findConsentPurposeByCode(purposeCode);
-                if (!existingPurpose) existingPurpose = await registry.createConsentPurpose({
+        });
+        const now = new Date();
+        let policyId;
+        let purposeIds = [];
+        if ('policyId' in input && input.policyId) {
+            policyId = input.policyId;
+            const policy = await typedContext.registry.findConsentPolicyById(policyId);
+            if (!policy) throw new __WEBPACK_EXTERNAL_MODULE__orpc_server_0dae8408__.ORPCError('POLICY_NOT_FOUND', {
+                data: {
+                    policyId,
+                    type
+                }
+            });
+            if (!policy.isActive) throw new __WEBPACK_EXTERNAL_MODULE__orpc_server_0dae8408__.ORPCError('POLICY_INACTIVE', {
+                data: {
+                    policyId,
+                    type
+                }
+            });
+        } else {
+            const policy = await typedContext.registry.findOrCreatePolicy(type);
+            if (!policy) throw new __WEBPACK_EXTERNAL_MODULE__orpc_server_0dae8408__.ORPCError('POLICY_CREATION_FAILED', {
+                data: {
+                    type
+                }
+            });
+            policyId = policy.id;
+        }
+        if (preferences) {
+            const consentedPurposes = Object.entries(preferences).filter(([_, isConsented])=>isConsented).map(([purposeCode])=>purposeCode);
+            const existingPurposes = await Promise.all(consentedPurposes.map((purposeCode)=>typedContext.registry.findConsentPurposeByCode(purposeCode)));
+            const purposesToCreate = consentedPurposes.filter((_purposeCode, index)=>!existingPurposes[index]);
+            const createdPurposes = await Promise.all(purposesToCreate.map((purposeCode)=>typedContext.registry.createConsentPurpose({
                     code: purposeCode,
                     name: purposeCode,
                     description: `Auto-created consentPurpose for ${purposeCode}`,
                     isActive: true,
                     isEssential: false,
-                    dataCategory: 'functional',
                     legalBasis: 'consent',
                     createdAt: now,
                     updatedAt: now
-                });
-                return existingPurpose.id;
-            }));
-            const result = await adapter.transaction({
-                callback: async (tx)=>{
-                    const consentRecord = await tx.create({
-                        model: 'consent',
-                        data: {
-                            subjectId: subject.id,
-                            domainId: domainRecord.id,
-                            policyId,
-                            purposeIds,
-                            status: 'active',
-                            isActive: true,
-                            givenAt: now,
-                            ipAddress: event.context.ipAddress || 'unknown',
-                            agent: event.context.userAgent || 'unknown',
-                            history: []
-                        }
-                    });
-                    const record = await tx.create({
-                        model: 'consentRecord',
-                        data: {
-                            subjectId: subject.id,
-                            consentId: consentRecord.id,
-                            actionType: 'consent_given',
-                            details: metadata,
-                            createdAt: now
-                        }
-                    });
-                    await tx.create({
-                        model: 'auditLog',
-                        data: {
-                            subjectId: subject.id,
-                            entityType: 'consent',
-                            entityId: consentRecord.id,
-                            actionType: 'consent_given',
-                            details: {
-                                consentId: consentRecord.id,
-                                type
-                            },
-                            timestamp: now,
-                            ipAddress: event.context.ipAddress || 'unknown',
-                            agent: event.context.userAgent || 'unknown'
-                        }
-                    });
-                    return {
-                        consent: consentRecord,
-                        record
-                    };
-                }
-            });
-            if (!result || !result.consent || !result.record) throw new error_class_DoubleTieError('Failed to create consent record', {
-                code: error_codes_ERROR_CODES.INTERNAL_SERVER_ERROR,
-                status: 500,
-                meta: {
-                    subjectId: subject.id,
-                    domain
+                })));
+            purposeIds = [
+                ...existingPurposes.filter((p)=>null !== p).map((p)=>p.id),
+                ...createdPurposes.filter((p)=>null !== p).map((p)=>p.id)
+            ];
+            if (purposeIds.length !== consentedPurposes.length) throw new __WEBPACK_EXTERNAL_MODULE__orpc_server_0dae8408__.ORPCError('PURPOSE_CREATION_FAILED', {
+                data: {
+                    purposeCode: purposesToCreate[purposeIds.length - consentedPurposes.length]
                 }
             });
-            const response = {
-                id: result.consent.id,
-                subjectId: subject.id,
-                externalSubjectId: subject.externalId ?? void 0,
-                domainId: domainRecord.id,
-                domain: domainRecord.name,
-                type,
-                status: result.consent.status,
-                recordId: result.record.id,
-                metadata,
-                givenAt: result.consent.givenAt.toISOString()
-            };
-            logger.info('Set-consent successful', {
-                consentId: response.id
-            });
-            return response;
-        } catch (error) {
-            logger.error('Error in set-consent handler', {
-                error: error instanceof Error ? error.message : String(error),
-                errorType: error instanceof Error ? error.constructor.name : typeof error
-            });
-            throw error;
         }
-    }
-});
-const show_consent_banner_showConsentBanner = defineRoute({
-    path: '/show-consent-banner',
-    method: 'get',
-    handler: async (event)=>{
-        const countryCode = event.headers.get('cf-ipcountry') || event.headers.get('x-vercel-ip-country') || event.headers.get('x-amz-cf-ipcountry') || event.headers.get('x-country-code');
-        const regionCode = event.headers.get('x-vercel-ip-country-region') || event.headers.get('x-region-code');
-        const { showConsentBanner, jurisdictionCode, message } = checkJurisdiction(countryCode ?? null);
-        return {
-            showConsentBanner,
-            jurisdiction: {
-                code: jurisdictionCode,
-                message
-            },
-            location: {
-                countryCode,
-                regionCode
+        const result = await typedContext.adapter.transaction({
+            callback: async (tx)=>{
+                const consentRecord = await tx.create({
+                    model: 'consent',
+                    data: {
+                        subjectId: subject.id,
+                        domainId: domainRecord.id,
+                        policyId,
+                        purposeIds,
+                        status: 'active',
+                        isActive: true,
+                        givenAt: now,
+                        ipAddress: typedContext.ipAddress || 'unknown',
+                        agent: typedContext.userAgent || 'unknown',
+                        history: []
+                    }
+                });
+                const record = await tx.create({
+                    model: 'consentRecord',
+                    data: {
+                        subjectId: subject.id,
+                        consentId: consentRecord.id,
+                        actionType: 'consent_given',
+                        details: metadata,
+                        createdAt: now
+                    }
+                });
+                await tx.create({
+                    model: 'auditLog',
+                    data: {
+                        subjectId: subject.id,
+                        entityType: 'consent',
+                        entityId: consentRecord.id,
+                        actionType: 'consent_given',
+                        details: {
+                            consentId: consentRecord.id,
+                            type
+                        },
+                        timestamp: now,
+                        ipAddress: typedContext.ipAddress || 'unknown',
+                        agent: typedContext.userAgent || 'unknown'
+                    }
+                });
+                return {
+                    consent: consentRecord,
+                    record
+                };
             }
+        });
+        if (!result || !result.consent || !result.record) throw new __WEBPACK_EXTERNAL_MODULE__orpc_server_0dae8408__.ORPCError('CONSENT_CREATION_FAILED', {
+            data: {
+                subjectId: subject.id,
+                domain
+            }
+        });
+        return {
+            id: result.consent.id,
+            subjectId: subject.id,
+            externalSubjectId: subject.externalId ?? void 0,
+            domainId: domainRecord.id,
+            domain: domainRecord.name,
+            type,
+            status: result.consent.status,
+            recordId: result.record.id,
+            metadata,
+            givenAt: result.consent.givenAt
         };
+    } catch (error) {
+        logger.error('Error in post-consent handler', {
+            error: error instanceof Error ? error.message : String(error),
+            errorType: error instanceof Error ? error.constructor.name : typeof error
+        });
+        if (error instanceof __WEBPACK_EXTERNAL_MODULE__orpc_server_0dae8408__.ORPCError) throw error;
+        throw new __WEBPACK_EXTERNAL_MODULE__orpc_server_0dae8408__.ORPCError('INTERNAL_SERVER_ERROR', {
+            message: error instanceof Error ? error.message : String(error)
+        });
     }
 });
+const show_banner_handler_showConsentBanner = os.consent.showBanner.handler(({ context })=>{
+    const typedContext = context;
+    const headers = typedContext.headers;
+    if (!headers) throw new __WEBPACK_EXTERNAL_MODULE__orpc_server_0dae8408__.ORPCError('LOCATION_DETECTION_FAILED', {
+        data: {
+            reason: 'No headers found in request context'
+        }
+    });
+    const normalizeHeader = (value)=>{
+        if (!value) return null;
+        return Array.isArray(value) ? value[0] ?? null : value;
+    };
+    const countryCode = normalizeHeader(headers.get('cf-ipcountry')) ?? normalizeHeader(headers.get('x-vercel-ip-country')) ?? normalizeHeader(headers.get('x-amz-cf-ipcountry')) ?? normalizeHeader(headers.get('x-country-code'));
+    const regionCode = normalizeHeader(headers.get('x-vercel-ip-country-region')) ?? normalizeHeader(headers.get('x-region-code'));
+    const { showConsentBanner, jurisdictionCode, message } = checkJurisdiction(countryCode);
+    return {
+        showConsentBanner,
+        jurisdiction: {
+            code: jurisdictionCode,
+            message
+        },
+        location: {
+            countryCode,
+            regionCode
+        }
+    };
+});
 function checkJurisdiction(countryCode) {
     const jurisdictions = {
         EU: new Set([
@@ -3223,150 +3030,156 @@ function checkJurisdiction(countryCode) {
     };
     let showConsentBanner = false;
     let jurisdictionCode = 'NONE';
-    let message = 'No specific requirements';
     if (countryCode) {
-        if (jurisdictions.EU.has(countryCode) || jurisdictions.EEA.has(countryCode) || jurisdictions.UK.has(countryCode)) {
-            showConsentBanner = true;
-            jurisdictionCode = 'GDPR';
-            message = 'GDPR or equivalent regulations require a cookie banner.';
-        } else if (jurisdictions.CH.has(countryCode)) {
-            showConsentBanner = true;
-            jurisdictionCode = 'CH';
-            message = 'Switzerland requires similar data protection measures.';
-        } else if (jurisdictions.BR.has(countryCode)) {
-            showConsentBanner = true;
-            jurisdictionCode = 'BR';
-            message = "Brazil's LGPD requires consent for cookies.";
-        } else if (jurisdictions.CA.has(countryCode)) {
-            showConsentBanner = true;
-            jurisdictionCode = 'PIPEDA';
-            message = 'PIPEDA requires consent for data collection.';
-        } else if (jurisdictions.AU.has(countryCode)) {
-            showConsentBanner = true;
-            jurisdictionCode = 'AU';
-            message = "Australia's Privacy Act mandates transparency about data collection.";
-        } else if (jurisdictions.JP.has(countryCode)) {
-            showConsentBanner = true;
-            jurisdictionCode = 'APPI';
-            message = "Japan's APPI requires consent for data collection.";
-        } else if (jurisdictions.KR.has(countryCode)) {
+        const jurisdictionMap = [
+            {
+                sets: [
+                    jurisdictions.EU,
+                    jurisdictions.EEA,
+                    jurisdictions.UK
+                ],
+                code: 'GDPR'
+            },
+            {
+                sets: [
+                    jurisdictions.CH
+                ],
+                code: 'CH'
+            },
+            {
+                sets: [
+                    jurisdictions.BR
+                ],
+                code: 'BR'
+            },
+            {
+                sets: [
+                    jurisdictions.CA
+                ],
+                code: 'PIPEDA'
+            },
+            {
+                sets: [
+                    jurisdictions.AU
+                ],
+                code: 'AU'
+            },
+            {
+                sets: [
+                    jurisdictions.JP
+                ],
+                code: 'APPI'
+            },
+            {
+                sets: [
+                    jurisdictions.KR
+                ],
+                code: 'PIPA'
+            }
+        ];
+        for (const { sets, code } of jurisdictionMap)if (sets.some((set)=>set.has(countryCode))) {
             showConsentBanner = true;
-            jurisdictionCode = 'PIPA';
-            message = "South Korea's PIPA requires consent for data collection.";
+            jurisdictionCode = code;
+            break;
         }
     }
+    const message = JurisdictionMessages[jurisdictionCode];
     return {
         showConsentBanner,
         jurisdictionCode,
         message
     };
 }
-var package_namespaceObject = {
-    i8: "1.0.5"
-};
-const status_status = defineRoute({
-    path: '/status',
-    method: 'get',
-    handler: async (event)=>{
-        const response = {
-            status: 'ok',
-            version: package_namespaceObject.i8,
-            timestamp: new Date().toISOString(),
-            storage: {
-                type: event.context.adapter?.id ?? 'Unavailable',
-                available: !!event.context.adapter
-            }
-        };
-        return response;
-    }
-});
-const VerifyConsentRequestBody = __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
-    subjectId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().optional(),
-    externalSubjectId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().optional(),
-    domain: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
-    type: PolicyTypeSchema,
-    policyId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().optional(),
-    preferences: __WEBPACK_EXTERNAL_MODULE_zod__.z.array(__WEBPACK_EXTERNAL_MODULE_zod__.z.string()).optional()
-});
-const verifyConsent = defineRoute({
-    path: '/consent/verify',
-    method: 'post',
-    validations: {
-        body: VerifyConsentRequestBody
-    },
-    handler: async (event)=>{
-        const { body } = event.context.validated;
-        const { type, subjectId, externalSubjectId, domain, policyId, preferences } = body;
-        const { registry } = event.context;
-        const subject = await registry.findOrCreateSubject({
+const verifyConsent = os.consent.verify.handler(async ({ input, context })=>{
+    const typedContext = context;
+    const logger = typedContext.logger;
+    logger.info('Handling verify-consent request');
+    const { type, subjectId, externalSubjectId, domain, policyId, preferences } = input;
+    logger.debug('Request parameters', {
+        type,
+        subjectId,
+        externalSubjectId,
+        domain,
+        policyId,
+        preferences
+    });
+    try {
+        const subject = await typedContext.registry.findOrCreateSubject({
             subjectId,
             externalSubjectId,
-            ipAddress: event.context.ipAddress || 'unknown'
+            ipAddress: typedContext.ipAddress || 'unknown'
         });
-        if (!subject) return {
-            isValid: false,
-            reasons: [
-                'Subject not found'
-            ]
-        };
-        const domainRecord = await registry.findDomain(domain);
-        if (!domainRecord) return {
-            isValid: false,
-            reasons: [
-                'Domain not found'
-            ]
-        };
-        if ('cookie_banner' === type && preferences?.length === 0) return {
-            isValid: false,
-            reasons: [
-                'Preferences are required'
-            ]
-        };
-        const purposePromises = preferences?.map((purpose)=>registry.findConsentPurposeByCode(purpose));
+        if (!subject) throw new __WEBPACK_EXTERNAL_MODULE__orpc_server_0dae8408__.ORPCError('SUBJECT_NOT_FOUND', {
+            data: {
+                subjectId,
+                externalSubjectId
+            }
+        });
+        const domainRecord = await typedContext.registry.findDomain(domain);
+        if (!domainRecord) throw new __WEBPACK_EXTERNAL_MODULE__orpc_server_0dae8408__.ORPCError('DOMAIN_NOT_FOUND', {
+            data: {
+                domain
+            }
+        });
+        if ('cookie_banner' === type && (!preferences || 0 === preferences.length)) throw new __WEBPACK_EXTERNAL_MODULE__orpc_server_0dae8408__.ORPCError('COOKIE_BANNER_PREFERENCES_REQUIRED', {
+            data: {
+                type: 'cookie_banner'
+            }
+        });
+        const purposePromises = preferences?.map((purpose)=>typedContext.registry.findConsentPurposeByCode(purpose));
         const rawPurposes = await Promise.all(purposePromises ?? []);
         const purposeIds = rawPurposes.filter((purpose)=>null !== purpose).map((purpose)=>purpose.id);
-        if (purposeIds.length !== (preferences?.length ?? 0)) return {
-            isValid: false,
-            reasons: [
-                'Could not find all purposes'
-            ]
-        };
+        if (purposeIds.length !== (preferences?.length ?? 0)) throw new __WEBPACK_EXTERNAL_MODULE__orpc_server_0dae8408__.ORPCError('PURPOSES_NOT_FOUND', {
+            data: {
+                preferences: preferences ?? [],
+                foundPurposes: rawPurposes.filter((p)=>null !== p).map((p)=>p.code)
+            }
+        });
         if (policyId) {
-            const policy = await registry.findConsentPolicyById(policyId);
-            if (!policy || policy.type !== type) return {
-                isValid: false,
-                reasons: [
-                    'Policy not found'
-                ]
-            };
-            return await policyConsentGiven({
+            const policy = await typedContext.registry.findConsentPolicyById(policyId);
+            if (!policy || policy.type !== type) throw new __WEBPACK_EXTERNAL_MODULE__orpc_server_0dae8408__.ORPCError('POLICY_NOT_FOUND', {
+                data: {
+                    policyId,
+                    type
+                }
+            });
+            return await checkPolicyConsent({
                 policyId: policy.id,
                 subjectId: subject.id,
                 domainId: domainRecord.id,
                 purposeIds,
                 type,
-                event
+                context: typedContext
             });
         }
-        const latestPolicy = await registry.findOrCreatePolicy(type);
-        if (!latestPolicy) return {
-            isValid: false,
-            reasons: [
-                'Failed to find or create latest policy'
-            ]
-        };
-        return await policyConsentGiven({
+        const latestPolicy = await typedContext.registry.findOrCreatePolicy(type);
+        if (!latestPolicy) throw new __WEBPACK_EXTERNAL_MODULE__orpc_server_0dae8408__.ORPCError('POLICY_NOT_FOUND', {
+            data: {
+                policyId: 'latest',
+                type
+            }
+        });
+        return await checkPolicyConsent({
             policyId: latestPolicy.id,
             subjectId: subject.id,
             domainId: domainRecord.id,
             purposeIds,
             type,
-            event
+            context: typedContext
+        });
+    } catch (error) {
+        logger.error('Error in verify-consent handler', {
+            error: error instanceof Error ? error.message : String(error),
+            errorType: error instanceof Error ? error.constructor.name : typeof error
+        });
+        if (error instanceof __WEBPACK_EXTERNAL_MODULE__orpc_server_0dae8408__.ORPCError) throw error;
+        throw new __WEBPACK_EXTERNAL_MODULE__orpc_server_0dae8408__.ORPCError('INTERNAL_SERVER_ERROR', {
+            message: error instanceof Error ? error.message : String(error)
         });
     }
 });
-async function policyConsentGiven({ policyId, subjectId, domainId, purposeIds, type, event }) {
-    const { registry, adapter } = event.context;
+async function checkPolicyConsent({ policyId, subjectId, domainId, purposeIds, type, context }) {
+    const { registry, adapter } = context;
     const rawConsents = await adapter.findMany({
         model: 'consent',
         where: [
@@ -3388,13 +3201,12 @@ async function policyConsentGiven({ policyId, subjectId, domainId, purposeIds, t
             direction: 'desc'
         }
     });
-    const consents = rawConsents.map((consent)=>validateEntityOutput('consent', consent, {}));
-    const filteredConsents = consents.filter((consent)=>{
+    const filteredConsents = rawConsents.filter((consent)=>{
         if (!purposeIds) return true;
         return purposeIds.every((id)=>consent.purposeIds.some((purposeId)=>purposeId === id));
     });
     await registry.createAuditLog({
-        subjectId: subjectId,
+        subjectId,
         entityType: 'consent_policy',
         entityId: policyId,
         actionType: 'verify_consent',
@@ -3403,260 +3215,325 @@ async function policyConsentGiven({ policyId, subjectId, domainId, purposeIds, t
             policyId,
             purposeIds,
             success: 0 !== filteredConsents.length,
-            consentId: filteredConsents[0]?.id
+            ...filteredConsents.length > 0 ? {
+                consentId: filteredConsents[0]?.id
+            } : {}
+        }
+    });
+    if (0 === rawConsents.length) throw new __WEBPACK_EXTERNAL_MODULE__orpc_server_0dae8408__.ORPCError('NO_CONSENT_FOUND', {
+        data: {
+            policyId,
+            subjectId,
+            domainId
+        }
+    });
+    if (0 === filteredConsents.length) throw new __WEBPACK_EXTERNAL_MODULE__orpc_server_0dae8408__.ORPCError('NO_CONSENT_FOUND', {
+        data: {
+            policyId,
+            subjectId,
+            domainId
         }
     });
-    if (0 === consents.length) return {
-        isValid: false,
-        reasons: [
-            'No consent found for the given policy'
-        ]
-    };
     return {
         isValid: true,
         consent: filteredConsents[0]
     };
 }
-const routes = [
-    status_status,
-    show_consent_banner_showConsentBanner,
-    setConsent,
-    verifyConsent
-];
-const API_ROUTER_TRACER_NAME = '@doubletie/api-router';
-const api_router_telemetry_getTracer = (options)=>{
-    if (options?.telemetry?.tracer) return options.telemetry.tracer;
-    return __WEBPACK_EXTERNAL_MODULE__opentelemetry_api_87359e78__.trace.getTracer(API_ROUTER_TRACER_NAME);
+const consentHandlers = {
+    post: postConsent,
+    showBanner: show_banner_handler_showConsentBanner,
+    verify: verifyConsent
 };
-const createRequestSpan = (method, path, options)=>{
-    if (options?.telemetry?.disabled) return null;
-    const tracer = api_router_telemetry_getTracer(options);
-    const span = tracer.startSpan(`${method} ${path}`, {
-        attributes: {
-            'http.method': method,
-            'http.path': path,
-            ...options?.telemetry?.defaultAttributes || {}
+const statusHandler = os.meta.status.handler(({ context })=>{
+    const typedContext = context;
+    const headers = typedContext.headers;
+    const normalizeHeader = (value)=>{
+        if (!value) return null;
+        return Array.isArray(value) ? value[0] ?? null : value;
+    };
+    const countryCode = normalizeHeader(headers?.get('cf-ipcountry')) ?? normalizeHeader(headers?.get('x-vercel-ip-country')) ?? normalizeHeader(headers?.get('x-amz-cf-ipcountry')) ?? normalizeHeader(headers?.get('x-country-code'));
+    const regionCode = normalizeHeader(headers?.get('x-vercel-ip-country-region')) ?? normalizeHeader(headers?.get('x-region-code'));
+    return {
+        status: 'ok',
+        version: package_namespaceObject.i8,
+        timestamp: new Date(),
+        storage: {
+            type: typedContext.adapter?.id ?? 'MemoryAdapter',
+            available: !!typedContext.adapter
+        },
+        client: {
+            ip: typedContext.ipAddress ?? null,
+            userAgent: typedContext.userAgent ?? null,
+            region: {
+                countryCode,
+                regionCode
+            }
         }
-    });
-    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: __WEBPACK_EXTERNAL_MODULE__opentelemetry_api_87359e78__.SpanStatusCode.OK
-        });
-        return result;
-    } catch (error) {
-        handleSpanError(span, error);
-        throw error;
-    } finally{
-        span.end();
-    }
+    };
+});
+const metaHandlers = {
+    status: statusHandler
 };
-const handleSpanError = (span, error)=>{
-    span.setStatus({
-        code: __WEBPACK_EXTERNAL_MODULE__opentelemetry_api_87359e78__.SpanStatusCode.ERROR,
-        message: error instanceof Error ? error.message : String(error)
+const router = os.router({
+    consent: consentHandlers,
+    meta: metaHandlers
+});
+const c15tInstance = (options)=>{
+    const contextPromise = init(options);
+    const corsOptions = options.trustedOrigins ? {
+        origin: options.trustedOrigins.includes('*') ? '*' : 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
+    };
+    const rpcHandler = new __WEBPACK_EXTERNAL_MODULE__orpc_openapi_fetch_89b49e61__.OpenAPIHandler(router, {
+        plugins: [
+            new __WEBPACK_EXTERNAL_MODULE__orpc_server_plugins_e445fd4f__.CORSPlugin(corsOptions)
+        ]
     });
-    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 STRIP_REGEX = /^(https?:\/\/)|(wss?:\/\/)|(\/+$)|:\d+/g;
-function isOriginTrusted(origin, trustedDomains, logger) {
-    try {
-        if (0 === trustedDomains.length) throw new Error('No trusted domains');
-        logger?.debug(`Checking if origin ${origin} is trusted in ${trustedDomains}`);
-        if (trustedDomains.includes('*')) {
-            logger?.debug('Allowing all origins');
-            return true;
-        }
-        const url = new URL(origin);
-        const originHostname = url.hostname.toLowerCase();
-        logger?.debug(`Parsed origin hostname: ${originHostname}`);
-        return trustedDomains.some((domain)=>{
-            if (!domain || '' === domain.trim()) {
-                logger?.debug('Skipping empty domain');
-                return false;
+    const openAPIGenerator = new __WEBPACK_EXTERNAL_MODULE__orpc_openapi_a95cc8e7__.OpenAPIGenerator({
+        schemaConverters: [
+            new __WEBPACK_EXTERNAL_MODULE__orpc_zod_716a28d4__.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: '/'
             }
-            const strippedDomain = domain.replace(STRIP_REGEX, '').toLowerCase();
-            logger?.debug(`Checking against stripped domain: ${strippedDomain}`);
-            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;
+        ],
+        security: [
+            {
+                bearerAuth: []
             }
-            const isMatch = originHostname === strippedDomain;
-            logger?.debug(`Exact match result: ${isMatch} ${originHostname} === ${strippedDomain}`);
-            return isMatch;
-        });
-    } catch (error) {
-        logger?.error('Error validating origin:', error);
-        return false;
-    }
-}
-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;
+        ]
+    };
+    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 null;
-}
-function createApiHandler({ options, context }) {
-    const { logger } = context;
-    logger.info('Creating API Handler');
-    const app = (0, __WEBPACK_EXTERNAL_MODULE_h3__.createApp)({
-        onRequest (event) {
-            event.context.ipAddress = getIp(event.headers, options);
-            event.context.userAgent = event.node.req.headers['user-agent'] || null;
-            event.context.registry = context.registry;
-            event.context.adapter = context.adapter;
-            event.context.trustedOrigins = context.trustedOrigins;
-            event.context.logger = logger;
-            logger.debug(`Request received: ${event.method} ${event.path}`);
-        },
-        onError (error, event) {
-            if (event.context._onError && 'function' == typeof event.context._onError) return event.context._onError(error);
-            logger.error(`Unhandled API error in ${event.method} ${event.path}`, {
-                error: error instanceof Error ? error.message : String(error),
-                errorType: error instanceof Error ? error.constructor.name : typeof error
-            });
+        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 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;
         }
-    });
-    app.use(createH3ErrorHandler());
-    logger.debug('Added error handler middleware');
-    app.use((0, __WEBPACK_EXTERNAL_MODULE_h3__.eventHandler)((event)=>{
-        if ((0, __WEBPACK_EXTERNAL_MODULE_h3__.handleCors)(event, {
-            origin: (originStr)=>isOriginTrusted(originStr, event.context.trustedOrigins, logger),
-            methods: [
-                'GET',
-                'POST',
-                'PUT',
-                'DELETE',
-                'PATCH',
-                'OPTIONS'
-            ],
-            allowHeaders: [
-                'Content-Type',
-                'Authorization'
-            ],
-            credentials: true,
-            maxAge: '600'
-        })) return void logger.debug('CORS preflight response sent');
-    }));
-    const router = (0, __WEBPACK_EXTERNAL_MODULE_h3__.createRouter)();
-    app.use(router);
-    logger.debug('Router initialized and registered with app');
-    for (const route of routes){
-        logger.debug(`Registering route: ${route.method} ${route.path}`);
-        router[route.method](route.path, withH3ErrorHandling((0, __WEBPACK_EXTERNAL_MODULE_h3__.eventHandler)(async (event)=>{
-            logger.debug(`Handling request: ${route.method} ${route.path}`);
-            try {
-                logger.debug(`Executing handler for ${route.path}`);
-                const result = await withRequestSpan(event.method.toUpperCase(), route.path, ()=>route.handler(event), options);
-                logger.debug(`Handler completed for ${route.path}`);
-                if ('object' == typeof result && null !== result && 'pipe' in result && 'function' == typeof result.pipe) {
-                    logger.debug(`Sending stream response for ${route.path}`);
-                    return (0, __WEBPACK_EXTERNAL_MODULE_h3__.sendStream)(event, result);
+        const spec = await openAPIGenerator.generate(router, mergedOptions);
+        getOpenAPISpec.cached = spec;
+        return spec;
+    };
+    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://orpc.unnoq.com/icon.svg" />
+      </head>
+      <body>
+        <script
+          id="api-reference"
+          data-url="${encodeURI(openApiConfig.specPath)}">
+        </script>
+        <script src="https://cdn.jsdelivr.net/npm/@scalar/api-reference"></script>
+      </body>
+    </html>
+    `;
+    };
+    const handleOpenApiSpecRequest = async (url)=>{
+        if (openApiConfig.enabled && url.pathname === openApiConfig.specPath) {
+            const spec = await getOpenAPISpec();
+            return new Response(JSON.stringify(spec), {
+                status: 200,
+                headers: {
+                    'Content-Type': 'application/json'
                 }
-                event.node.res.setHeader('Content-Type', 'application/json');
-                return result;
-            } catch (error) {
-                logger.error(`Error in route handler for ${route.path}`, {
-                    error: error instanceof Error ? error.message : String(error),
-                    errorType: error instanceof Error ? error.constructor.name : typeof error
-                });
-                throw error;
-            }
-        })));
-    }
-    const handler = (0, __WEBPACK_EXTERNAL_MODULE_h3__.toWebHandler)(app);
-    logger.info('API handler created successfully');
-    return {
-        handler
+            });
+        }
+        return null;
     };
-}
-const c15tInstance = (options)=>{
-    const contextPromise = init(options);
-    let webHandler = null;
-    const getHandler = async (ctx)=>{
-        if (!webHandler) {
-            const { handler } = createApiHandler({
-                options: ctx.options,
-                context: {
-                    adapter: ctx.adapter,
-                    registry: ctx.registry,
-                    trustedOrigins: ctx.trustedOrigins,
-                    logger: ctx.logger
+    const handleDocsUiRequest = (url)=>{
+        if (openApiConfig.enabled && url.pathname === openApiConfig.docsPath) {
+            const html = getDocsUI();
+            return new Response(html, {
+                status: 200,
+                headers: {
+                    'Content-Type': 'text/html',
+                    'Content-Security-Policy': "default-src 'self'; script-src 'self' https://cdn.jsdelivr.net; style-src 'self' 'unsafe-inline' https://cdn.jsdelivr.net;"
                 }
             });
-            webHandler = handler;
         }
-        return webHandler;
+        return null;
+    };
+    const createDoubleTieErrorResponse = (error)=>{
+        const sanitizedMessage = error.message.replace(/[^\w\s.,;:!?()[\]{}'"+-]/g, '');
+        return new Response(JSON.stringify({
+            code: error.code,
+            message: sanitizedMessage,
+            data: error.meta,
+            status: error.statusCode,
+            defined: true
+        }), {
+            status: error.statusCode,
+            headers: {
+                'Content-Type': 'application/json'
+            }
+        });
+    };
+    const createUnknownErrorResponse = (error)=>{
+        const message = error instanceof Error ? error.message : String(error);
+        let status = 500;
+        if (error instanceof Error && 'status' in error) {
+            const statusValue = error.status;
+            if ('number' == typeof statusValue && statusValue >= 100 && statusValue < 600) status = statusValue;
+        }
+        return new Response(JSON.stringify({
+            code: error_codes_ERROR_CODES.INTERNAL_SERVER_ERROR,
+            message,
+            status,
+            defined: true,
+            data: {}
+        }), {
+            status,
+            headers: {
+                'Content-Type': 'application/json'
+            }
+        });
+    };
+    const handleApiRequest = async (request, ctx)=>{
+        const orpcContext = {
+            adapter: ctx.adapter,
+            registry: ctx.registry,
+            logger: ctx.logger,
+            generateId: ctx.generateId,
+            headers: request.headers,
+            userAgent: request.headers.get('user-agent') || void 0
+        };
+        processIp(request, orpcContext);
+        processCors(request, orpcContext);
+        processTelemetry(request, orpcContext);
+        const handlerContext = orpcContext;
+        const { matched, response } = await rpcHandler.handle(request, {
+            prefix: '/',
+            context: handlerContext
+        });
+        if (matched && response) return response;
+        return new Response('Not Found', {
+            status: 404
+        });
     };
     const handler = async (request)=>{
         try {
-            const contextResult = await contextPromise;
-            return contextResult.match(async (ctx)=>{
-                try {
-                    const handler = await getHandler(ctx);
-                    const response = await handler(request);
-                    return (0, __WEBPACK_EXTERNAL_MODULE_neverthrow__.okAsync)(response);
-                } catch (error) {
-                    return failAsync('Request handling failed', {
-                        code: error_codes_ERROR_CODES.REQUEST_HANDLER_ERROR,
-                        cause: error instanceof Error ? error : void 0
-                    });
-                }
-            }, (error)=>failAsync(`Context initialization failed: ${error.message}`, {
-                    code: error_codes_ERROR_CODES.INITIALIZATION_FAILED,
-                    cause: error
-                }));
+            const url = new URL(request.url);
+            const openApiResponse = await handleOpenApiSpecRequest(url);
+            if (openApiResponse) return openApiResponse;
+            const docsResponse = handleDocsUiRequest(url);
+            if (docsResponse) return docsResponse;
+            const ctxResult = await contextPromise;
+            if (!ctxResult.isOk()) throw ctxResult.error;
+            const ctx = ctxResult.value;
+            return await handleApiRequest(request, ctx);
         } catch (error) {
-            return failAsync(`Unexpected error: ${error instanceof Error ? error.message : String(error)}`, {
-                code: error_codes_ERROR_CODES.UNKNOWN_ERROR,
-                cause: error instanceof Error ? error : void 0
-            });
+            const logger = options.logger ? (0, __WEBPACK_EXTERNAL_MODULE__doubletie_logger_91c58a8f__.createLogger)(options.logger) : console;
+            logger.error('Request handling error:', error);
+            if (error instanceof error_class_DoubleTieError) return createDoubleTieErrorResponse(error);
+            return createUnknownErrorResponse(error);
         }
     };
+    const createNextHandlers = ()=>{
+        const nextHandler = async (request)=>await handler(request);
+        return {
+            GET: nextHandler,
+            POST: nextHandler,
+            PUT: nextHandler,
+            PATCH: nextHandler,
+            DELETE: nextHandler,
+            OPTIONS: nextHandler,
+            HEAD: nextHandler
+        };
+    };
     return {
-        handler,
-        getApi: async ()=>{
-            const contextResult = await contextPromise;
-            return contextResult.match(()=>(0, __WEBPACK_EXTERNAL_MODULE_neverthrow__.okAsync)(routes), (error)=>failAsync(`API retrieval failed: ${error.message}`, {
-                    code: error_codes_ERROR_CODES.API_RETRIEVAL_ERROR,
-                    cause: error
-                }));
-        },
         options,
-        $context: contextPromise
+        $context: contextPromise.then((result)=>{
+            if (!result.isOk()) throw result.error;
+            return result.value;
+        }),
+        router: router,
+        handler,
+        ...createNextHandlers(),
+        getOpenAPISpec,
+        getDocsUI
     };
 };
-export { pkgs_types_namespaceObject as Types, c15tInstance };
+export { c15tInstance };