guideai-app 0.5.4-2 → 0.5.4-8

package/dist/playwrightBuddyHarness.js

@@ -0,0 +1,1766 @@
+/******/ (() => { // webpackBootstrap
+/******/ 	"use strict";
+/******/ 	var __webpack_modules__ = ({
+
+/***/ 983
+/*!*************************************!*\
+  !*** ./src/buddy/buddyPropTools.ts ***!
+  \*************************************/
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.buddyPropTools = exports.BUDDY_TOOL_NAMES = void 0;
+var buddyTools_1 = __webpack_require__(/*! ./buddyTools */ 552);
+var actionProperty = {
+    type: 'string',
+    description: 'Operation to perform. See tool description for valid values.',
+};
+var userIdProperty = {
+    type: 'string',
+    description: 'Optional user scope override. Defaults to the signed-in widget user.',
+};
+exports.BUDDY_TOOL_NAMES = [
+    'buddyTaskList',
+    'buddyResearch',
+    'buddyQuickie',
+    'buddyMemory',
+];
+exports.buddyPropTools = {
+    buddyTaskList: {
+        description: 'Manage the user task queue for everyday work. Actions: add (enqueue), list (optionally filter by status), getNext (current or next pending task), complete, update, remove.',
+        parameters: {
+            type: 'object',
+            properties: {
+                action: __assign(__assign({}, actionProperty), { enum: ['add', 'list', 'getNext', 'complete', 'update', 'remove'] }),
+                userId: userIdProperty,
+                title: { type: 'string', description: 'Task title (add/update).' },
+                description: { type: 'string', description: 'Task details (add/update).' },
+                taskId: { type: 'string', description: 'Task id (complete/update/remove).' },
+                status: {
+                    type: 'string',
+                    enum: ['pending', 'in_progress', 'completed', 'cancelled'],
+                    description: 'Task status filter or update value.',
+                },
+                priority: {
+                    type: 'string',
+                    enum: ['low', 'normal', 'high'],
+                    description: 'Task priority (add/update).',
+                },
+            },
+            required: ['action'],
+        },
+        execute: buddyTools_1.executeBuddyTaskList,
+    },
+    buddyResearch: {
+        description: 'Capture and retrieve research notes linked to everyday tasks. Actions: add, list (search by query or taskId), get (by noteId).',
+        parameters: {
+            type: 'object',
+            properties: {
+                action: __assign(__assign({}, actionProperty), { enum: ['add', 'list', 'get'] }),
+                userId: userIdProperty,
+                title: { type: 'string', description: 'Research title (add).' },
+                content: { type: 'string', description: 'Research body (add).' },
+                sources: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'URLs or citations (add).',
+                },
+                tags: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Tags for retrieval (add).',
+                },
+                taskId: {
+                    type: 'string',
+                    description: 'Optional linked task id (add/list filter).',
+                },
+                noteId: { type: 'string', description: 'Research note id (get).' },
+                query: { type: 'string', description: 'Search text (list).' },
+            },
+            required: ['action'],
+        },
+        execute: buddyTools_1.executeBuddyResearch,
+    },
+    buddyQuickie: {
+        description: 'Save and replay small everyday automations (like Excel macros) from observed workflows. Actions: save, list, get, run, delete. A quickie is a named sequence of instruction or tool steps.',
+        parameters: {
+            type: 'object',
+            properties: {
+                action: __assign(__assign({}, actionProperty), { enum: ['save', 'list', 'get', 'run', 'delete'] }),
+                userId: userIdProperty,
+                quickieId: { type: 'string', description: 'Quickie id (get/run/delete/update).' },
+                name: { type: 'string', description: 'Short macro name (save).' },
+                description: {
+                    type: 'string',
+                    description: 'What this automation does (save).',
+                },
+                trigger: {
+                    type: 'string',
+                    description: 'When the user usually runs this (save), e.g. "every morning".',
+                },
+                steps: {
+                    type: 'array',
+                    description: 'Ordered steps. Each item: { kind: "instruction" | "tool", content: string }.',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            kind: { type: 'string', enum: ['instruction', 'tool'] },
+                            content: { type: 'string' },
+                        },
+                        required: ['kind', 'content'],
+                    },
+                },
+                tags: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Optional labels (save).',
+                },
+            },
+            required: ['action'],
+        },
+        execute: buddyTools_1.executeBuddyQuickie,
+    },
+    buddyMemory: {
+        description: 'Remember how the user organizes tasks, research, quickies, and their work style. Actions: get (full memory), search, setNote (key/value), appendOrganization, appendWorkStyle.',
+        parameters: {
+            type: 'object',
+            properties: {
+                action: __assign(__assign({}, actionProperty), { enum: ['get', 'search', 'setNote', 'appendOrganization', 'appendWorkStyle'] }),
+                userId: userIdProperty,
+                key: { type: 'string', description: 'Note key (setNote).' },
+                value: {
+                    type: 'string',
+                    description: 'Note value or list entry (setNote/append*).',
+                },
+                query: { type: 'string', description: 'Search filter (search).' },
+            },
+            required: ['action'],
+        },
+        execute: buddyTools_1.executeBuddyMemory,
+    },
+};
+
+
+/***/ },
+
+/***/ 302
+/*!*********************************!*\
+  !*** ./src/buddy/buddyStore.ts ***!
+  \*********************************/
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.BUDDY_STATE_CHANGED_EVENT = void 0;
+exports.resolveBuddyUserId = resolveBuddyUserId;
+exports.readBuddyState = readBuddyState;
+exports.writeBuddyState = writeBuddyState;
+exports.addBuddyTask = addBuddyTask;
+exports.listBuddyTasks = listBuddyTasks;
+exports.getNextBuddyTask = getNextBuddyTask;
+exports.updateBuddyTask = updateBuddyTask;
+exports.completeBuddyTask = completeBuddyTask;
+exports.removeBuddyTask = removeBuddyTask;
+exports.addResearchNote = addResearchNote;
+exports.listResearchNotes = listResearchNotes;
+exports.getResearchNote = getResearchNote;
+exports.saveQuickie = saveQuickie;
+exports.listQuickies = listQuickies;
+exports.getQuickie = getQuickie;
+exports.runQuickie = runQuickie;
+exports.deleteQuickie = deleteQuickie;
+exports.getBuddyMemory = getBuddyMemory;
+exports.setBuddyMemoryNote = setBuddyMemoryNote;
+exports.appendBuddyMemoryList = appendBuddyMemoryList;
+exports.searchBuddyMemory = searchBuddyMemory;
+exports.clearBuddyState = clearBuddyState;
+var types_1 = __webpack_require__(/*! ./types */ 958);
+var localStorageHelper_1 = __webpack_require__(/*! ../utils/localStorageHelper */ 640);
+var localStorageHelper_2 = __webpack_require__(/*! ../utils/localStorageHelper */ 640);
+exports.BUDDY_STATE_CHANGED_EVENT = 'guideai_buddy_state_changed';
+var BUDDY_STORAGE_PREFIX = 'guideAI_buddy_state_';
+function storageKeyForUser(userId) {
+    return "".concat(BUDDY_STORAGE_PREFIX).concat(userId);
+}
+function newId(prefix) {
+    if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
+        return "".concat(prefix, "_").concat(crypto.randomUUID());
+    }
+    return "".concat(prefix, "_").concat(Date.now(), "_").concat(Math.random().toString(36).slice(2, 9));
+}
+function nowIso() {
+    return new Date().toISOString();
+}
+function emitBuddyStateChanged(userId) {
+    if (typeof window === 'undefined')
+        return;
+    try {
+        window.dispatchEvent(new CustomEvent(exports.BUDDY_STATE_CHANGED_EVENT, { detail: { userId: userId } }));
+    }
+    catch (_a) {
+        /* ignore */
+    }
+}
+function emptyState(userId) {
+    return {
+        version: types_1.BUDDY_STATE_VERSION,
+        userId: userId,
+        tasks: [],
+        research: [],
+        quickies: [],
+        memory: __assign(__assign({}, types_1.EMPTY_BUDDY_MEMORY), { updatedAt: nowIso() }),
+    };
+}
+function parseState(raw, userId) {
+    var _a, _b, _c, _d;
+    try {
+        var parsed = JSON.parse(raw);
+        if (parsed.version !== types_1.BUDDY_STATE_VERSION)
+            return emptyState(userId);
+        return {
+            version: types_1.BUDDY_STATE_VERSION,
+            userId: userId,
+            tasks: Array.isArray(parsed.tasks) ? parsed.tasks : [],
+            research: Array.isArray(parsed.research) ? parsed.research : [],
+            quickies: Array.isArray(parsed.quickies) ? parsed.quickies : [],
+            memory: {
+                organization: Array.isArray((_a = parsed.memory) === null || _a === void 0 ? void 0 : _a.organization)
+                    ? parsed.memory.organization.filter(function (v) { return typeof v === 'string'; })
+                    : [],
+                workStyle: Array.isArray((_b = parsed.memory) === null || _b === void 0 ? void 0 : _b.workStyle)
+                    ? parsed.memory.workStyle.filter(function (v) { return typeof v === 'string'; })
+                    : [],
+                notes: ((_c = parsed.memory) === null || _c === void 0 ? void 0 : _c.notes) && typeof parsed.memory.notes === 'object'
+                    ? Object.fromEntries(Object.entries(parsed.memory.notes).filter(function (_a) {
+                        var k = _a[0], v = _a[1];
+                        return typeof k === 'string' && typeof v === 'string';
+                    }))
+                    : {},
+                updatedAt: typeof ((_d = parsed.memory) === null || _d === void 0 ? void 0 : _d.updatedAt) === 'string' ? parsed.memory.updatedAt : nowIso(),
+            },
+        };
+    }
+    catch (_e) {
+        return emptyState(userId);
+    }
+}
+function resolveBuddyUserId(override) {
+    var trimmed = override === null || override === void 0 ? void 0 : override.trim();
+    if (trimmed)
+        return trimmed;
+    return (0, localStorageHelper_1.resolveWidgetEndUserId)();
+}
+function readBuddyState(userId) {
+    var id = resolveBuddyUserId(userId);
+    var raw = (0, localStorageHelper_2.safeReadLocal)(storageKeyForUser(id));
+    if (!raw)
+        return emptyState(id);
+    return parseState(raw, id);
+}
+function writeBuddyState(state) {
+    var next = __assign(__assign({}, state), { userId: state.userId.trim() || (0, localStorageHelper_1.resolveWidgetEndUserId)() });
+    (0, localStorageHelper_2.safeWriteLocal)(storageKeyForUser(next.userId), JSON.stringify(next));
+    emitBuddyStateChanged(next.userId);
+    return next;
+}
+function withState(userId, mutate) {
+    var current = readBuddyState(userId);
+    var _a = mutate(current), state = _a.state, result = _a.result;
+    writeBuddyState(state);
+    return result;
+}
+var TASK_STATUS_ORDER = {
+    in_progress: 0,
+    pending: 1,
+    completed: 2,
+    cancelled: 3,
+};
+var TASK_PRIORITY_ORDER = {
+    high: 0,
+    normal: 1,
+    low: 2,
+};
+function sortTasks(tasks) {
+    return __spreadArray([], tasks, true).sort(function (a, b) {
+        var statusDiff = TASK_STATUS_ORDER[a.status] - TASK_STATUS_ORDER[b.status];
+        if (statusDiff !== 0)
+            return statusDiff;
+        var priorityDiff = TASK_PRIORITY_ORDER[a.priority] - TASK_PRIORITY_ORDER[b.priority];
+        if (priorityDiff !== 0)
+            return priorityDiff;
+        return a.createdAt.localeCompare(b.createdAt);
+    });
+}
+function addBuddyTask(input) {
+    var title = input.title.trim();
+    if (!title)
+        throw new Error('Task title is required');
+    return withState(input.userId, function (state) {
+        var _a, _b, _c;
+        var ts = nowIso();
+        var task = {
+            id: newId('task'),
+            title: title,
+            description: ((_a = input.description) === null || _a === void 0 ? void 0 : _a.trim()) || undefined,
+            status: (_b = input.status) !== null && _b !== void 0 ? _b : 'pending',
+            priority: (_c = input.priority) !== null && _c !== void 0 ? _c : 'normal',
+            createdAt: ts,
+            updatedAt: ts,
+        };
+        return {
+            state: __assign(__assign({}, state), { tasks: sortTasks(__spreadArray(__spreadArray([], state.tasks, true), [task], false)) }),
+            result: task,
+        };
+    });
+}
+function listBuddyTasks(input) {
+    var tasks = sortTasks(readBuddyState(input === null || input === void 0 ? void 0 : input.userId).tasks);
+    if (!(input === null || input === void 0 ? void 0 : input.status))
+        return tasks;
+    return tasks.filter(function (t) { return t.status === input.status; });
+}
+function getNextBuddyTask(userId) {
+    var _a;
+    var tasks = listBuddyTasks({ status: 'in_progress', userId: userId });
+    if (tasks.length > 0)
+        return tasks[0];
+    var pending = listBuddyTasks({ status: 'pending', userId: userId });
+    return (_a = pending[0]) !== null && _a !== void 0 ? _a : null;
+}
+function updateBuddyTask(input) {
+    return withState(input.userId, function (state) {
+        var _a, _b, _c, _d;
+        var idx = state.tasks.findIndex(function (t) { return t.id === input.taskId; });
+        if (idx < 0)
+            throw new Error("Task not found: ".concat(input.taskId));
+        var existing = state.tasks[idx];
+        var ts = nowIso();
+        var nextStatus = (_a = input.status) !== null && _a !== void 0 ? _a : existing.status;
+        var completedAt = existing.completedAt;
+        if (nextStatus === 'completed') {
+            completedAt = existing.status === 'completed' ? ((_b = existing.completedAt) !== null && _b !== void 0 ? _b : ts) : ts;
+        }
+        else if (input.status !== undefined) {
+            completedAt = undefined;
+        }
+        var updated = __assign(__assign({}, existing), { title: ((_c = input.title) === null || _c === void 0 ? void 0 : _c.trim()) || existing.title, description: input.description !== undefined
+                ? input.description.trim() || undefined
+                : existing.description, status: nextStatus, priority: (_d = input.priority) !== null && _d !== void 0 ? _d : existing.priority, updatedAt: ts, completedAt: completedAt });
+        var tasks = __spreadArray([], state.tasks, true);
+        tasks[idx] = updated;
+        return { state: __assign(__assign({}, state), { tasks: sortTasks(tasks) }), result: updated };
+    });
+}
+function completeBuddyTask(input) {
+    return updateBuddyTask(__assign(__assign({}, input), { status: 'completed' }));
+}
+function removeBuddyTask(input) {
+    return withState(input.userId, function (state) {
+        var nextTasks = state.tasks.filter(function (t) { return t.id !== input.taskId; });
+        if (nextTasks.length === state.tasks.length) {
+            throw new Error("Task not found: ".concat(input.taskId));
+        }
+        return { state: __assign(__assign({}, state), { tasks: nextTasks }), result: true };
+    });
+}
+function addResearchNote(input) {
+    var title = input.title.trim();
+    var content = input.content.trim();
+    if (!title)
+        throw new Error('Research title is required');
+    if (!content)
+        throw new Error('Research content is required');
+    return withState(input.userId, function (state) {
+        var _a, _b, _c;
+        var ts = nowIso();
+        var note = {
+            id: newId('research'),
+            title: title,
+            content: content,
+            sources: (_a = input.sources) === null || _a === void 0 ? void 0 : _a.map(function (s) { return s.trim(); }).filter(Boolean),
+            tags: (_b = input.tags) === null || _b === void 0 ? void 0 : _b.map(function (s) { return s.trim(); }).filter(Boolean),
+            taskId: ((_c = input.taskId) === null || _c === void 0 ? void 0 : _c.trim()) || undefined,
+            createdAt: ts,
+            updatedAt: ts,
+        };
+        return {
+            state: __assign(__assign({}, state), { research: __spreadArray([note], state.research, true) }),
+            result: note,
+        };
+    });
+}
+function listResearchNotes(input) {
+    var _a;
+    var notes = readBuddyState(input === null || input === void 0 ? void 0 : input.userId).research;
+    if (input === null || input === void 0 ? void 0 : input.taskId) {
+        notes = notes.filter(function (n) { return n.taskId === input.taskId; });
+    }
+    var query = (_a = input === null || input === void 0 ? void 0 : input.query) === null || _a === void 0 ? void 0 : _a.trim().toLowerCase();
+    if (query) {
+        notes = notes.filter(function (n) {
+            var _a;
+            return n.title.toLowerCase().includes(query) ||
+                n.content.toLowerCase().includes(query) ||
+                ((_a = n.tags) !== null && _a !== void 0 ? _a : []).some(function (t) { return t.toLowerCase().includes(query); });
+        });
+    }
+    return notes;
+}
+function getResearchNote(input) {
+    var note = readBuddyState(input.userId).research.find(function (n) { return n.id === input.noteId; });
+    if (!note)
+        throw new Error("Research note not found: ".concat(input.noteId));
+    return note;
+}
+function saveQuickie(input) {
+    var name = input.name.trim();
+    if (!name)
+        throw new Error('Quickie name is required');
+    if (!input.steps.length)
+        throw new Error('Quickie must have at least one step');
+    return withState(input.userId, function (state) {
+        var _a, _b, _c, _d;
+        var ts = nowIso();
+        var existingIdx = input.quickieId
+            ? state.quickies.findIndex(function (q) { return q.id === input.quickieId; })
+            : -1;
+        var quickie = existingIdx >= 0
+            ? __assign(__assign({}, state.quickies[existingIdx]), { name: name, description: input.description.trim(), trigger: ((_a = input.trigger) === null || _a === void 0 ? void 0 : _a.trim()) || undefined, steps: input.steps, tags: (_b = input.tags) === null || _b === void 0 ? void 0 : _b.map(function (t) { return t.trim(); }).filter(Boolean), updatedAt: ts }) : {
+            id: newId('quickie'),
+            name: name,
+            description: input.description.trim(),
+            trigger: ((_c = input.trigger) === null || _c === void 0 ? void 0 : _c.trim()) || undefined,
+            steps: input.steps,
+            tags: (_d = input.tags) === null || _d === void 0 ? void 0 : _d.map(function (t) { return t.trim(); }).filter(Boolean),
+            usageCount: 0,
+            createdAt: ts,
+            updatedAt: ts,
+        };
+        var quickies = existingIdx >= 0
+            ? state.quickies.map(function (q, i) { return (i === existingIdx ? quickie : q); })
+            : __spreadArray([quickie], state.quickies, true);
+        return { state: __assign(__assign({}, state), { quickies: quickies }), result: quickie };
+    });
+}
+function listQuickies(userId) {
+    return readBuddyState(userId).quickies;
+}
+function getQuickie(input) {
+    var quickie = readBuddyState(input.userId).quickies.find(function (q) { return q.id === input.quickieId; });
+    if (!quickie)
+        throw new Error("Quickie not found: ".concat(input.quickieId));
+    return quickie;
+}
+function runQuickie(input) {
+    return withState(input.userId, function (state) {
+        var idx = state.quickies.findIndex(function (q) { return q.id === input.quickieId; });
+        if (idx < 0)
+            throw new Error("Quickie not found: ".concat(input.quickieId));
+        var ts = nowIso();
+        var quickie = __assign(__assign({}, state.quickies[idx]), { usageCount: state.quickies[idx].usageCount + 1, lastUsedAt: ts, updatedAt: ts });
+        var quickies = state.quickies.map(function (q, i) { return (i === idx ? quickie : q); });
+        return { state: __assign(__assign({}, state), { quickies: quickies }), result: quickie };
+    });
+}
+function deleteQuickie(input) {
+    return withState(input.userId, function (state) {
+        var next = state.quickies.filter(function (q) { return q.id !== input.quickieId; });
+        if (next.length === state.quickies.length) {
+            throw new Error("Quickie not found: ".concat(input.quickieId));
+        }
+        return { state: __assign(__assign({}, state), { quickies: next }), result: true };
+    });
+}
+function getBuddyMemory(userId) {
+    return readBuddyState(userId).memory;
+}
+function setBuddyMemoryNote(input) {
+    var key = input.key.trim();
+    if (!key)
+        throw new Error('Memory key is required');
+    return withState(input.userId, function (state) {
+        var _a;
+        var ts = nowIso();
+        var memory = __assign(__assign({}, state.memory), { notes: __assign(__assign({}, state.memory.notes), (_a = {}, _a[key] = input.value.trim(), _a)), updatedAt: ts });
+        return { state: __assign(__assign({}, state), { memory: memory }), result: memory };
+    });
+}
+function appendBuddyMemoryList(input) {
+    var value = input.value.trim();
+    if (!value)
+        throw new Error('Memory value is required');
+    return withState(input.userId, function (state) {
+        var _a;
+        var ts = nowIso();
+        var list = state.memory[input.category];
+        if (list.includes(value)) {
+            return { state: state, result: state.memory };
+        }
+        var memory = __assign(__assign({}, state.memory), (_a = {}, _a[input.category] = __spreadArray(__spreadArray([], list, true), [value], false), _a.updatedAt = ts, _a));
+        return { state: __assign(__assign({}, state), { memory: memory }), result: memory };
+    });
+}
+function searchBuddyMemory(input) {
+    var _a;
+    var memory = getBuddyMemory(input.userId);
+    var query = (_a = input.query) === null || _a === void 0 ? void 0 : _a.trim().toLowerCase();
+    if (!query)
+        return memory;
+    return __assign(__assign({}, memory), { organization: memory.organization.filter(function (v) { return v.toLowerCase().includes(query); }), workStyle: memory.workStyle.filter(function (v) { return v.toLowerCase().includes(query); }), notes: Object.fromEntries(Object.entries(memory.notes).filter(function (_a) {
+            var k = _a[0], v = _a[1];
+            return k.toLowerCase().includes(query) || v.toLowerCase().includes(query);
+        })) });
+}
+function clearBuddyState(userId) {
+    var id = resolveBuddyUserId(userId);
+    var state = emptyState(id);
+    writeBuddyState(state);
+    return state;
+}
+
+
+/***/ },
+
+/***/ 552
+/*!*********************************!*\
+  !*** ./src/buddy/buddyTools.ts ***!
+  \*********************************/
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.executeBuddyTaskList = executeBuddyTaskList;
+exports.executeBuddyResearch = executeBuddyResearch;
+exports.executeBuddyQuickie = executeBuddyQuickie;
+exports.executeBuddyMemory = executeBuddyMemory;
+var buddyStore_1 = __webpack_require__(/*! ./buddyStore */ 302);
+function asString(value) {
+    return typeof value === 'string' ? value : undefined;
+}
+function asStringArray(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    return value.filter(function (v) { return typeof v === 'string'; });
+}
+function parseQuickieSteps(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .map(function (step) {
+        if (!step || typeof step !== 'object')
+            return null;
+        var kind = step.kind;
+        var content = step.content;
+        if ((kind !== 'instruction' && kind !== 'tool') || typeof content !== 'string') {
+            return null;
+        }
+        return { kind: kind, content: content.trim() };
+    })
+        .filter(function (s) { return !!s && s.content.length > 0; });
+}
+function parseTaskStatus(value) {
+    if (value === 'pending' ||
+        value === 'in_progress' ||
+        value === 'completed' ||
+        value === 'cancelled') {
+        return value;
+    }
+    return undefined;
+}
+function parseTaskPriority(value) {
+    if (value === 'low' || value === 'normal' || value === 'high')
+        return value;
+    return undefined;
+}
+function executeBuddyTaskList(args) {
+    return __awaiter(this, void 0, void 0, function () {
+        var action, userId;
+        var _a, _b, _c, _d;
+        return __generator(this, function (_e) {
+            action = asString(args.action);
+            userId = asString(args.userId);
+            switch (action) {
+                case 'add':
+                    return [2 /*return*/, (0, buddyStore_1.addBuddyTask)({
+                            userId: userId,
+                            title: (_a = asString(args.title)) !== null && _a !== void 0 ? _a : '',
+                            description: asString(args.description),
+                            priority: parseTaskPriority(args.priority),
+                            status: parseTaskStatus(args.status),
+                        })];
+                case 'list':
+                    return [2 /*return*/, (0, buddyStore_1.listBuddyTasks)({ userId: userId, status: parseTaskStatus(args.status) })];
+                case 'getNext':
+                    return [2 /*return*/, (0, buddyStore_1.getNextBuddyTask)(userId)];
+                case 'complete':
+                    return [2 /*return*/, (0, buddyStore_1.completeBuddyTask)({
+                            userId: userId,
+                            taskId: (_b = asString(args.taskId)) !== null && _b !== void 0 ? _b : '',
+                        })];
+                case 'update':
+                    return [2 /*return*/, (0, buddyStore_1.updateBuddyTask)({
+                            userId: userId,
+                            taskId: (_c = asString(args.taskId)) !== null && _c !== void 0 ? _c : '',
+                            title: asString(args.title),
+                            description: asString(args.description),
+                            status: parseTaskStatus(args.status),
+                            priority: parseTaskPriority(args.priority),
+                        })];
+                case 'remove':
+                    return [2 /*return*/, (0, buddyStore_1.removeBuddyTask)({
+                            userId: userId,
+                            taskId: (_d = asString(args.taskId)) !== null && _d !== void 0 ? _d : '',
+                        })];
+                default:
+                    throw new Error("buddyTaskList: unknown action \"".concat(action, "\". Use add, list, getNext, complete, update, or remove."));
+            }
+            return [2 /*return*/];
+        });
+    });
+}
+function executeBuddyResearch(args) {
+    return __awaiter(this, void 0, void 0, function () {
+        var action, userId;
+        var _a, _b, _c;
+        return __generator(this, function (_d) {
+            action = asString(args.action);
+            userId = asString(args.userId);
+            switch (action) {
+                case 'add':
+                    return [2 /*return*/, (0, buddyStore_1.addResearchNote)({
+                            userId: userId,
+                            title: (_a = asString(args.title)) !== null && _a !== void 0 ? _a : '',
+                            content: (_b = asString(args.content)) !== null && _b !== void 0 ? _b : '',
+                            sources: asStringArray(args.sources),
+                            tags: asStringArray(args.tags),
+                            taskId: asString(args.taskId),
+                        })];
+                case 'list':
+                    return [2 /*return*/, (0, buddyStore_1.listResearchNotes)({
+                            userId: userId,
+                            query: asString(args.query),
+                            taskId: asString(args.taskId),
+                        })];
+                case 'get':
+                    return [2 /*return*/, (0, buddyStore_1.getResearchNote)({
+                            userId: userId,
+                            noteId: (_c = asString(args.noteId)) !== null && _c !== void 0 ? _c : '',
+                        })];
+                default:
+                    throw new Error("buddyResearch: unknown action \"".concat(action, "\". Use add, list, or get."));
+            }
+            return [2 /*return*/];
+        });
+    });
+}
+function executeBuddyQuickie(args) {
+    return __awaiter(this, void 0, void 0, function () {
+        var action, userId, quickie;
+        var _a, _b, _c, _d, _e;
+        return __generator(this, function (_f) {
+            action = asString(args.action);
+            userId = asString(args.userId);
+            switch (action) {
+                case 'save':
+                    return [2 /*return*/, (0, buddyStore_1.saveQuickie)({
+                            userId: userId,
+                            quickieId: asString(args.quickieId),
+                            name: (_a = asString(args.name)) !== null && _a !== void 0 ? _a : '',
+                            description: (_b = asString(args.description)) !== null && _b !== void 0 ? _b : '',
+                            trigger: asString(args.trigger),
+                            steps: parseQuickieSteps(args.steps),
+                            tags: asStringArray(args.tags),
+                        })];
+                case 'list':
+                    return [2 /*return*/, (0, buddyStore_1.listQuickies)(userId)];
+                case 'get':
+                    return [2 /*return*/, (0, buddyStore_1.getQuickie)({
+                            userId: userId,
+                            quickieId: (_c = asString(args.quickieId)) !== null && _c !== void 0 ? _c : '',
+                        })];
+                case 'run': {
+                    quickie = (0, buddyStore_1.runQuickie)({
+                        userId: userId,
+                        quickieId: (_d = asString(args.quickieId)) !== null && _d !== void 0 ? _d : '',
+                    });
+                    return [2 /*return*/, {
+                            quickie: quickie,
+                            message: 'Execute each step in order. Tool steps are JSON like {"tool":"fillField","args":{...}}; instruction steps are natural-language guidance.',
+                        }];
+                }
+                case 'delete':
+                    return [2 /*return*/, (0, buddyStore_1.deleteQuickie)({
+                            userId: userId,
+                            quickieId: (_e = asString(args.quickieId)) !== null && _e !== void 0 ? _e : '',
+                        })];
+                default:
+                    throw new Error("buddyQuickie: unknown action \"".concat(action, "\". Use save, list, get, run, or delete."));
+            }
+            return [2 /*return*/];
+        });
+    });
+}
+function executeBuddyMemory(args) {
+    return __awaiter(this, void 0, void 0, function () {
+        var action, userId;
+        var _a, _b, _c, _d;
+        return __generator(this, function (_e) {
+            action = asString(args.action);
+            userId = asString(args.userId);
+            switch (action) {
+                case 'get':
+                    return [2 /*return*/, (0, buddyStore_1.getBuddyMemory)(userId)];
+                case 'search':
+                    return [2 /*return*/, (0, buddyStore_1.searchBuddyMemory)({ userId: userId, query: asString(args.query) })];
+                case 'setNote':
+                    return [2 /*return*/, (0, buddyStore_1.setBuddyMemoryNote)({
+                            userId: userId,
+                            key: (_a = asString(args.key)) !== null && _a !== void 0 ? _a : '',
+                            value: (_b = asString(args.value)) !== null && _b !== void 0 ? _b : '',
+                        })];
+                case 'appendOrganization':
+                    return [2 /*return*/, (0, buddyStore_1.appendBuddyMemoryList)({
+                            userId: userId,
+                            category: 'organization',
+                            value: (_c = asString(args.value)) !== null && _c !== void 0 ? _c : '',
+                        })];
+                case 'appendWorkStyle':
+                    return [2 /*return*/, (0, buddyStore_1.appendBuddyMemoryList)({
+                            userId: userId,
+                            category: 'workStyle',
+                            value: (_d = asString(args.value)) !== null && _d !== void 0 ? _d : '',
+                        })];
+                default:
+                    throw new Error("buddyMemory: unknown action \"".concat(action, "\". Use get, search, setNote, appendOrganization, or appendWorkStyle."));
+            }
+            return [2 /*return*/];
+        });
+    });
+}
+
+
+/***/ },
+
+/***/ 958
+/*!****************************!*\
+  !*** ./src/buddy/types.ts ***!
+  \****************************/
+(__unused_webpack_module, exports) {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.EMPTY_BUDDY_MEMORY = exports.BUDDY_STATE_VERSION = void 0;
+exports.BUDDY_STATE_VERSION = 1;
+exports.EMPTY_BUDDY_MEMORY = {
+    organization: [],
+    workStyle: [],
+    notes: {},
+    updatedAt: new Date(0).toISOString(),
+};
+
+
+/***/ },
+
+/***/ 737
+/*!***************************************!*\
+  !*** ./src/playwrightBuddyHarness.ts ***!
+  \***************************************/
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+/**
+ * Browser bundle entry for Playwright: exposes buddy productivity tools on window
+ * so E2E tests run against real localStorage in a page context.
+ */
+var buddyPropTools_1 = __webpack_require__(/*! ./buddy/buddyPropTools */ 983);
+var buddyStore_1 = __webpack_require__(/*! ./buddy/buddyStore */ 302);
+var toolMap = buddyPropTools_1.buddyPropTools;
+window.__GUIDEAI_BUDDY__ = {
+    toolNames: Object.keys(buddyPropTools_1.buddyPropTools),
+    executeTool: function (name, argsJson) { return __awaiter(void 0, void 0, void 0, function () {
+        var tool, parsed;
+        return __generator(this, function (_a) {
+            tool = toolMap[name];
+            if (!tool)
+                throw new Error("Unknown buddy tool: ".concat(name));
+            try {
+                parsed = argsJson ? JSON.parse(argsJson) : {};
+            }
+            catch (_b) {
+                throw new Error("Invalid JSON args for ".concat(name));
+            }
+            return [2 /*return*/, tool.execute(parsed)];
+        });
+    }); },
+    readState: function (userId) { return (0, buddyStore_1.readBuddyState)(userId); },
+    clearState: function (userId) { return (0, buddyStore_1.clearBuddyState)(userId); },
+};
+
+
+/***/ },
+
+/***/ 485
+/*!*************************************************!*\
+  !*** ./src/utils/guideaiMirroredStorageKeys.ts ***!
+  \*************************************************/
+(__unused_webpack_module, exports) {
+
+
+/**
+ * Canonical GuideAI localStorage key strings.
+ * Imported by guide-ai-package helpers and the Chrome extension (UMD does not export STORAGE_KEYS).
+ */
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.GUIDEAI_MIRRORED_STORAGE_KEYS = exports.GUIDEAI_STORAGE_KEYS = exports.WIDGET_BEARER_TOKEN_STORAGE_KEY = void 0;
+/** Widget Bearer JWT — mirrored; not part of transcript prefs. */
+exports.WIDGET_BEARER_TOKEN_STORAGE_KEY = 'guideai_widgetBearerToken';
+exports.GUIDEAI_STORAGE_KEYS = {
+    USER_UUID: 'guideAI_userUUID',
+    /** Persisted widget profile username (email or stable id); mirrored by the Chrome extension. */
+    WIDGET_PROFILE_USERNAME: 'guideAI_widgetProfileUsername',
+    SESSION_ID: 'guideAI_sessionId',
+    CONVERSATION: 'guideAI_conversation',
+    HAS_INTERACTED: 'guideAI_hasInteracted',
+    IS_MUTED: 'guideAI_isMuted',
+    /** Mute assistant TTS / remote audio (WebRTC playback); not the user microphone. */
+    ASSISTANT_PLAYBACK_MUTED: 'guideAI_assistantPlaybackMuted',
+    LOGGER_ENABLED: 'guideAI_loggerEnabled',
+    AUDIO_CONFIG: 'guideAI_audioConfig',
+    /** UI microphone preset selector (Precise vs Noisy). */
+    MIC_PRESET: 'guideAI_micPreset',
+    /** Developer tools shell: playback interrupt lock panel visibility (default off). */
+    PLAYBACK_LOCK_DEBUG_OVERLAY: 'guideAI_playbackLockDebugOverlay',
+    /** Developer tools shell: workflow tester tab overlay visibility (default off). */
+    WORKFLOW_TESTER_OVERLAY: 'guideAI_workflowTesterOverlay',
+    /** Last dragged position of the floating developer tools shell (`{ left, top }` JSON). */
+    DEVTOOLS_SHELL_POSITION: 'guideAI_devtoolsShellPosition',
+    /** Last dragged position of learn mode capture focus chrome (`{ left, top }` JSON). */
+    LEARN_CAPTURE_POSITION: 'guideAI_learnCapturePosition',
+};
+/**
+ * Keys mirrored from the widget to extension localStorage via `guideai_storage_write`.
+ */
+exports.GUIDEAI_MIRRORED_STORAGE_KEYS = __spreadArray(__spreadArray([], Object.values(exports.GUIDEAI_STORAGE_KEYS), true), [
+    exports.WIDGET_BEARER_TOKEN_STORAGE_KEY,
+], false);
+
+
+/***/ },
+
+/***/ 640
+/*!*****************************************!*\
+  !*** ./src/utils/localStorageHelper.ts ***!
+  \*****************************************/
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.STORAGE_KEYS = exports.clearTranscriptWorkflowPrefs = exports.setTranscriptWorkflowWorkspaceState = exports.getTranscriptWorkflowWorkspaceState = exports.setLastWorkspaceSlugPref = exports.getLastWorkspaceSlugPref = exports.setTranscriptPanelDockedPref = exports.getTranscriptPanelDockedPref = exports.clearTranscriptFloatGeometryPref = exports.setTranscriptFloatGeometryPref = exports.getTranscriptFloatGeometryPref = exports.setTranscriptDrawerWidthPref = exports.getTranscriptDrawerWidthPref = exports.TRANSCRIPT_DRAWER_WIDTH_MAX_PX = exports.TRANSCRIPT_DRAWER_WIDTH_MIN_PX = exports.TRANSCRIPT_DRAWER_WIDTH_PX = exports.setLearnCapturePosition = exports.getLearnCapturePosition = exports.setDevtoolsShellPosition = exports.getDevtoolsShellPosition = exports.setWorkflowTesterOverlayVisible = exports.setPlaybackLockDebugOverlayVisible = exports.setMicPreset = exports.getMicPreset = exports.setAudioConfig = exports.getAudioConfig = exports.setLoggerEnabled = exports.getLoggerEnabled = exports.setAssistantPlaybackMuted = exports.getAssistantPlaybackMuted = exports.setIsMuted = exports.getIsMuted = exports.setHasInteracted = exports.getHasInteracted = exports.setSessionId = exports.getSessionId = exports.getWidgetProfileUsername = exports.getUserUUID = exports.isLocalStorageAvailable = void 0;
+exports.emitStorageWrite = emitStorageWrite;
+exports.safeReadLocal = safeReadLocal;
+exports.safeWriteLocal = safeWriteLocal;
+exports.safeRemoveLocal = safeRemoveLocal;
+exports.writeMirroredLocal = writeMirroredLocal;
+exports.resolveWidgetEndUserId = resolveWidgetEndUserId;
+var logger_1 = __importDefault(__webpack_require__(/*! ./logger */ 628));
+var guideaiMirroredStorageKeys_1 = __webpack_require__(/*! ./guideaiMirroredStorageKeys */ 485);
+/**
+ * Centralized localStorage helper
+ * Tracks all localStorage keys used in the application
+ */
+var STORAGE_KEYS = guideaiMirroredStorageKeys_1.GUIDEAI_STORAGE_KEYS;
+exports.STORAGE_KEYS = STORAGE_KEYS;
+/**
+ * Emit a custom event when localStorage is written, so the Chrome extension
+ * content script can mirror writes from the isolated GuideAI component.
+ * Exported for bespoke flows (for example conversation save + quota handling).
+ */
+function emitStorageWrite(key, value) {
+    if (typeof window === 'undefined')
+        return;
+    try {
+        window.dispatchEvent(new CustomEvent('guideai_storage_write', { detail: { key: key, value: value } }));
+    }
+    catch (error) {
+        logger_1.default.warn('LocalStorageHelper', 'Failed to emit storage write event', error);
+    }
+}
+/**
+ * Check if localStorage is available
+ */
+var isLocalStorageAvailable = function () {
+    try {
+        if (typeof window === 'undefined')
+            return false;
+        var testKey = '__storage_test__';
+        localStorage.setItem(testKey, testKey);
+        localStorage.removeItem(testKey);
+        return true;
+    }
+    catch (_e) {
+        return false;
+    }
+};
+exports.isLocalStorageAvailable = isLocalStorageAvailable;
+/**
+ * Return `localStorage.getItem(key)` or `null` if localStorage is unavailable / throws
+ * (SSR, private mode, quota errors). Prefer this over an ad-hoc `typeof localStorage` check.
+ */
+function safeReadLocal(key) {
+    if (typeof localStorage === 'undefined')
+        return null;
+    try {
+        return localStorage.getItem(key);
+    }
+    catch (_a) {
+        return null;
+    }
+}
+/**
+ * Best-effort `localStorage.setItem(key, value)`. Silently no-ops if localStorage is unavailable.
+ * Does NOT emit the `guideai_storage_write` event — use the typed setters in this file for keys
+ * the Chrome extension needs to mirror.
+ */
+function safeWriteLocal(key, value) {
+    if (typeof localStorage === 'undefined')
+        return;
+    try {
+        localStorage.setItem(key, value);
+    }
+    catch (_a) {
+        /* ignore */
+    }
+}
+/** Best-effort removeItem. No-ops if localStorage is unavailable. */
+function safeRemoveLocal(key) {
+    if (typeof localStorage === 'undefined')
+        return;
+    try {
+        localStorage.removeItem(key);
+    }
+    catch (_a) {
+        /* ignore */
+    }
+}
+/**
+ * setItem(key, value) if value is a string; removeItem(key) if value is null.
+ * Emits the guideai_storage_write event for the final state (value or '').
+ *
+ * Use for keys the Chrome extension mirrors. Callers that need emit-on-set-only
+ * can pass `{ emitOnClear: false }`.
+ */
+function writeMirroredLocal(key, value, options) {
+    if (options === void 0) { options = {}; }
+    var _a = options.emitOnClear, emitOnClear = _a === void 0 ? true : _a;
+    if (typeof localStorage === 'undefined')
+        return;
+    try {
+        if (value === null) {
+            localStorage.removeItem(key);
+            if (emitOnClear)
+                emitStorageWrite(key, '');
+        }
+        else {
+            localStorage.setItem(key, value);
+            emitStorageWrite(key, value);
+        }
+    }
+    catch (_b) {
+        /* ignore */
+    }
+}
+var getBooleanPref = function (key) { return safeReadLocal(key) === 'true'; };
+var setBooleanPref = function (key, value) {
+    writeMirroredLocal(key, value ? 'true' : null, { emitOnClear: false });
+};
+/**
+ * Generate a UUID v4
+ */
+var generateUUID = function () {
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+        var r = (Math.random() * 16) | 0;
+        var v = c === 'x' ? r : (r & 0x3) | 0x8;
+        return v.toString(16);
+    });
+};
+/**
+ * Get or create user UUID
+ * Creates a new UUID if one doesn't exist
+ */
+var getUserUUID = function () {
+    var existing = safeReadLocal(STORAGE_KEYS.USER_UUID);
+    if (existing)
+        return existing;
+    var uuid = generateUUID();
+    writeMirroredLocal(STORAGE_KEYS.USER_UUID, uuid);
+    return uuid;
+};
+exports.getUserUUID = getUserUUID;
+/** Trimmed profile username from localStorage, or null if unset / blank. */
+var getWidgetProfileUsername = function () {
+    var raw = safeReadLocal(STORAGE_KEYS.WIDGET_PROFILE_USERNAME);
+    var t = typeof raw === 'string' ? raw.trim() : '';
+    return t.length > 0 ? t : null;
+};
+exports.getWidgetProfileUsername = getWidgetProfileUsername;
+/**
+ * Canonical end-user id for widget HTTP payloads (`user` on `/initialize`, `userId`
+ * on `/widget/session`, `user` on logged messages): persisted **`guideAI_widgetProfileUsername`**
+ * when present in localStorage (hosts should set **`STORAGE_KEYS.WIDGET_PROFILE_USERNAME`** and emit
+ * **`guideai_storage_write`** for Chrome extension mirroring — see package README), otherwise the
+ * stable anonymous id from {@link getUserUUID}. Host **`getUserInfo`** (GuideAI prop) also persists here.
+ */
+function resolveWidgetEndUserId() {
+    var profile = (0, exports.getWidgetProfileUsername)();
+    if (profile)
+        return profile;
+    return (0, exports.getUserUUID)();
+}
+/**
+ * Get session ID (active OpenAI session)
+ */
+var getSessionId = function () { return safeReadLocal(STORAGE_KEYS.SESSION_ID); };
+exports.getSessionId = getSessionId;
+/**
+ * Set session ID
+ */
+var setSessionId = function (sessionId) {
+    var key = STORAGE_KEYS.SESSION_ID;
+    if (sessionId === null) {
+        safeRemoveLocal(key);
+    }
+    else {
+        safeWriteLocal(key, sessionId);
+    }
+};
+exports.setSessionId = setSessionId;
+/**
+ * Get has interacted flag
+ */
+var getHasInteracted = function () { return getBooleanPref(STORAGE_KEYS.HAS_INTERACTED); };
+exports.getHasInteracted = getHasInteracted;
+/**
+ * Set has interacted flag
+ */
+var setHasInteracted = function (value) {
+    setBooleanPref(STORAGE_KEYS.HAS_INTERACTED, value);
+};
+exports.setHasInteracted = setHasInteracted;
+/**
+ * Get is muted flag
+ */
+var getIsMuted = function () { return getBooleanPref(STORAGE_KEYS.IS_MUTED); };
+exports.getIsMuted = getIsMuted;
+/**
+ * Set is muted flag
+ */
+var setIsMuted = function (value) {
+    setBooleanPref(STORAGE_KEYS.IS_MUTED, value);
+};
+exports.setIsMuted = setIsMuted;
+var getAssistantPlaybackMuted = function () {
+    return getBooleanPref(STORAGE_KEYS.ASSISTANT_PLAYBACK_MUTED);
+};
+exports.getAssistantPlaybackMuted = getAssistantPlaybackMuted;
+var setAssistantPlaybackMuted = function (value) {
+    setBooleanPref(STORAGE_KEYS.ASSISTANT_PLAYBACK_MUTED, value);
+};
+exports.setAssistantPlaybackMuted = setAssistantPlaybackMuted;
+/**
+ * Get logger enabled flag (used by Logger to persist enable state)
+ */
+var getLoggerEnabled = function () { return getBooleanPref(STORAGE_KEYS.LOGGER_ENABLED); };
+exports.getLoggerEnabled = getLoggerEnabled;
+/**
+ * Set logger enabled flag
+ */
+var setLoggerEnabled = function (value) {
+    setBooleanPref(STORAGE_KEYS.LOGGER_ENABLED, value);
+};
+exports.setLoggerEnabled = setLoggerEnabled;
+/**
+ * Get stored audio configuration
+ */
+var getAudioConfig = function () {
+    var raw = safeReadLocal(STORAGE_KEYS.AUDIO_CONFIG);
+    if (!raw)
+        return null;
+    try {
+        return JSON.parse(raw);
+    }
+    catch (error) {
+        logger_1.default.error('LocalStorageHelper', 'Error parsing audio config:', error);
+        return null;
+    }
+};
+exports.getAudioConfig = getAudioConfig;
+/**
+ * Save audio configuration
+ */
+var setAudioConfig = function (value) {
+    writeMirroredLocal(STORAGE_KEYS.AUDIO_CONFIG, value ? JSON.stringify(value) : null, {
+        emitOnClear: false,
+    });
+};
+exports.setAudioConfig = setAudioConfig;
+/** Default mic preset is Precise. */
+var getMicPreset = function () {
+    var v = safeReadLocal(STORAGE_KEYS.MIC_PRESET);
+    return v === 'noisy' ? 'noisy' : 'precise';
+};
+exports.getMicPreset = getMicPreset;
+var setMicPreset = function (preset) {
+    writeMirroredLocal(STORAGE_KEYS.MIC_PRESET, preset === 'precise' ? null : preset);
+};
+exports.setMicPreset = setMicPreset;
+/** Mirrored flag for playback-lock debug tab (developer tools shell / extension). */
+var setPlaybackLockDebugOverlayVisible = function (visible) {
+    writeMirroredLocal(STORAGE_KEYS.PLAYBACK_LOCK_DEBUG_OVERLAY, visible ? 'true' : null);
+};
+exports.setPlaybackLockDebugOverlayVisible = setPlaybackLockDebugOverlayVisible;
+/** Mirrored flag for workflow tester tab (developer tools shell / extension). */
+var setWorkflowTesterOverlayVisible = function (visible) {
+    writeMirroredLocal(STORAGE_KEYS.WORKFLOW_TESTER_OVERLAY, visible ? 'true' : null);
+};
+exports.setWorkflowTesterOverlayVisible = setWorkflowTesterOverlayVisible;
+var getDevtoolsShellPosition = function () {
+    var raw = safeReadLocal(STORAGE_KEYS.DEVTOOLS_SHELL_POSITION);
+    if (!raw)
+        return null;
+    try {
+        var parsed = JSON.parse(raw);
+        if (typeof parsed.left !== 'number' || typeof parsed.top !== 'number')
+            return null;
+        if (!Number.isFinite(parsed.left) || !Number.isFinite(parsed.top))
+            return null;
+        return { left: parsed.left, top: parsed.top };
+    }
+    catch (_a) {
+        return null;
+    }
+};
+exports.getDevtoolsShellPosition = getDevtoolsShellPosition;
+var setDevtoolsShellPosition = function (position) {
+    writeMirroredLocal(STORAGE_KEYS.DEVTOOLS_SHELL_POSITION, JSON.stringify({ left: position.left, top: position.top }));
+};
+exports.setDevtoolsShellPosition = setDevtoolsShellPosition;
+var getLearnCapturePosition = function () {
+    var raw = safeReadLocal(STORAGE_KEYS.LEARN_CAPTURE_POSITION);
+    if (!raw)
+        return null;
+    try {
+        var parsed = JSON.parse(raw);
+        if (typeof parsed.left !== 'number' || typeof parsed.top !== 'number')
+            return null;
+        if (!Number.isFinite(parsed.left) || !Number.isFinite(parsed.top))
+            return null;
+        return { left: parsed.left, top: parsed.top };
+    }
+    catch (_a) {
+        return null;
+    }
+};
+exports.getLearnCapturePosition = getLearnCapturePosition;
+var setLearnCapturePosition = function (position) {
+    writeMirroredLocal(STORAGE_KEYS.LEARN_CAPTURE_POSITION, JSON.stringify({ left: position.left, top: position.top }));
+};
+exports.setLearnCapturePosition = setLearnCapturePosition;
+/** Default docked drawer width (px). */
+exports.TRANSCRIPT_DRAWER_WIDTH_PX = 420;
+exports.TRANSCRIPT_DRAWER_WIDTH_MIN_PX = 260;
+exports.TRANSCRIPT_DRAWER_WIDTH_MAX_PX = 720;
+var transcriptDrawerPrefStorageKey = function (widgetKey) {
+    return "guideAI_transcriptDrawerPref:".concat(widgetKey);
+};
+var transcriptDrawerWidthStorageKey = function (widgetKey) {
+    return "guideAI_transcriptDrawerWidth:".concat(widgetKey);
+};
+function clampDrawerWidthPx(n) {
+    if (!Number.isFinite(n))
+        return exports.TRANSCRIPT_DRAWER_WIDTH_PX;
+    return Math.round(Math.min(exports.TRANSCRIPT_DRAWER_WIDTH_MAX_PX, Math.max(exports.TRANSCRIPT_DRAWER_WIDTH_MIN_PX, n)));
+}
+/** User-resizable docked drawer width (px), per widget key. */
+var getTranscriptDrawerWidthPref = function (widgetKey) {
+    var raw = safeReadLocal(transcriptDrawerWidthStorageKey(widgetKey));
+    if (raw == null || raw === '')
+        return exports.TRANSCRIPT_DRAWER_WIDTH_PX;
+    return clampDrawerWidthPx(parseInt(raw, 10));
+};
+exports.getTranscriptDrawerWidthPref = getTranscriptDrawerWidthPref;
+var setTranscriptDrawerWidthPref = function (widgetKey, widthPx) {
+    var key = transcriptDrawerWidthStorageKey(widgetKey);
+    writeMirroredLocal(key, String(clampDrawerWidthPx(widthPx)));
+};
+exports.setTranscriptDrawerWidthPref = setTranscriptDrawerWidthPref;
+var transcriptFloatGeometryStorageKey = function (widgetKey) {
+    return "guideAI_transcriptFloatGeometry:".concat(widgetKey);
+};
+var FLOAT_WIDTH_MIN_PX = 240;
+var FLOAT_WIDTH_MAX_PX = 560;
+var FLOAT_CORE_H_MIN_PX = 180;
+var FLOAT_CORE_H_MAX_PX = 560;
+function clampFloatDimension(n, min, max) {
+    return Math.round(Math.min(max, Math.max(min, n)));
+}
+var getTranscriptFloatGeometryPref = function (widgetKey) {
+    var raw = safeReadLocal(transcriptFloatGeometryStorageKey(widgetKey));
+    if (!raw)
+        return null;
+    try {
+        var parsed = JSON.parse(raw);
+        var left = parsed.left, bottom = parsed.bottom, width = parsed.width, coreH = parsed.coreH;
+        if (typeof left !== 'number' ||
+            typeof bottom !== 'number' ||
+            typeof width !== 'number' ||
+            typeof coreH !== 'number' ||
+            !Number.isFinite(left) ||
+            !Number.isFinite(bottom) ||
+            !Number.isFinite(width) ||
+            !Number.isFinite(coreH)) {
+            return null;
+        }
+        return {
+            left: Math.round(left),
+            bottom: Math.round(bottom),
+            width: clampFloatDimension(width, FLOAT_WIDTH_MIN_PX, FLOAT_WIDTH_MAX_PX),
+            coreH: clampFloatDimension(coreH, FLOAT_CORE_H_MIN_PX, FLOAT_CORE_H_MAX_PX),
+        };
+    }
+    catch (_a) {
+        return null;
+    }
+};
+exports.getTranscriptFloatGeometryPref = getTranscriptFloatGeometryPref;
+var setTranscriptFloatGeometryPref = function (widgetKey, geometry) {
+    var key = transcriptFloatGeometryStorageKey(widgetKey);
+    writeMirroredLocal(key, JSON.stringify({
+        left: Math.round(geometry.left),
+        bottom: Math.round(geometry.bottom),
+        width: clampFloatDimension(geometry.width, FLOAT_WIDTH_MIN_PX, FLOAT_WIDTH_MAX_PX),
+        coreH: clampFloatDimension(geometry.coreH, FLOAT_CORE_H_MIN_PX, FLOAT_CORE_H_MAX_PX),
+    }));
+};
+exports.setTranscriptFloatGeometryPref = setTranscriptFloatGeometryPref;
+var clearTranscriptFloatGeometryPref = function (widgetKey) {
+    writeMirroredLocal(transcriptFloatGeometryStorageKey(widgetKey), null);
+};
+exports.clearTranscriptFloatGeometryPref = clearTranscriptFloatGeometryPref;
+/**
+ * Whether the user prefers the docked transcript panel when the transcript is visible (per widget key).
+ * Storage key remains `guideAI_transcriptDrawerPref:*` for backward compatibility.
+ */
+var getTranscriptPanelDockedPref = function (widgetKey) {
+    return safeReadLocal(transcriptDrawerPrefStorageKey(widgetKey)) === '1';
+};
+exports.getTranscriptPanelDockedPref = getTranscriptPanelDockedPref;
+var setTranscriptPanelDockedPref = function (widgetKey, docked) {
+    var key = transcriptDrawerPrefStorageKey(widgetKey);
+    writeMirroredLocal(key, docked ? '1' : '0');
+};
+exports.setTranscriptPanelDockedPref = setTranscriptPanelDockedPref;
+/**
+ * Last workspace slug the user selected in the in-widget transcript selector, scoped per
+ * conversation/widget key. Used to keep the selection sticky across page reloads. Cleared
+ * when the conversation ends (see `useConversationSession.endConversationSession`) so a
+ * brand-new thread falls back to the host-default workspace resolution.
+ *
+ * The persisted slug is only re-applied when it still appears in the freshly fetched
+ * workspace catalog; consumers must validate before using.
+ */
+var lastWorkspaceSlugStorageKey = function (widgetKey) { return "guideAI_lastWorkspaceSlug:".concat(widgetKey); };
+var getLastWorkspaceSlugPref = function (widgetKey) {
+    var raw = safeReadLocal(lastWorkspaceSlugStorageKey(widgetKey));
+    var trimmed = typeof raw === 'string' ? raw.trim() : '';
+    return trimmed.length > 0 ? trimmed : null;
+};
+exports.getLastWorkspaceSlugPref = getLastWorkspaceSlugPref;
+var setLastWorkspaceSlugPref = function (widgetKey, slug) {
+    var key = lastWorkspaceSlugStorageKey(widgetKey);
+    var trimmed = typeof slug === 'string' ? slug.trim() : '';
+    writeMirroredLocal(key, trimmed.length > 0 ? trimmed : null);
+};
+exports.setLastWorkspaceSlugPref = setLastWorkspaceSlugPref;
+var transcriptWorkflowStateStorageKey = function (conversationKey) {
+    return "guideAI_transcriptWorkflowState:".concat(conversationKey);
+};
+function readTranscriptWorkflowStateBlob(conversationKey) {
+    var raw = safeReadLocal(transcriptWorkflowStateStorageKey(conversationKey));
+    if (!raw)
+        return {};
+    try {
+        var parsed = JSON.parse(raw);
+        return parsed && typeof parsed === 'object' ? parsed : {};
+    }
+    catch (_a) {
+        return {};
+    }
+}
+var getTranscriptWorkflowWorkspaceState = function (conversationKey, workspaceSlug) {
+    var slug = workspaceSlug.trim();
+    if (!slug)
+        return null;
+    var blob = readTranscriptWorkflowStateBlob(conversationKey);
+    var row = blob[slug];
+    if (!row || typeof row !== 'object')
+        return null;
+    var id = typeof row.sessionWorkflowId === 'string' ? row.sessionWorkflowId.trim() : '';
+    return {
+        sessionWorkflowId: id.length > 0 ? id : null,
+        activeWorkflowTitle: typeof row.activeWorkflowTitle === 'string' ? row.activeWorkflowTitle : null,
+        workflowChecked: row.workflowChecked && typeof row.workflowChecked === 'object'
+            ? row.workflowChecked
+            : undefined,
+        rollupWorkflows: row.rollupWorkflows === true,
+    };
+};
+exports.getTranscriptWorkflowWorkspaceState = getTranscriptWorkflowWorkspaceState;
+var setTranscriptWorkflowWorkspaceState = function (conversationKey, workspaceSlug, state) {
+    var slug = workspaceSlug.trim();
+    if (!slug)
+        return;
+    var key = transcriptWorkflowStateStorageKey(conversationKey);
+    var blob = readTranscriptWorkflowStateBlob(conversationKey);
+    if (state == null) {
+        delete blob[slug];
+    }
+    else {
+        var id = typeof state.sessionWorkflowId === 'string' ? state.sessionWorkflowId.trim() : '';
+        blob[slug] = {
+            sessionWorkflowId: id.length > 0 ? id : null,
+            activeWorkflowTitle: typeof state.activeWorkflowTitle === 'string' ? state.activeWorkflowTitle : null,
+            workflowChecked: state.workflowChecked,
+            rollupWorkflows: state.rollupWorkflows === true,
+        };
+    }
+    var hasAny = Object.keys(blob).length > 0;
+    writeMirroredLocal(key, hasAny ? JSON.stringify(blob) : null);
+};
+exports.setTranscriptWorkflowWorkspaceState = setTranscriptWorkflowWorkspaceState;
+/** Cleared when the conversation ends (same scope as last workspace slug). */
+var clearTranscriptWorkflowPrefs = function (conversationKey) {
+    writeMirroredLocal(transcriptWorkflowStateStorageKey(conversationKey), null);
+};
+exports.clearTranscriptWorkflowPrefs = clearTranscriptWorkflowPrefs;
+
+
+/***/ },
+
+/***/ 628
+/*!*****************************!*\
+  !*** ./src/utils/logger.ts ***!
+  \*****************************/
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.LOGGER_UI_COMPONENTS = void 0;
+/**
+ * Standardized logging utility for GuideAI package
+ * Provides consistent formatting and development gating across all components
+ */
+var localStorageHelper_1 = __webpack_require__(/*! ./localStorageHelper */ 640);
+var LOG_LEVEL = 'log';
+var LEVELS = ['log', 'info', 'warn', 'error'];
+function shouldLog(requestedLevel) {
+    var currentIndex = LEVELS.indexOf(LOG_LEVEL);
+    var requestedIndex = LEVELS.indexOf(requestedLevel);
+    return requestedIndex >= currentIndex;
+}
+/** Ordered list for debug UI and default flag initialization. */
+exports.LOGGER_UI_COMPONENTS = [
+    'GuideAI',
+    'API',
+    'TranscriptBox',
+    'Onboarding',
+    'VisualContext',
+    'StaticContext',
+    'MessageStorage',
+    'DataChannel',
+    'ConversationManager',
+    'LocalStorageHelper',
+    'WebRTCConnection',
+    'ToolCall',
+];
+var ON_BY_DEFAULT = {
+    DataChannel: true,
+    LocalStorageHelper: true,
+    WebRTCConnection: true,
+};
+var logging_enabled = Object.fromEntries(exports.LOGGER_UI_COMPONENTS.map(function (k) { return [k, Boolean(ON_BY_DEFAULT[k])]; }));
+// Manual override flag for console-based logging control
+var manualLoggingEnabled = false;
+var Logger = /** @class */ (function () {
+    function Logger() {
+    }
+    Logger.formatMessage = function (component, action) {
+        return "[GuideAI:".concat(component, "] ").concat(action);
+    };
+    Logger.checkLoggingEnabled = function (component, requestedLevel) {
+        // Check manual override first, then fall back to development mode check
+        var isManuallyEnabled = manualLoggingEnabled && logging_enabled[component] && shouldLog(requestedLevel);
+        var isDevModeEnabled =  true &&
+            logging_enabled[component] &&
+            shouldLog(requestedLevel);
+        return isManuallyEnabled || isDevModeEnabled;
+    };
+    /**
+     * Initialize logger and attach to window for console access
+     * Call Logger.init() from browser console to enable logging.
+     * Restores persisted enabled state from localStorage if previously enabled.
+     */
+    Logger.init = function () {
+        if (typeof window !== 'undefined') {
+            var win = window;
+            if (!win.GuideAI)
+                win.GuideAI = {};
+            win.GuideAI.logger = Logger;
+            if ((0, localStorageHelper_1.getLoggerEnabled)()) {
+                manualLoggingEnabled = true;
+                console.log('[GuideAI Logger] Initialized with logging enabled (restored from previous session).');
+            }
+            else {
+                console.log('[GuideAI Logger] Initialized. Use GuideAI.logger.enable() to start logging.');
+            }
+        }
+    };
+    /**
+     * Enable logging from console, or for a specific component.
+     * Usage: GuideAI.logger.enable() or GuideAI.logger.enable('API')
+     */
+    Logger.enable = function (component) {
+        if (component !== undefined) {
+            manualLoggingEnabled = true;
+            logging_enabled[component] = true;
+            console.log("[GuideAI Logger] ".concat(component, " logging enabled"));
+        }
+        else {
+            manualLoggingEnabled = true;
+            (0, localStorageHelper_1.setLoggerEnabled)(true);
+            console.log('[GuideAI Logger] Logging enabled');
+        }
+    };
+    /**
+     * Disable logging from console, or for a specific component.
+     * Usage: GuideAI.logger.disable() or GuideAI.logger.disable('API')
+     */
+    Logger.disable = function (component) {
+        if (component !== undefined) {
+            logging_enabled[component] = false;
+            console.log("[GuideAI Logger] ".concat(component, " logging disabled"));
+        }
+        else {
+            manualLoggingEnabled = false;
+            (0, localStorageHelper_1.setLoggerEnabled)(false);
+            console.log('[GuideAI Logger] Logging disabled');
+        }
+    };
+    /**
+     * Enable or disable logging for a specific component
+     * Usage: GuideAI.logger.setComponentEnabled('API', true)
+     */
+    Logger.setComponentEnabled = function (component, enabled) {
+        logging_enabled[component] = enabled;
+        console.log("[GuideAI Logger] ".concat(component, " logging ").concat(enabled ? 'enabled' : 'disabled'));
+    };
+    /**
+     * Get current logging status
+     * Usage: GuideAI.logger.getStatus()
+     */
+    Logger.getStatus = function () {
+        return {
+            manualEnabled: manualLoggingEnabled,
+            components: __assign({}, logging_enabled),
+        };
+    };
+    /**
+     * Disable logging for all components
+     * Usage: GuideAI.logger.disableAllComponents()
+     */
+    Logger.disableAllComponents = function () {
+        exports.LOGGER_UI_COMPONENTS.forEach(function (component) {
+            logging_enabled[component] = false;
+        });
+        console.log('[GuideAI Logger] All components disabled');
+    };
+    /**
+     * Enable logging for all components
+     * Usage: GuideAI.logger.enableAllComponents()
+     */
+    Logger.enableAllComponents = function () {
+        exports.LOGGER_UI_COMPONENTS.forEach(function (component) {
+            logging_enabled[component] = true;
+        });
+        console.log('[GuideAI Logger] All components enabled');
+    };
+    /**
+     * Standard info logging - only in development
+     */
+    Logger.info = function (component, action, data) {
+        if (this.checkLoggingEnabled(component, 'info')) {
+            if (data !== undefined) {
+                console.info(this.formatMessage(component, action), data);
+            }
+            else {
+                console.info(this.formatMessage(component, action));
+            }
+        }
+    };
+    /**
+     * Standard info logging - only in development
+     */
+    Logger.log = function (component, action, data) {
+        if (this.checkLoggingEnabled(component, 'log')) {
+            if (data !== undefined) {
+                console.log(this.formatMessage(component, action), data);
+            }
+            else {
+                console.log(this.formatMessage(component, action));
+            }
+        }
+    };
+    /**
+     * Warning logging - always shown
+     */
+    Logger.warn = function (component, action, data) {
+        if (this.checkLoggingEnabled(component, 'warn')) {
+            if (data !== undefined) {
+                console.warn(this.formatMessage(component, action), data);
+            }
+            else {
+                console.warn(this.formatMessage(component, action));
+            }
+        }
+    };
+    /**
+     * Error logging - always shown
+     */
+    Logger.error = function (component, action, error) {
+        if (this.checkLoggingEnabled(component, 'error')) {
+            if (error !== undefined) {
+                console.error(this.formatMessage(component, action), error);
+            }
+            else {
+                console.error(this.formatMessage(component, action));
+            }
+        }
+    };
+    /**
+     * API call logging with method and endpoint
+     */
+    Logger.apiCall = function (method, endpoint, data) {
+        if (this.checkLoggingEnabled('API', 'log')) {
+            var action = "".concat(method, " ").concat(endpoint);
+            if (data !== undefined) {
+                console.log(this.formatMessage('API', action), data);
+            }
+            else {
+                console.log(this.formatMessage('API', action));
+            }
+        }
+    };
+    /**
+     * API response logging
+     */
+    Logger.apiResponse = function (method, endpoint, success, data) {
+        if (this.checkLoggingEnabled('API', 'log')) {
+            var status_1 = success ? '✅ SUCCESS' : '❌ FAILED';
+            var action = "".concat(method, " ").concat(endpoint, " ").concat(status_1);
+            if (data !== undefined) {
+                console.log(this.formatMessage('API', action), data);
+            }
+            else {
+                console.log(this.formatMessage('API', action));
+            }
+        }
+    };
+    /**
+     * Conversation flow tracking
+     */
+    Logger.conversation = function (action, data) {
+        if (this.checkLoggingEnabled('GuideAI', 'log')) {
+            if (data !== undefined) {
+                console.log(this.formatMessage('GuideAI', action), data);
+            }
+            else {
+                console.log(this.formatMessage('GuideAI', action));
+            }
+        }
+    };
+    return Logger;
+}());
+exports["default"] = Logger;
+
+
+/***/ }
+
+/******/ 	});
+/************************************************************************/
+/******/ 	// The module cache
+/******/ 	var __webpack_module_cache__ = {};
+/******/ 	
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/ 		// Check if module is in cache
+/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
+/******/ 		if (cachedModule !== undefined) {
+/******/ 			return cachedModule.exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = __webpack_module_cache__[moduleId] = {
+/******/ 			// no module.id needed
+/******/ 			// no module.loaded needed
+/******/ 			exports: {}
+/******/ 		};
+/******/ 	
+/******/ 		// Execute the module function
+/******/ 		if (!(moduleId in __webpack_modules__)) {
+/******/ 			delete __webpack_module_cache__[moduleId];
+/******/ 			var e = new Error("Cannot find module '" + moduleId + "'");
+/******/ 			e.code = 'MODULE_NOT_FOUND';
+/******/ 			throw e;
+/******/ 		}
+/******/ 		__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/ 	
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/ 	
+/************************************************************************/
+/******/ 	
+/******/ 	// startup
+/******/ 	// Load entry module and return exports
+/******/ 	// This entry module is referenced by other modules so it can't be inlined
+/******/ 	var __webpack_exports__ = __webpack_require__(737);
+/******/ 	
+/******/ })()
+;
+//# sourceMappingURL=playwrightBuddyHarness.js.map