@jshookmcp/jshook 0.2.0 → 0.2.2

package/dist/src/server/domains/debugger/handlers/watch-expressions.js

@@ -1,3 +1,4 @@
+import { argString } from '../../../domains/shared/parse-args.js';
 function getErrorMessage(error) {
     if (typeof error === 'object' && error !== null && 'message' in error) {
         const message = error.message;
@@ -14,8 +15,8 @@ export class WatchExpressionsHandlers {
     }
     async handleWatchAdd(args) {
         try {
-            const expression = args.expression;
-            const name = args.name;
+            const expression = argString(args, 'expression', '');
+            const name = argString(args, 'name');
             const watchManager = this.deps.debuggerManager.getWatchManager();
             const watchId = watchManager.addWatch(expression, name);
             return {
@@ -50,7 +51,7 @@ export class WatchExpressionsHandlers {
     }
     async handleWatchRemove(args) {
         try {
-            const watchId = args.watchId;
+            const watchId = argString(args, 'watchId', '');
             const watchManager = this.deps.debuggerManager.getWatchManager();
             const removed = watchManager.removeWatch(watchId);
             return {
@@ -115,7 +116,7 @@ export class WatchExpressionsHandlers {
     }
     async handleWatchEvaluateAll(args) {
         try {
-            const callFrameId = args.callFrameId;
+            const callFrameId = argString(args, 'callFrameId');
             const watchManager = this.deps.debuggerManager.getWatchManager();
             const results = await watchManager.evaluateAll(callFrameId);
             return {

package/dist/src/server/domains/debugger/handlers/xhr-breakpoint.js

@@ -1,5 +1,6 @@
+import { argString } from '../../../domains/shared/parse-args.js';
 function hasEnsureAdvancedFeatures(manager) {
-    return typeof manager.ensureAdvancedFeatures === 'function';
+    return (typeof manager.ensureAdvancedFeatures === 'function');
 }
 function getErrorMessage(error) {
     if (typeof error === 'object' && error !== null && 'message' in error) {
@@ -22,7 +23,7 @@ export class XHRBreakpointHandlers {
     }
     async handleXHRBreakpointSet(args) {
         try {
-            const urlPattern = args.urlPattern;
+            const urlPattern = argString(args, 'urlPattern', '');
             await this.ensureAdvancedFeaturesIfSupported();
             const xhrManager = this.deps.debuggerManager.getXHRManager();
             const breakpointId = await xhrManager.setXHRBreakpoint(urlPattern);
@@ -57,7 +58,7 @@ export class XHRBreakpointHandlers {
     }
     async handleXHRBreakpointRemove(args) {
         try {
-            const breakpointId = args.breakpointId;
+            const breakpointId = argString(args, 'breakpointId', '');
             await this.ensureAdvancedFeaturesIfSupported();
             const xhrManager = this.deps.debuggerManager.getXHRManager();
             const removed = await xhrManager.removeXHRBreakpoint(breakpointId);

package/dist/src/server/domains/debugger/manifest.d.ts

@@ -1,7 +1,67 @@
-import type { DomainManifest } from '../../domains/shared/registry.js';
+import type { MCPServerContext } from '../../domains/shared/registry.js';
 import { DebuggerToolHandlers } from '../../domains/debugger/index.js';
-declare const DOMAIN: "debugger";
-declare const DEP_KEY: "debuggerHandlers";
 type H = DebuggerToolHandlers;
-declare const manifest: DomainManifest<typeof DEP_KEY, H, typeof DOMAIN>;
+declare function ensure(ctx: MCPServerContext): H;
+declare const manifest: {
+    kind: "domain-manifest";
+    version: 1;
+    domain: "debugger";
+    depKey: "debuggerHandlers";
+    profiles: ("workflow" | "full")[];
+    ensure: typeof ensure;
+    prerequisites: {
+        debugger_enable: {
+            condition: string;
+            fix: string;
+        }[];
+        breakpoint_set: {
+            condition: string;
+            fix: string;
+        }[];
+    };
+    registrations: {
+        tool: {
+            inputSchema: {
+                [x: string]: unknown;
+                type: "object";
+                properties?: {
+                    [x: string]: object;
+                } | undefined;
+                required?: string[] | undefined;
+            };
+            name: string;
+            description?: string | undefined;
+            outputSchema?: {
+                [x: string]: unknown;
+                type: "object";
+                properties?: {
+                    [x: string]: object;
+                } | undefined;
+                required?: string[] | undefined;
+            } | undefined;
+            annotations?: {
+                title?: string | undefined;
+                readOnlyHint?: boolean | undefined;
+                destructiveHint?: boolean | undefined;
+                idempotentHint?: boolean | undefined;
+                openWorldHint?: boolean | undefined;
+            } | undefined;
+            execution?: {
+                taskSupport?: "optional" | "required" | "forbidden" | undefined;
+            } | undefined;
+            _meta?: {
+                [x: string]: unknown;
+            } | undefined;
+            icons?: {
+                src: string;
+                mimeType?: string | undefined;
+                sizes?: string[] | undefined;
+                theme?: "light" | "dark" | undefined;
+            }[] | undefined;
+            title?: string | undefined;
+        };
+        domain: "debugger";
+        bind: (deps: import("../../domains/shared/registry.js").ToolHandlerDeps) => (args: import("../../types.js").ToolArgs) => Promise<unknown>;
+    }[];
+};
 export default manifest;

package/dist/src/server/domains/debugger/manifest.js

@@ -25,43 +25,131 @@ const manifest = {
     depKey: DEP_KEY,
     profiles: ['workflow', 'full'],
     ensure,
+    prerequisites: {
+        debugger_enable: [{ condition: 'Browser must be launched', fix: 'Call browser_launch or browser_attach first' }],
+        breakpoint_set: [{ condition: 'Browser must be launched', fix: 'Call browser_launch and debugger_enable first' }],
+    },
     registrations: [
         { tool: t('debugger_enable'), domain: DOMAIN, bind: b((h, a) => h.handleDebuggerEnable(a)) },
         { tool: t('debugger_disable'), domain: DOMAIN, bind: b((h, a) => h.handleDebuggerDisable(a)) },
         { tool: t('debugger_pause'), domain: DOMAIN, bind: b((h, a) => h.handleDebuggerPause(a)) },
         { tool: t('debugger_resume'), domain: DOMAIN, bind: b((h, a) => h.handleDebuggerResume(a)) },
-        { tool: t('debugger_step_into'), domain: DOMAIN, bind: b((h, a) => h.handleDebuggerStepInto(a)) },
-        { tool: t('debugger_step_over'), domain: DOMAIN, bind: b((h, a) => h.handleDebuggerStepOver(a)) },
+        {
+            tool: t('debugger_step_into'),
+            domain: DOMAIN,
+            bind: b((h, a) => h.handleDebuggerStepInto(a)),
+        },
+        {
+            tool: t('debugger_step_over'),
+            domain: DOMAIN,
+            bind: b((h, a) => h.handleDebuggerStepOver(a)),
+        },
         { tool: t('debugger_step_out'), domain: DOMAIN, bind: b((h, a) => h.handleDebuggerStepOut(a)) },
         { tool: t('breakpoint_set'), domain: DOMAIN, bind: b((h, a) => h.handleBreakpointSet(a)) },
-        { tool: t('breakpoint_remove'), domain: DOMAIN, bind: b((h, a) => h.handleBreakpointRemove(a)) },
+        {
+            tool: t('breakpoint_remove'),
+            domain: DOMAIN,
+            bind: b((h, a) => h.handleBreakpointRemove(a)),
+        },
         { tool: t('breakpoint_list'), domain: DOMAIN, bind: b((h, a) => h.handleBreakpointList(a)) },
         { tool: t('get_call_stack'), domain: DOMAIN, bind: b((h, a) => h.handleGetCallStack(a)) },
-        { tool: t('debugger_evaluate'), domain: DOMAIN, bind: b((h, a) => h.handleDebuggerEvaluate(a)) },
-        { tool: t('debugger_evaluate_global'), domain: DOMAIN, bind: b((h, a) => h.handleDebuggerEvaluateGlobal(a)) },
-        { tool: t('debugger_wait_for_paused'), domain: DOMAIN, bind: b((h, a) => h.handleDebuggerWaitForPaused(a)) },
-        { tool: t('debugger_get_paused_state'), domain: DOMAIN, bind: b((h, a) => h.handleDebuggerGetPausedState(a)) },
-        { tool: t('breakpoint_set_on_exception'), domain: DOMAIN, bind: b((h, a) => h.handleBreakpointSetOnException(a)) },
-        { tool: t('get_object_properties'), domain: DOMAIN, bind: b((h, a) => h.handleGetObjectProperties(a)) },
-        { tool: t('get_scope_variables_enhanced'), domain: DOMAIN, bind: b((h, a) => h.handleGetScopeVariablesEnhanced(a)) },
+        {
+            tool: t('debugger_evaluate'),
+            domain: DOMAIN,
+            bind: b((h, a) => h.handleDebuggerEvaluate(a)),
+        },
+        {
+            tool: t('debugger_evaluate_global'),
+            domain: DOMAIN,
+            bind: b((h, a) => h.handleDebuggerEvaluateGlobal(a)),
+        },
+        {
+            tool: t('debugger_wait_for_paused'),
+            domain: DOMAIN,
+            bind: b((h, a) => h.handleDebuggerWaitForPaused(a)),
+        },
+        {
+            tool: t('debugger_get_paused_state'),
+            domain: DOMAIN,
+            bind: b((h, a) => h.handleDebuggerGetPausedState(a)),
+        },
+        {
+            tool: t('breakpoint_set_on_exception'),
+            domain: DOMAIN,
+            bind: b((h, a) => h.handleBreakpointSetOnException(a)),
+        },
+        {
+            tool: t('get_object_properties'),
+            domain: DOMAIN,
+            bind: b((h, a) => h.handleGetObjectProperties(a)),
+        },
+        {
+            tool: t('get_scope_variables_enhanced'),
+            domain: DOMAIN,
+            bind: b((h, a) => h.handleGetScopeVariablesEnhanced(a)),
+        },
         { tool: t('debugger_save_session'), domain: DOMAIN, bind: b((h, a) => h.handleSaveSession(a)) },
         { tool: t('debugger_load_session'), domain: DOMAIN, bind: b((h, a) => h.handleLoadSession(a)) },
-        { tool: t('debugger_export_session'), domain: DOMAIN, bind: b((h, a) => h.handleExportSession(a)) },
-        { tool: t('debugger_list_sessions'), domain: DOMAIN, bind: b((h, a) => h.handleListSessions(a)) },
+        {
+            tool: t('debugger_export_session'),
+            domain: DOMAIN,
+            bind: b((h, a) => h.handleExportSession(a)),
+        },
+        {
+            tool: t('debugger_list_sessions'),
+            domain: DOMAIN,
+            bind: b((h, a) => h.handleListSessions(a)),
+        },
         { tool: t('watch_add'), domain: DOMAIN, bind: b((h, a) => h.handleWatchAdd(a)) },
         { tool: t('watch_remove'), domain: DOMAIN, bind: b((h, a) => h.handleWatchRemove(a)) },
         { tool: t('watch_list'), domain: DOMAIN, bind: b((h, a) => h.handleWatchList(a)) },
-        { tool: t('watch_evaluate_all'), domain: DOMAIN, bind: b((h, a) => h.handleWatchEvaluateAll(a)) },
+        {
+            tool: t('watch_evaluate_all'),
+            domain: DOMAIN,
+            bind: b((h, a) => h.handleWatchEvaluateAll(a)),
+        },
         { tool: t('watch_clear_all'), domain: DOMAIN, bind: b((h, a) => h.handleWatchClearAll(a)) },
-        { tool: t('xhr_breakpoint_set'), domain: DOMAIN, bind: b((h, a) => h.handleXHRBreakpointSet(a)) },
-        { tool: t('xhr_breakpoint_remove'), domain: DOMAIN, bind: b((h, a) => h.handleXHRBreakpointRemove(a)) },
-        { tool: t('xhr_breakpoint_list'), domain: DOMAIN, bind: b((h, a) => h.handleXHRBreakpointList(a)) },
-        { tool: t('event_breakpoint_set'), domain: DOMAIN, bind: b((h, a) => h.handleEventBreakpointSet(a)) },
-        { tool: t('event_breakpoint_set_category'), domain: DOMAIN, bind: b((h, a) => h.handleEventBreakpointSetCategory(a)) },
-        { tool: t('event_breakpoint_remove'), domain: DOMAIN, bind: b((h, a) => h.handleEventBreakpointRemove(a)) },
-        { tool: t('event_breakpoint_list'), domain: DOMAIN, bind: b((h, a) => h.handleEventBreakpointList(a)) },
+        {
+            tool: t('xhr_breakpoint_set'),
+            domain: DOMAIN,
+            bind: b((h, a) => h.handleXHRBreakpointSet(a)),
+        },
+        {
+            tool: t('xhr_breakpoint_remove'),
+            domain: DOMAIN,
+            bind: b((h, a) => h.handleXHRBreakpointRemove(a)),
+        },
+        {
+            tool: t('xhr_breakpoint_list'),
+            domain: DOMAIN,
+            bind: b((h, a) => h.handleXHRBreakpointList(a)),
+        },
+        {
+            tool: t('event_breakpoint_set'),
+            domain: DOMAIN,
+            bind: b((h, a) => h.handleEventBreakpointSet(a)),
+        },
+        {
+            tool: t('event_breakpoint_set_category'),
+            domain: DOMAIN,
+            bind: b((h, a) => h.handleEventBreakpointSetCategory(a)),
+        },
+        {
+            tool: t('event_breakpoint_remove'),
+            domain: DOMAIN,
+            bind: b((h, a) => h.handleEventBreakpointRemove(a)),
+        },
+        {
+            tool: t('event_breakpoint_list'),
+            domain: DOMAIN,
+            bind: b((h, a) => h.handleEventBreakpointList(a)),
+        },
         { tool: t('blackbox_add'), domain: DOMAIN, bind: b((h, a) => h.handleBlackboxAdd(a)) },
-        { tool: t('blackbox_add_common'), domain: DOMAIN, bind: b((h, a) => h.handleBlackboxAddCommon(a)) },
+        {
+            tool: t('blackbox_add_common'),
+            domain: DOMAIN,
+            bind: b((h, a) => h.handleBlackboxAddCommon(a)),
+        },
         { tool: t('blackbox_list'), domain: DOMAIN, bind: b((h, a) => h.handleBlackboxList(a)) },
     ],
 };

package/dist/src/server/domains/encoding/definitions.js

@@ -25,6 +25,12 @@ export const encodingTools = [
             },
             required: ['source'],
         },
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
     },
     {
         name: 'binary_decode',
@@ -50,6 +56,12 @@ export const encodingTools = [
             },
             required: ['data', 'encoding'],
         },
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: false,
+        },
     },
     {
         name: 'binary_encode',
@@ -74,6 +86,12 @@ export const encodingTools = [
             },
             required: ['data', 'inputFormat', 'outputEncoding'],
         },
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: false,
+        },
     },
     {
         name: 'binary_entropy_analysis',
@@ -102,6 +120,12 @@ export const encodingTools = [
             },
             required: ['source'],
         },
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
     },
     {
         name: 'protobuf_decode_raw',
@@ -121,5 +145,11 @@ export const encodingTools = [
             },
             required: ['data'],
         },
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
     },
 ];

package/dist/src/server/domains/encoding/encoding-msgpack.d.ts

@@ -0,0 +1,7 @@
+import type { MsgPackDecodeResult } from '../../domains/encoding/handlers.impl.core.runtime.shared.js';
+export declare function decodeMsgPack(buffer: Buffer): unknown;
+export declare function decodeMsgPackValue(buffer: Buffer, startOffset: number, depth: number): MsgPackDecodeResult;
+export declare function decodeMsgPackArray(buffer: Buffer, startOffset: number, length: number, depth: number): MsgPackDecodeResult;
+export declare function decodeMsgPackMap(buffer: Buffer, startOffset: number, length: number, depth: number): MsgPackDecodeResult;
+export declare function msgPackMapKey(value: unknown): string;
+export declare function ensureRange(buffer: Buffer, offset: number, length: number): void;

package/dist/src/server/domains/encoding/encoding-msgpack.js

@@ -0,0 +1,266 @@
+import { bigIntToSafeValue } from '../../domains/encoding/encoding-protobuf.js';
+export function decodeMsgPack(buffer) {
+    const decoded = decodeMsgPackValue(buffer, 0, 0);
+    if (decoded.offset !== buffer.length) {
+        throw new Error(`MessagePack decode ended early: consumed ${decoded.offset} of ${buffer.length} bytes`);
+    }
+    return decoded.value;
+}
+export function decodeMsgPackValue(buffer, startOffset, depth) {
+    if (depth > 64) {
+        throw new Error('MessagePack decode depth exceeds safety limit');
+    }
+    const prefix = buffer[startOffset];
+    if (prefix === undefined) {
+        throw new Error(`Unexpected EOF at offset ${startOffset}`);
+    }
+    let offset = startOffset + 1;
+    if (prefix <= 0x7f) {
+        return { value: prefix, offset };
+    }
+    if (prefix >= 0xe0) {
+        return { value: prefix - 0x100, offset };
+    }
+    if (prefix >= 0xa0 && prefix <= 0xbf) {
+        const length = prefix & 0x1f;
+        ensureRange(buffer, offset, length);
+        const value = buffer.subarray(offset, offset + length).toString('utf8');
+        return { value, offset: offset + length };
+    }
+    if (prefix >= 0x90 && prefix <= 0x9f) {
+        const length = prefix & 0x0f;
+        return decodeMsgPackArray(buffer, offset, length, depth + 1);
+    }
+    if (prefix >= 0x80 && prefix <= 0x8f) {
+        const length = prefix & 0x0f;
+        return decodeMsgPackMap(buffer, offset, length, depth + 1);
+    }
+    if (prefix === 0xc0)
+        return { value: null, offset };
+    if (prefix === 0xc2)
+        return { value: false, offset };
+    if (prefix === 0xc3)
+        return { value: true, offset };
+    if (prefix === 0xcc) {
+        ensureRange(buffer, offset, 1);
+        const value = buffer.readUInt8(offset);
+        return { value, offset: offset + 1 };
+    }
+    if (prefix === 0xcd) {
+        ensureRange(buffer, offset, 2);
+        const value = buffer.readUInt16BE(offset);
+        return { value, offset: offset + 2 };
+    }
+    if (prefix === 0xce) {
+        ensureRange(buffer, offset, 4);
+        const value = buffer.readUInt32BE(offset);
+        return { value, offset: offset + 4 };
+    }
+    if (prefix === 0xcf) {
+        ensureRange(buffer, offset, 8);
+        const value = buffer.readBigUInt64BE(offset);
+        return { value: bigIntToSafeValue(value), offset: offset + 8 };
+    }
+    if (prefix === 0xd0) {
+        ensureRange(buffer, offset, 1);
+        const value = buffer.readInt8(offset);
+        return { value, offset: offset + 1 };
+    }
+    if (prefix === 0xd1) {
+        ensureRange(buffer, offset, 2);
+        const value = buffer.readInt16BE(offset);
+        return { value, offset: offset + 2 };
+    }
+    if (prefix === 0xd2) {
+        ensureRange(buffer, offset, 4);
+        const value = buffer.readInt32BE(offset);
+        return { value, offset: offset + 4 };
+    }
+    if (prefix === 0xd3) {
+        ensureRange(buffer, offset, 8);
+        const value = buffer.readBigInt64BE(offset);
+        return { value: bigIntToSafeValue(value), offset: offset + 8 };
+    }
+    if (prefix === 0xca) {
+        ensureRange(buffer, offset, 4);
+        const value = buffer.readFloatBE(offset);
+        return { value, offset: offset + 4 };
+    }
+    if (prefix === 0xcb) {
+        ensureRange(buffer, offset, 8);
+        const value = buffer.readDoubleBE(offset);
+        return { value, offset: offset + 8 };
+    }
+    if (prefix === 0xd9) {
+        ensureRange(buffer, offset, 1);
+        const length = buffer.readUInt8(offset);
+        offset += 1;
+        ensureRange(buffer, offset, length);
+        const value = buffer.subarray(offset, offset + length).toString('utf8');
+        return { value, offset: offset + length };
+    }
+    if (prefix === 0xda) {
+        ensureRange(buffer, offset, 2);
+        const length = buffer.readUInt16BE(offset);
+        offset += 2;
+        ensureRange(buffer, offset, length);
+        const value = buffer.subarray(offset, offset + length).toString('utf8');
+        return { value, offset: offset + length };
+    }
+    if (prefix === 0xdb) {
+        ensureRange(buffer, offset, 4);
+        const length = buffer.readUInt32BE(offset);
+        offset += 4;
+        ensureRange(buffer, offset, length);
+        const value = buffer.subarray(offset, offset + length).toString('utf8');
+        return { value, offset: offset + length };
+    }
+    if (prefix === 0xc4) {
+        ensureRange(buffer, offset, 1);
+        const length = buffer.readUInt8(offset);
+        offset += 1;
+        ensureRange(buffer, offset, length);
+        const payload = buffer.subarray(offset, offset + length);
+        return {
+            value: { type: 'bytes', base64: payload.toString('base64'), hex: payload.toString('hex') },
+            offset: offset + length,
+        };
+    }
+    if (prefix === 0xc5) {
+        ensureRange(buffer, offset, 2);
+        const length = buffer.readUInt16BE(offset);
+        offset += 2;
+        ensureRange(buffer, offset, length);
+        const payload = buffer.subarray(offset, offset + length);
+        return {
+            value: { type: 'bytes', base64: payload.toString('base64'), hex: payload.toString('hex') },
+            offset: offset + length,
+        };
+    }
+    if (prefix === 0xc6) {
+        ensureRange(buffer, offset, 4);
+        const length = buffer.readUInt32BE(offset);
+        offset += 4;
+        ensureRange(buffer, offset, length);
+        const payload = buffer.subarray(offset, offset + length);
+        return {
+            value: { type: 'bytes', base64: payload.toString('base64'), hex: payload.toString('hex') },
+            offset: offset + length,
+        };
+    }
+    if (prefix === 0xdc) {
+        ensureRange(buffer, offset, 2);
+        const length = buffer.readUInt16BE(offset);
+        offset += 2;
+        return decodeMsgPackArray(buffer, offset, length, depth + 1);
+    }
+    if (prefix === 0xdd) {
+        ensureRange(buffer, offset, 4);
+        const length = buffer.readUInt32BE(offset);
+        offset += 4;
+        return decodeMsgPackArray(buffer, offset, length, depth + 1);
+    }
+    if (prefix === 0xde) {
+        ensureRange(buffer, offset, 2);
+        const length = buffer.readUInt16BE(offset);
+        offset += 2;
+        return decodeMsgPackMap(buffer, offset, length, depth + 1);
+    }
+    if (prefix === 0xdf) {
+        ensureRange(buffer, offset, 4);
+        const length = buffer.readUInt32BE(offset);
+        offset += 4;
+        return decodeMsgPackMap(buffer, offset, length, depth + 1);
+    }
+    if (prefix >= 0xd4 && prefix <= 0xd8) {
+        const sizeByPrefix = {
+            0xd4: 1,
+            0xd5: 2,
+            0xd6: 4,
+            0xd7: 8,
+            0xd8: 16,
+        };
+        const size = sizeByPrefix[prefix];
+        ensureRange(buffer, offset, 1 + size);
+        const extType = buffer.readInt8(offset);
+        const payload = buffer.subarray(offset + 1, offset + 1 + size);
+        return {
+            value: {
+                type: 'ext',
+                extType,
+                base64: payload.toString('base64'),
+                hex: payload.toString('hex'),
+            },
+            offset: offset + 1 + size,
+        };
+    }
+    if (prefix === 0xc7 || prefix === 0xc8 || prefix === 0xc9) {
+        const lengthBytes = prefix === 0xc7 ? 1 : prefix === 0xc8 ? 2 : 4;
+        ensureRange(buffer, offset, lengthBytes);
+        const length = lengthBytes === 1
+            ? buffer.readUInt8(offset)
+            : lengthBytes === 2
+                ? buffer.readUInt16BE(offset)
+                : buffer.readUInt32BE(offset);
+        offset += lengthBytes;
+        ensureRange(buffer, offset, 1 + length);
+        const extType = buffer.readInt8(offset);
+        const payload = buffer.subarray(offset + 1, offset + 1 + length);
+        return {
+            value: {
+                type: 'ext',
+                extType,
+                base64: payload.toString('base64'),
+                hex: payload.toString('hex'),
+            },
+            offset: offset + 1 + length,
+        };
+    }
+    throw new Error(`Unsupported MessagePack prefix 0x${prefix.toString(16)} at offset ${startOffset}`);
+}
+export function decodeMsgPackArray(buffer, startOffset, length, depth) {
+    let offset = startOffset;
+    const values = [];
+    for (let index = 0; index < length; index += 1) {
+        const decoded = decodeMsgPackValue(buffer, offset, depth);
+        values.push(decoded.value);
+        offset = decoded.offset;
+    }
+    return { value: values, offset };
+}
+export function decodeMsgPackMap(buffer, startOffset, length, depth) {
+    let offset = startOffset;
+    const mapValue = {};
+    for (let index = 0; index < length; index += 1) {
+        const keyDecoded = decodeMsgPackValue(buffer, offset, depth);
+        offset = keyDecoded.offset;
+        const valueDecoded = decodeMsgPackValue(buffer, offset, depth);
+        offset = valueDecoded.offset;
+        const key = msgPackMapKey(keyDecoded.value);
+        mapValue[key] = valueDecoded.value;
+    }
+    return { value: mapValue, offset };
+}
+export function msgPackMapKey(value) {
+    if (typeof value === 'string')
+        return value;
+    if (typeof value === 'number')
+        return String(value);
+    if (typeof value === 'boolean')
+        return String(value);
+    if (typeof value === 'bigint')
+        return value.toString();
+    if (value === null)
+        return 'null';
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+export function ensureRange(buffer, offset, length) {
+    if (offset < 0 || length < 0 || offset + length > buffer.length) {
+        throw new Error(`Unexpected EOF while reading ${length} bytes at offset ${offset}`);
+    }
+}

package/dist/src/server/domains/encoding/encoding-protobuf.d.ts

@@ -0,0 +1,10 @@
+import type { ProtobufParseResult } from '../../domains/encoding/handlers.impl.core.runtime.shared.js';
+export declare function parseProtobufMessage(buffer: Buffer, depth: number, maxDepth: number): ProtobufParseResult;
+export declare function decodeLengthDelimited(payload: Buffer, depth: number, maxDepth: number): unknown;
+export declare function tryParseVarint(buffer: Buffer, startOffset: number): {
+    value?: bigint;
+    offset?: number;
+    error?: string;
+};
+export declare function protobufWireTypeName(wireType: number): string;
+export declare function bigIntToSafeValue(value: bigint): number | string;