@qvac/sdk 0.14.1 → 0.15.0

package/dist/server/utils/tools/parsers/hermes.js

@@ -1,4 +1,4 @@
-import { generateStableToolCallId, isValidToolCall, validateToolArguments, } from "../shared.js";
+import { generateStableToolCallId, isValidToolCall, validateToolArguments } from '../shared.js';
 // Qwen3.5/3.6 can fuse its two tool templates into one frame, embedding the
 // XML `<function=NAME>` token as a bare string key inside the JSON envelope:
 //   {"function=NAME","arguments":{...}}  (invalid JSON, not parseable as-is)
@@ -25,13 +25,13 @@ function parseHermesJson(candidate) {
 export function parseHermesFormat(text, tools) {
     const toolCalls = [];
     const errors = [];
-    if (!text.includes("<tool_call>")) {
+    if (!text.includes('<tool_call>')) {
         return { matched: false, toolCalls, errors };
     }
     // Incomplete frame: open marker without close (cutoff/abort). Recover
     // the inner buffer here — fallthrough to JSON parsers can't strip the
     // `<tool_call>` prefix on its own.
-    if (!text.includes("</tool_call>")) {
+    if (!text.includes('</tool_call>')) {
         return recoverIncompleteHermesFrame(text, tools);
     }
     const toolCallRegex = /<tool_call>\s*({[\s\S]*?})\s*<\/tool_call>/g;
@@ -47,17 +47,17 @@ export function parseHermesFormat(text, tools) {
         }
         catch (error) {
             errors.push({
-                code: "PARSE_ERROR",
+                code: 'PARSE_ERROR',
                 message: `Failed to parse Hermes tool call: ${error instanceof Error ? error.message : String(error)}`,
-                raw: trimmedJson,
+                raw: trimmedJson
             });
             continue;
         }
         if (!isValidToolCall(callItem)) {
             errors.push({
-                code: "PARSE_ERROR",
-                message: "Hermes tool call is missing name/arguments",
-                raw: trimmedJson,
+                code: 'PARSE_ERROR',
+                message: 'Hermes tool call is missing name/arguments',
+                raw: trimmedJson
             });
             continue;
         }
@@ -66,7 +66,7 @@ export function parseHermesFormat(text, tools) {
         if (!validation.isValid && validation.error) {
             errors.push({
                 ...validation.error,
-                raw: trimmedJson,
+                raw: trimmedJson
             });
             continue;
         }
@@ -74,7 +74,7 @@ export function parseHermesFormat(text, tools) {
             id: call.id || generateStableToolCallId(call.name, call.arguments),
             name: call.name,
             arguments: call.arguments,
-            raw: trimmedJson,
+            raw: trimmedJson
         });
     }
     return { matched: true, toolCalls, errors };
@@ -82,8 +82,8 @@ export function parseHermesFormat(text, tools) {
 // Strips a possible truncated close-tag tail (`</tool`, `</tool_c`)
 // before parsing. Bounded to buffers that actually contain the open marker.
 function recoverIncompleteHermesFrame(text, tools) {
-    const openIdx = text.indexOf("<tool_call>");
-    const inner = text.slice(openIdx + "<tool_call>".length).trim();
+    const openIdx = text.indexOf('<tool_call>');
+    const inner = text.slice(openIdx + '<tool_call>'.length).trim();
     const partialCloseIdx = inner.search(/<\/tool/);
     const candidate = partialCloseIdx === -1 ? inner : inner.slice(0, partialCloseIdx).trim();
     if (candidate.length === 0) {
@@ -104,7 +104,7 @@ function recoverIncompleteHermesFrame(text, tools) {
         return {
             matched: true,
             toolCalls: [],
-            errors: [{ ...validation.error, raw: candidate }],
+            errors: [{ ...validation.error, raw: candidate }]
         };
     }
     return {
@@ -114,9 +114,9 @@ function recoverIncompleteHermesFrame(text, tools) {
                 id: parsed.id || generateStableToolCallId(parsed.name, parsed.arguments),
                 name: parsed.name,
                 arguments: parsed.arguments,
-                raw: candidate,
-            },
+                raw: candidate
+            }
         ],
-        errors: [],
+        errors: []
     };
 }

package/dist/server/utils/tools/parsers/json.d.ts

@@ -1,5 +1,5 @@
-import type { Tool } from "../../../../schemas/index";
-import { type ParserResult } from "../shared";
+import type { Tool } from '../../../../schemas/index';
+import { type ParserResult } from '../shared';
 export declare function parseGemmaFormat(text: string, tools: Tool[]): ParserResult;
 export declare function parseLlamacppFormat(text: string, tools: Tool[]): ParserResult;
 export declare function parseGenericFormat(text: string, tools: Tool[]): ParserResult;

package/dist/server/utils/tools/parsers/json.js

@@ -1,4 +1,4 @@
-import { generateStableToolCallId, isValidToolCall, validateToolArguments, } from "../shared.js";
+import { generateStableToolCallId, isValidToolCall, validateToolArguments } from '../shared.js';
 export function parseGemmaFormat(text, tools) {
     const toolCalls = [];
     const errors = [];
@@ -10,17 +10,17 @@ export function parseGemmaFormat(text, tools) {
         return { matched: false, toolCalls, errors };
     }
     if (!parsed ||
-        typeof parsed !== "object" ||
-        !("tool_calls" in parsed) ||
+        typeof parsed !== 'object' ||
+        !('tool_calls' in parsed) ||
         !Array.isArray(parsed.tool_calls)) {
         return { matched: false, toolCalls, errors };
     }
     for (const callItem of parsed.tool_calls) {
         if (!isValidToolCall(callItem)) {
             errors.push({
-                code: "PARSE_ERROR",
-                message: "Gemma tool_calls entry is missing name/arguments",
-                raw: JSON.stringify(callItem),
+                code: 'PARSE_ERROR',
+                message: 'Gemma tool_calls entry is missing name/arguments',
+                raw: JSON.stringify(callItem)
             });
             continue;
         }
@@ -29,7 +29,7 @@ export function parseGemmaFormat(text, tools) {
         if (!validation.isValid && validation.error) {
             errors.push({
                 ...validation.error,
-                raw: JSON.stringify(call),
+                raw: JSON.stringify(call)
             });
             continue;
         }
@@ -37,7 +37,7 @@ export function parseGemmaFormat(text, tools) {
             id: call.id || generateStableToolCallId(call.name, call.arguments),
             name: call.name,
             arguments: call.arguments,
-            raw: JSON.stringify(call),
+            raw: JSON.stringify(call)
         });
     }
     return { matched: true, toolCalls, errors };
@@ -60,7 +60,7 @@ export function parseLlamacppFormat(text, tools) {
     if (!validation.isValid && validation.error) {
         errors.push({
             ...validation.error,
-            raw: text,
+            raw: text
         });
     }
     else {
@@ -68,7 +68,7 @@ export function parseLlamacppFormat(text, tools) {
             id: parsed.id || generateStableToolCallId(parsed.name, parsed.arguments),
             name: parsed.name,
             arguments: parsed.arguments,
-            raw: text,
+            raw: text
         });
     }
     return { matched: true, toolCalls, errors };
@@ -91,7 +91,7 @@ export function parseGenericFormat(text, tools) {
                 if (!validation.isValid && validation.error) {
                     errors.push({
                         ...validation.error,
-                        raw: match[0],
+                        raw: match[0]
                     });
                     continue;
                 }
@@ -99,15 +99,15 @@ export function parseGenericFormat(text, tools) {
                     id: obj.id || generateStableToolCallId(obj.name, obj.arguments),
                     name: obj.name,
                     arguments: obj.arguments,
-                    raw: match[0],
+                    raw: match[0]
                 });
             }
         }
         catch (error) {
             errors.push({
-                code: "PARSE_ERROR",
+                code: 'PARSE_ERROR',
                 message: `Failed to parse generic tool call: ${error instanceof Error ? error.message : String(error)}`,
-                raw: match[0],
+                raw: match[0]
             });
         }
     }

package/dist/server/utils/tools/parsers/pythonic.d.ts

@@ -1,4 +1,4 @@
-import type { Tool } from "../../../../schemas/index";
-import { type ParserResult } from "../shared";
+import type { Tool } from '../../../../schemas/index';
+import { type ParserResult } from '../shared';
 export declare function parsePythonicFormat(text: string, tools: Tool[]): ParserResult;
 //# sourceMappingURL=pythonic.d.ts.map

package/dist/server/utils/tools/parsers/pythonic.js

@@ -1,12 +1,12 @@
-import { generateStableToolCallId, validateToolArguments, } from "../shared.js";
+import { generateStableToolCallId, validateToolArguments } from '../shared.js';
 // Pythonic `[name(k=v), ...]` arrays. LFM 2.x is auto-routed; Llama-style
 // tokens are kept for callers that opt in via `completion({ toolDialect:
 // "pythonic" })` for a model known to emit Pythonic. Pure string parsing —
 // no eval/vm/Function (untrusted model output).
-const PYTHONIC_LFM_OPEN = "<|tool_call_start|>";
-const PYTHONIC_LFM_CLOSE = "<|tool_call_end|>";
-const PYTHONIC_LLAMA_OPEN = "<|start_header_id|>tool_call<|end_header_id|>";
-const PYTHONIC_LLAMA_CLOSE = "<|eot_id|>";
+const PYTHONIC_LFM_OPEN = '<|tool_call_start|>';
+const PYTHONIC_LFM_CLOSE = '<|tool_call_end|>';
+const PYTHONIC_LLAMA_OPEN = '<|start_header_id|>tool_call<|end_header_id|>';
+const PYTHONIC_LLAMA_CLOSE = '<|eot_id|>';
 function locatePythonicCallList(text) {
     const lfmStart = text.indexOf(PYTHONIC_LFM_OPEN);
     if (lfmStart !== -1) {
@@ -27,10 +27,10 @@ function locatePythonicCallList(text) {
     return null;
 }
 function pyPeek(s, offset = 0) {
-    return s.text[s.pos + offset] ?? "";
+    return s.text[s.pos + offset] ?? '';
 }
 function pyConsume(s) {
-    const c = s.text[s.pos] ?? "";
+    const c = s.text[s.pos] ?? '';
     s.pos++;
     return c;
 }
@@ -40,23 +40,23 @@ function pySkipWs(s) {
 }
 function pyParseString(s) {
     const quote = pyConsume(s);
-    let out = "";
+    let out = '';
     while (s.pos < s.text.length && pyPeek(s) !== quote) {
-        if (pyPeek(s) === "\\") {
+        if (pyPeek(s) === '\\') {
             s.pos++;
             const esc = pyConsume(s);
             switch (esc) {
-                case "n":
-                    out += "\n";
+                case 'n':
+                    out += '\n';
                     break;
-                case "t":
-                    out += "\t";
+                case 't':
+                    out += '\t';
                     break;
-                case "r":
-                    out += "\r";
+                case 'r':
+                    out += '\r';
                     break;
-                case "\\":
-                    out += "\\";
+                case '\\':
+                    out += '\\';
                     break;
                 case "'":
                     out += "'";
@@ -64,8 +64,8 @@ function pyParseString(s) {
                 case '"':
                     out += '"';
                     break;
-                case "0":
-                    out += "\0";
+                case '0':
+                    out += '\0';
                     break;
                 default:
                     out += esc;
@@ -77,25 +77,25 @@ function pyParseString(s) {
         }
     }
     if (s.pos >= s.text.length) {
-        throw new Error("Unterminated string literal");
+        throw new Error('Unterminated string literal');
     }
     pyConsume(s);
     return out;
 }
 function pyParseNumber(s) {
     const start = s.pos;
-    if (pyPeek(s) === "-" || pyPeek(s) === "+")
+    if (pyPeek(s) === '-' || pyPeek(s) === '+')
         s.pos++;
     while (/\d/.test(pyPeek(s)))
         s.pos++;
-    if (pyPeek(s) === ".") {
+    if (pyPeek(s) === '.') {
         s.pos++;
         while (/\d/.test(pyPeek(s)))
             s.pos++;
     }
-    if (pyPeek(s) === "e" || pyPeek(s) === "E") {
+    if (pyPeek(s) === 'e' || pyPeek(s) === 'E') {
         s.pos++;
-        if (pyPeek(s) === "-" || pyPeek(s) === "+")
+        if (pyPeek(s) === '-' || pyPeek(s) === '+')
             s.pos++;
         while (/\d/.test(pyPeek(s)))
             s.pos++;
@@ -125,19 +125,19 @@ function pyParseValue(s) {
     const c = pyPeek(s);
     if (c === '"' || c === "'")
         return pyParseString(s);
-    if (c === "[")
+    if (c === '[')
         return pyParseList(s);
-    if (c === "{")
+    if (c === '{')
         return pyParseDict(s);
-    if (c === "-" || c === "+" || /\d/.test(c))
+    if (c === '-' || c === '+' || /\d/.test(c))
         return pyParseNumber(s);
     if (/[A-Za-z_]/.test(c)) {
         const id = pyParseIdentifier(s);
-        if (id === "True")
+        if (id === 'True')
             return true;
-        if (id === "False")
+        if (id === 'False')
             return false;
-        if (id === "None")
+        if (id === 'None')
             return null;
         return id;
     }
@@ -156,7 +156,7 @@ function pyParseDelimited(s, close, context, parseItem) {
         parseItem();
         pySkipWs(s);
         const sep = pyPeek(s);
-        if (sep === ",") {
+        if (sep === ',') {
             pyConsume(s);
             pySkipWs(s);
             if (pyPeek(s) === close) {
@@ -176,7 +176,7 @@ function pyParseDelimited(s, close, context, parseItem) {
 function pyParseList(s) {
     pyConsume(s);
     const items = [];
-    pyParseDelimited(s, "]", "list", () => {
+    pyParseDelimited(s, ']', 'list', () => {
         items.push(pyParseValue(s));
     });
     return items;
@@ -184,7 +184,7 @@ function pyParseList(s) {
 function pyParseDict(s) {
     pyConsume(s);
     const obj = {};
-    pyParseDelimited(s, "}", "dict", () => {
+    pyParseDelimited(s, '}', 'dict', () => {
         const c = pyPeek(s);
         let key;
         if (c === '"' || c === "'")
@@ -194,7 +194,7 @@ function pyParseDict(s) {
         else
             throw new Error(`Expected dict key, got ${JSON.stringify(c)}`);
         pySkipWs(s);
-        if (pyConsume(s) !== ":") {
+        if (pyConsume(s) !== ':') {
             throw new Error(`Expected : after dict key "${key}"`);
         }
         obj[key] = pyParseValue(s);
@@ -203,10 +203,10 @@ function pyParseDict(s) {
 }
 function pyParseArgList(s) {
     const args = {};
-    pyParseDelimited(s, ")", "args", () => {
+    pyParseDelimited(s, ')', 'args', () => {
         const key = pyParseIdentifier(s);
         pySkipWs(s);
-        if (pyConsume(s) !== "=") {
+        if (pyConsume(s) !== '=') {
             throw new Error(`Expected = after arg name "${key}"`);
         }
         args[key] = pyParseValue(s);
@@ -216,14 +216,14 @@ function pyParseArgList(s) {
 function pyParseCallList(text) {
     const s = { text, pos: 0 };
     pySkipWs(s);
-    if (pyConsume(s) !== "[") {
-        throw new Error("Expected [ at start of call list");
+    if (pyConsume(s) !== '[') {
+        throw new Error('Expected [ at start of call list');
     }
     const calls = [];
-    pyParseDelimited(s, "]", "call list", () => {
+    pyParseDelimited(s, ']', 'call list', () => {
         const name = pyParseIdentifier(s);
         pySkipWs(s);
-        if (pyConsume(s) !== "(") {
+        if (pyConsume(s) !== '(') {
             throw new Error(`Expected ( after call name "${name}"`);
         }
         calls.push({ name, arguments: pyParseArgList(s) });
@@ -243,9 +243,9 @@ export function parsePythonicFormat(text, tools) {
     }
     catch (error) {
         errors.push({
-            code: "PARSE_ERROR",
+            code: 'PARSE_ERROR',
             message: `Failed to parse Pythonic tool call list: ${error instanceof Error ? error.message : String(error)}`,
-            raw: slice,
+            raw: slice
         });
         return { matched: true, toolCalls, errors };
     }
@@ -260,7 +260,7 @@ export function parsePythonicFormat(text, tools) {
             id: generateStableToolCallId(call.name, call.arguments),
             name: call.name,
             arguments: call.arguments,
-            raw,
+            raw
         });
     }
     return { matched: true, toolCalls, errors };

package/dist/server/utils/tools/parsers/qwen35.d.ts

@@ -1,4 +1,4 @@
-import type { Tool } from "../../../../schemas/index";
-import { type ParserResult } from "../shared";
+import type { Tool } from '../../../../schemas/index';
+import { type ParserResult } from '../shared';
 export declare function parseQwen35Format(text: string, tools: Tool[]): ParserResult;
 //# sourceMappingURL=qwen35.d.ts.map

package/dist/server/utils/tools/parsers/qwen35.js

@@ -1,4 +1,4 @@
-import { generateStableToolCallId, validateToolArguments, } from "../shared.js";
+import { generateStableToolCallId, validateToolArguments } from '../shared.js';
 // Coerce raw parameter text to the type declared in the tool's JSON schema.
 // String values are raw (not JSON-quoted); arrays/objects are valid JSON.
 function coerceParamValue(raw, schema) {
@@ -6,7 +6,7 @@ function coerceParamValue(raw, schema) {
     if (!schema?.type)
         return trimmed;
     switch (schema.type) {
-        case "number": {
+        case 'number': {
             if (trimmed.length === 0)
                 throw new Error(`invalid numeric value: ""`);
             const n = Number(trimmed);
@@ -14,7 +14,7 @@ function coerceParamValue(raw, schema) {
                 throw new Error(`invalid numeric value: "${trimmed}"`);
             return n;
         }
-        case "integer": {
+        case 'integer': {
             if (trimmed.length === 0)
                 throw new Error(`invalid integer value: ""`);
             const n = Number(trimmed);
@@ -22,18 +22,18 @@ function coerceParamValue(raw, schema) {
                 throw new Error(`invalid integer value: "${trimmed}"`);
             return n;
         }
-        case "boolean": {
+        case 'boolean': {
             // Qwen3.5/3.6 intermittently emit Python-style capitalised booleans
             // (`True`/`False`); accept any casing so a valid call isn't dropped.
             const v = trimmed.toLowerCase();
-            if (v === "true")
+            if (v === 'true')
                 return true;
-            if (v === "false")
+            if (v === 'false')
                 return false;
             throw new Error(`invalid boolean value: "${trimmed}"`);
         }
-        case "array":
-        case "object":
+        case 'array':
+        case 'object':
             return JSON.parse(trimmed);
         default:
             return trimmed;
@@ -50,7 +50,7 @@ function coerceParamValue(raw, schema) {
 export function parseQwen35Format(text, tools) {
     const toolCalls = [];
     const errors = [];
-    if (!text.includes("<tool_call>")) {
+    if (!text.includes('<tool_call>')) {
         return { matched: false, toolCalls, errors };
     }
     const outerRegex = /<tool_call>([\s\S]*?)<\/tool_call>/g;
@@ -59,10 +59,10 @@ export function parseQwen35Format(text, tools) {
         return { matched: false, toolCalls, errors };
     // If no match contains XML function syntax, check if this is JSON format
     // (defer to hermes) or just malformed content (surface as PARSE_ERROR).
-    if (!outerMatches.some((m) => m[1].includes("<function="))) {
+    if (!outerMatches.some((m) => m[1].includes('<function='))) {
         const looksLikeJson = outerMatches.some((m) => {
             const inner = m[1].trim();
-            return inner.startsWith("{") || inner.startsWith("[");
+            return inner.startsWith('{') || inner.startsWith('[');
         });
         if (looksLikeJson)
             return { matched: false, toolCalls, errors };
@@ -70,10 +70,10 @@ export function parseQwen35Format(text, tools) {
             matched: true,
             toolCalls,
             errors: outerMatches.map((m) => ({
-                code: "PARSE_ERROR",
-                message: "Qwen3.5 tool call missing <function=NAME>...</function>",
-                raw: m[1].trim(),
-            })),
+                code: 'PARSE_ERROR',
+                message: 'Qwen3.5 tool call missing <function=NAME>...</function>',
+                raw: m[1].trim()
+            }))
         };
     }
     for (const outerMatch of outerMatches) {
@@ -81,9 +81,9 @@ export function parseQwen35Format(text, tools) {
         const fnMatch = /<function=([^>\s]+)\s*>([\s\S]*?)<\/function>/i.exec(inner);
         if (!fnMatch) {
             errors.push({
-                code: "PARSE_ERROR",
-                message: "Qwen3.5 tool call missing <function=NAME>...</function>",
-                raw: inner,
+                code: 'PARSE_ERROR',
+                message: 'Qwen3.5 tool call missing <function=NAME>...</function>',
+                raw: inner
             });
             continue;
         }
@@ -105,7 +105,7 @@ export function parseQwen35Format(text, tools) {
             parseError = err instanceof Error ? err.message : String(err);
         }
         if (parseError !== undefined) {
-            errors.push({ code: "PARSE_ERROR", message: parseError, raw: inner });
+            errors.push({ code: 'PARSE_ERROR', message: parseError, raw: inner });
             continue;
         }
         const validation = validateToolArguments(name, args, tools);
@@ -117,7 +117,7 @@ export function parseQwen35Format(text, tools) {
             id: generateStableToolCallId(name, args),
             name,
             arguments: args,
-            raw: inner,
+            raw: inner
         });
     }
     return { matched: true, toolCalls, errors };

package/dist/server/utils/tools/shared.d.ts

@@ -1,4 +1,4 @@
-import type { Tool, ToolCall, ToolCallError } from "../../../schemas/index";
+import type { Tool, ToolCall, ToolCallError } from '../../../schemas/index';
 export type ParserResult = {
     matched: boolean;
     toolCalls: ToolCall[];

package/dist/server/utils/tools/shared.js

@@ -1,5 +1,5 @@
 export function stripThinkingBlocks(text) {
-    return text.replace(/<think>[\s\S]*?<\/think>/gi, "");
+    return text.replace(/<think>[\s\S]*?<\/think>/gi, '');
 }
 let toolCallSequence = 0;
 export function generateStableToolCallId(name, args) {
@@ -14,15 +14,13 @@ export function generateStableToolCallId(name, args) {
     return `call_${Math.abs(hash).toString(36)}_${sequence}`;
 }
 export function isValidToolCall(obj) {
-    if (!obj || typeof obj !== "object") {
+    if (!obj || typeof obj !== 'object') {
         return false;
     }
-    if (!("name" in obj) || typeof obj.name !== "string") {
+    if (!('name' in obj) || typeof obj.name !== 'string') {
         return false;
     }
-    if (!("arguments" in obj) ||
-        typeof obj.arguments !== "object" ||
-        obj.arguments === null) {
+    if (!('arguments' in obj) || typeof obj.arguments !== 'object' || obj.arguments === null) {
         return false;
     }
     return true;
@@ -33,9 +31,9 @@ export function validateToolArguments(toolName, args, tools) {
         return {
             isValid: false,
             error: {
-                code: "UNKNOWN_TOOL",
-                message: `Tool "${toolName}" not found in available tools`,
-            },
+                code: 'UNKNOWN_TOOL',
+                message: `Tool "${toolName}" not found in available tools`
+            }
         };
     }
     const required = tool.parameters.required || [];
@@ -44,9 +42,9 @@ export function validateToolArguments(toolName, args, tools) {
             return {
                 isValid: false,
                 error: {
-                    code: "VALIDATION_ERROR",
-                    message: `Missing required parameter "${requiredParam}" for tool "${toolName}"`,
-                },
+                    code: 'VALIDATION_ERROR',
+                    message: `Missing required parameter "${requiredParam}" for tool "${toolName}"`
+                }
             };
         }
     }

package/dist/server/utils/worker-lock.js

@@ -1,10 +1,10 @@
-import fs from "bare-fs";
-import path from "bare-path";
-import os from "bare-os";
-import { getServerLogger } from "../../logging/index.js";
-import { getQvacPath } from "./qvac-paths.js";
+import fs from 'bare-fs';
+import path from 'bare-path';
+import os from 'bare-os';
+import { getServerLogger } from '../../logging/index.js';
+import { getQvacPath } from './qvac-paths.js';
 const logger = getServerLogger();
-const LOCK_FILENAME = ".worker.lock";
+const LOCK_FILENAME = '.worker.lock';
 function getLockFilePath() {
     return getQvacPath(LOCK_FILENAME);
 }
@@ -21,7 +21,7 @@ function readLockFile(lockPath) {
     try {
         if (!fs.existsSync(lockPath))
             return null;
-        const raw = fs.readFileSync(lockPath, "utf-8");
+        const raw = fs.readFileSync(lockPath, 'utf-8');
         return JSON.parse(raw);
     }
     catch {
@@ -41,7 +41,7 @@ export function acquireWorkerLock() {
     }
     const content = {
         pid: os.pid(),
-        startedAt: new Date().toISOString(),
+        startedAt: new Date().toISOString()
     };
     try {
         fs.mkdirSync(path.dirname(lockPath), { recursive: true });
@@ -49,7 +49,7 @@ export function acquireWorkerLock() {
         logger.debug(`Worker lock acquired (PID ${os.pid()})`);
     }
     catch (error) {
-        logger.error("Failed to write worker lock file:", error instanceof Error ? error.message : String(error));
+        logger.error('Failed to write worker lock file:', error instanceof Error ? error.message : String(error));
     }
 }
 export function releaseWorkerLock() {
@@ -58,7 +58,7 @@ export function releaseWorkerLock() {
         const existing = readLockFile(lockPath);
         if (existing && existing.pid === os.pid()) {
             fs.unlinkSync(lockPath);
-            logger.debug("Worker lock released");
+            logger.debug('Worker lock released');
         }
     }
     catch {

package/dist/server/worker-core.d.ts

@@ -3,7 +3,7 @@ export declare function initializeWorkerCore(): {
 };
 export declare function ensureRPCSetup(): void;
 export declare function isCoreInitialized(): boolean;
-export type BareDirectShutdownReason = "signal" | "rpc-close" | "uncaught-exception" | "unhandled-rejection" | "ipc-disconnect";
+export type BareDirectShutdownReason = 'signal' | 'rpc-close' | 'uncaught-exception' | 'unhandled-rejection' | 'ipc-disconnect';
 /**
  * Pre-terminate cleanup, callable while the worker is still alive.
  *