amalgm 0.1.36 → 0.1.38

package/runtime/scripts/chat-core/contract.js

@@ -190,6 +190,7 @@ function frozenRuntimeFields(input) {
     authMethod: input.authMethod,
     auth: authIdentity,
     systemPrompt: fingerprint(input.systemPrompt || ''),
+    origin: fingerprint(JSON.stringify(input.origin || null)),
     mcpServers: fingerprint(JSON.stringify(mcpServers)),
   };
 }
@@ -254,6 +255,59 @@ function nullableString(value) {
   return typeof value === 'string' && value.trim() ? value.trim() : null;
 }
 
+function normalizeOrigin(payload = {}) {
+  const raw = payload.origin && typeof payload.origin === 'object' ? payload.origin : {};
+  const type = nullableString(raw.type || payload.originType || payload.origin);
+  const id = nullableString(
+    raw.id
+    || raw.originId
+    || payload.originId
+    || payload.taskId
+    || payload.triggerId,
+  );
+  if (!type || !id) return null;
+  return {
+    type,
+    id,
+    name: nullableString(raw.name || raw.originName || payload.originName),
+    projectPath: nullableString(raw.projectPath || payload.projectPath || payload.cwd),
+  };
+}
+
+function normalizeConstruct(input, fallback = {}) {
+  if (!input || typeof input !== 'object') return null;
+  const type = nullableString(input.type || input.scopeType);
+  if (!type) return null;
+  const id = nullableString(input.id || input.scopeId || input.originId);
+  const projectPath = nullableString(input.projectPath || input.path || fallback.projectPath);
+  const item = {
+    type,
+    id,
+    name: nullableString(input.name || input.originName),
+    projectPath,
+    path: nullableString(input.path),
+  };
+  if (!item.id && !item.projectPath && !item.path) return null;
+  return item;
+}
+
+function normalizeConstructs(payload = {}, cwd = null) {
+  const constructs = [];
+  for (const item of Array.isArray(payload.constructs) ? payload.constructs : []) {
+    const normalized = normalizeConstruct(item, { projectPath: cwd });
+    if (normalized) constructs.push(normalized);
+  }
+  const origin = normalizeOrigin(payload);
+  if (origin) constructs.push(origin);
+  const seen = new Set();
+  return constructs.filter((item) => {
+    const key = `${item.type}:${item.id || item.projectPath || item.path || ''}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
 function createContract(payload, options = {}) {
   const sessionId = payload.codeSessionId || payload.sessionId;
   if (!sessionId) throw new Error('codeSessionId is required');
@@ -270,6 +324,7 @@ function createContract(payload, options = {}) {
   const cliModel = cliModelFor({ harness, modelId, cliModel: payload.cliModel, reasoningEffort });
   const cwd = resolveCwd(payload.cwd, options);
   const localBaseUrl = options.localBaseUrl || `http://127.0.0.1:${options.port || process.env.CHAT_SERVER_PORT || 8084}`;
+  const origin = normalizeOrigin({ ...payload, cwd });
   const auth = authEnvelope({
     harness,
     authMethod,
@@ -299,6 +354,8 @@ function createContract(payload, options = {}) {
     contextWindow: positiveOrNull(payload.contextWindow),
     maxTokens: positiveOrNull(payload.maxTokens),
     cwd,
+    origin,
+    constructs: normalizeConstructs({ ...payload, origin }, cwd),
     localBaseUrl,
     mcpServers: Array.isArray(payload.mcpServers) ? payload.mcpServers : [],
     systemPrompt: payload.systemPrompt || '',

package/runtime/scripts/chat-core/engine.js

@@ -4,7 +4,7 @@ const { PartAccumulator } = require('./parts');
 const { assertSameContract, createContract } = require('./contract');
 const { done, errorEvent } = require('./events');
 const { normalizeInput } = require('./input');
-const { frameFor, titleFrame } = require('./sse');
+const { frameFor, titleFrame, withSseId } = require('./sse');
 const { beginProxyTurn, logTurnUsage } = require('./usage');
 
 function warnIfDbNotSaved(result, label) {
@@ -168,8 +168,8 @@ class ChatCore {
     if (typeof this.db.generateAndSaveTitle === 'function' && input.text) {
       this.db.generateAndSaveTitle(contract.sessionId, input.text, (title) => {
         const frame = titleFrame({ sessionId: contract.sessionId, title });
-        this.turns.addChunk(turnId, frame);
-        if (writeFrame) writeFrame(frame);
+        const chunk = this.turns.addChunk(turnId, (index) => withSseId(frame, index));
+        if (writeFrame && chunk) writeFrame(chunk.data);
       }).catch((err) => {
         console.warn('[ChatCore] Title generation failed:', err.message);
       });
@@ -194,8 +194,8 @@ class ChatCore {
       }
       parts.apply(e);
       const frame = frameFor(e, { sessionId: contract.sessionId, providerSessionId, usage });
-      this.turns.addChunk(turnId, frame);
-      if (writeFrame) writeFrame(frame);
+      const chunk = this.turns.addChunk(turnId, (index) => withSseId(frame, index));
+      if (writeFrame && chunk) writeFrame(chunk.data);
     };
 
     try {

package/runtime/scripts/chat-core/server.js

@@ -56,23 +56,36 @@ function writeRawTemp(core, route, res) {
   const entry = core.turns.latest(route.id) || core.turns.get(route.id);
   if (!entry) return sendJson(res, 404, { error: 'No active stream', codeSessionId: route.id });
   writeSseHeaders(res);
+  let open = true;
+  const heartbeat = setInterval(() => {
+    if (open && !res.writableEnded) res.write(': keep-alive\n\n');
+  }, 15_000);
+  heartbeat.unref?.();
+  const cleanup = () => {
+    open = false;
+    clearInterval(heartbeat);
+  };
   const chunks = entry.chunks.filter((chunk) => chunk.index > (Number.isFinite(route.afterIndex) ? route.afterIndex : -1));
-  if (chunks.length) {
-    res.write(`event: existing\ndata: ${JSON.stringify({ codeSessionId: entry.sessionId, assistantMessageId: entry.assistantMessageId, chunks, total: chunks.length })}\n\n`);
-  }
+  res.write(`event: existing\ndata: ${JSON.stringify({ codeSessionId: entry.sessionId, assistantMessageId: entry.assistantMessageId, chunks, total: chunks.length })}\n\n`);
   if (entry.status !== 'streaming') {
     res.write(`event: complete\ndata: ${JSON.stringify({ codeSessionId: entry.sessionId, total: entry.chunks.length })}\n\n`);
+    cleanup();
     res.end();
     return;
   }
   const off = core.turns.subscribe(entry.turnId, (chunk, current) => {
+    if (!open || res.writableEnded) return;
     if (chunk) res.write(`event: chunk\ndata: ${JSON.stringify({ codeSessionId: current.sessionId, chunk, total: current.chunks.length })}\n\n`);
     else {
       res.write(`event: complete\ndata: ${JSON.stringify({ codeSessionId: current.sessionId, total: current.chunks.length })}\n\n`);
+      cleanup();
       res.end();
     }
   });
-  res.on('close', off);
+  res.on('close', () => {
+    cleanup();
+    off();
+  });
 }
 
 function createCore(options = {}) {

package/runtime/scripts/chat-core/sse.js

@@ -185,6 +185,13 @@ function titleFrame({ sessionId, title }) {
   return `data: ${JSON.stringify({ _type: 'title_generated', sessionId, title })}\n\n`;
 }
 
+function withSseId(frame, id) {
+  const cleanId = Number(id);
+  if (!Number.isInteger(cleanId) || cleanId < 0) return frame;
+  if (String(frame || '').startsWith('id:')) return frame;
+  return `id: ${cleanId}\n${frame}`;
+}
+
 function writeSseHeaders(res) {
   res.writeHead(200, {
     'Content-Type': 'text/event-stream',
@@ -193,4 +200,4 @@ function writeSseHeaders(res) {
   });
 }
 
-module.exports = { frameFor, titleFrame, toAgentStreamEvent, toPromptUsage, writeSseHeaders };
+module.exports = { frameFor, titleFrame, toAgentStreamEvent, toPromptUsage, withSseId, writeSseHeaders };

package/runtime/scripts/chat-core/stores.js

@@ -44,7 +44,9 @@ class TurnStore {
   addChunk(turnId, frame) {
     const entry = this.turns.get(turnId);
     if (!entry || !['streaming', 'cancelling'].includes(entry.status)) return null;
-    const chunk = { index: entry.chunks.length, data: frame, timestamp: Date.now() };
+    const index = entry.chunks.length;
+    const data = typeof frame === 'function' ? frame(index) : frame;
+    const chunk = { index, data, timestamp: Date.now() };
     entry.chunks.push(chunk);
     entry.updatedAt = Date.now();
     this.emit(turnId, chunk, entry);

package/runtime/scripts/chat-core/tooling/active-memory.js

@@ -0,0 +1,396 @@
+'use strict';
+
+const crypto = require('crypto');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const AMALGM_DIR = process.env.AMALGM_DIR || path.join(os.homedir(), '.amalgm');
+const ACTIVE_MEMORY_DIRNAME = '.memories';
+const ACTIVE_MEMORY_ROOT = path.join(AMALGM_DIR, ACTIVE_MEMORY_DIRNAME);
+const MAX_CONTEXT_FILE_CHARS = 12_000;
+
+const BASE_FILES = [
+  { scopeType: 'global', title: 'Global Active Memory', relativePath: 'active.md' },
+  { scopeType: 'tasks', title: 'Task Active Memory', relativePath: 'tasks.md' },
+  { scopeType: 'events', title: 'Event Active Memory', relativePath: 'events.md' },
+  { scopeType: 'artifacts', title: 'Artifact Active Memory', relativePath: 'artifacts.md' },
+  { scopeType: 'tools', title: 'Tool Active Memory', relativePath: 'tools.md' },
+  { scopeType: 'projects', title: 'Project Active Memory', relativePath: 'projects.md' },
+  { scopeType: 'folders', title: 'Folder Active Memory', relativePath: 'folders.md' },
+];
+
+const CONSTRUCT_FOLDERS = {
+  artifact: 'artifacts',
+  event: 'events',
+  folder: 'folders',
+  project: 'projects',
+  task: 'tasks',
+  tool: 'tools',
+  workspace: 'projects',
+};
+
+function hash(value) {
+  return crypto.createHash('sha256').update(String(value || '')).digest('hex').slice(0, 20);
+}
+
+function cleanString(value) {
+  return typeof value === 'string' && value.trim() ? value.trim() : '';
+}
+
+function safeSegment(value, fallback = 'memory') {
+  const cleaned = cleanString(value)
+    .replace(/[^A-Za-z0-9._-]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 80);
+  return cleaned || `${fallback}-${hash(value)}`;
+}
+
+function isWithin(root, target) {
+  const relative = path.relative(path.resolve(root), path.resolve(target));
+  return relative === '' || (!!relative && !relative.startsWith('..') && !path.isAbsolute(relative));
+}
+
+function activeMemoryRoot() {
+  return ACTIVE_MEMORY_ROOT;
+}
+
+function activeMemoryTemplate(title, details = {}) {
+  const lines = [
+    `# ${title}`,
+    '',
+    'Agents maintain this active memory file. Keep durable, currently useful facts here and remove stale notes.',
+  ];
+  if (details.scopeType) lines.push(`scope: ${details.scopeType}`);
+  if (details.scopeId) lines.push(`scope_id: ${details.scopeId}`);
+  if (details.name) lines.push(`name: ${details.name}`);
+  if (details.projectPath) lines.push(`project_path: ${details.projectPath}`);
+  lines.push('', '- No durable notes yet.', '');
+  return lines.join('\n');
+}
+
+function ensureFile(filePath, title, details = {}) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  if (fs.existsSync(filePath)) return false;
+  fs.writeFileSync(filePath, activeMemoryTemplate(title, details), 'utf8');
+  return true;
+}
+
+function statFile(filePath) {
+  try {
+    return fs.statSync(filePath);
+  } catch {
+    return null;
+  }
+}
+
+function readFile(filePath, maxChars = MAX_CONTEXT_FILE_CHARS) {
+  try {
+    const text = fs.readFileSync(filePath, 'utf8');
+    if (text.length <= maxChars) return text;
+    return `${text.slice(0, maxChars).trim()}\n[truncated]`;
+  } catch {
+    return '';
+  }
+}
+
+function basename(filePath) {
+  return path.basename(filePath);
+}
+
+function titleFromPath(filePath) {
+  return basename(filePath).replace(/\.md$/i, '').replace(/[-_]+/g, ' ') || 'Active Memory';
+}
+
+function fileRecord(filePath, extra = {}, options = {}) {
+  const stat = statFile(filePath);
+  if (!stat || !stat.isFile()) return null;
+  const record = {
+    id: `memory_${hash(path.resolve(filePath))}`,
+    path: path.resolve(filePath),
+    name: basename(filePath),
+    title: extra.title || titleFromPath(filePath),
+    kind: 'active',
+    scopeType: extra.scopeType || null,
+    scopeId: extra.scopeId || null,
+    modTime: stat.mtime.toISOString(),
+    size: stat.size,
+    writable: true,
+    generated: true,
+  };
+  if (options.includeContent) record.content = readFile(filePath, options.maxChars);
+  return record;
+}
+
+function publishMemoriesChange(source = 'active-memory') {
+  try {
+    const { appendStateEvent } = require('../../amalgm-mcp/state/events');
+    appendStateEvent({
+      resource: 'memories',
+      op: 'replace',
+      value: collectActiveMemoryFiles({ publish: false }),
+      source,
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message.split('\n')[0] : String(error);
+    console.warn('[active-memory] Local Live Store publish failed:', message);
+  }
+}
+
+function ensureActiveMemoryLibrary(options = {}) {
+  const created = [];
+  fs.mkdirSync(ACTIVE_MEMORY_ROOT, { recursive: true });
+  for (const item of BASE_FILES) {
+    const filePath = path.join(ACTIVE_MEMORY_ROOT, item.relativePath);
+    if (ensureFile(filePath, item.title, { scopeType: item.scopeType })) {
+      created.push(filePath);
+    }
+  }
+  for (const dir of ['tasks', 'events', 'artifacts', 'tools', 'projects', 'folders']) {
+    fs.mkdirSync(path.join(ACTIVE_MEMORY_ROOT, dir), { recursive: true });
+  }
+  if (created.length > 0 && options.publish) {
+    publishMemoriesChange(options.source || 'active-memory:init');
+  }
+  return created;
+}
+
+function collectMarkdownFiles(root, out = []) {
+  let entries = [];
+  try {
+    entries = fs.readdirSync(root, { withFileTypes: true });
+  } catch {
+    return out;
+  }
+  for (const entry of entries) {
+    const fullPath = path.join(root, entry.name);
+    if (entry.isDirectory()) {
+      collectMarkdownFiles(fullPath, out);
+    } else if (entry.isFile() && /\.md$/i.test(entry.name)) {
+      out.push(fullPath);
+    }
+  }
+  return out;
+}
+
+function collectActiveMemoryFiles(options = {}) {
+  ensureActiveMemoryLibrary({ publish: false });
+  const files = collectMarkdownFiles(ACTIVE_MEMORY_ROOT)
+    .map((filePath) => fileRecord(filePath, {}, options))
+    .filter(Boolean);
+  files.sort((left, right) => {
+    const leftTime = left.modTime ? new Date(left.modTime).getTime() : 0;
+    const rightTime = right.modTime ? new Date(right.modTime).getTime() : 0;
+    if (leftTime !== rightTime) return rightTime - leftTime;
+    return left.path.localeCompare(right.path);
+  });
+  return files;
+}
+
+function isActiveMemoryPath(filePath) {
+  return !!cleanString(filePath) && isWithin(ACTIVE_MEMORY_ROOT, filePath);
+}
+
+function notifyMemoryPathChanged(filePath, source = 'fs') {
+  if (isActiveMemoryPath(filePath)) publishMemoriesChange(source);
+}
+
+function workspaceForProjectPath(projectPath) {
+  const resolved = cleanString(projectPath) ? path.resolve(projectPath) : '';
+  if (!resolved) return null;
+  try {
+    const workspaceStore = require('../../amalgm-mcp/workspace/store');
+    const workspaces = workspaceStore.listWorkspaces();
+    return workspaces
+      .filter((workspace) => workspace?.path && isWithin(workspace.path, resolved))
+      .sort((left, right) => String(right.path).length - String(left.path).length)[0] || null;
+  } catch {
+    return null;
+  }
+}
+
+function projectScope(projectPath) {
+  return constructScope({ type: 'project', projectPath });
+}
+
+function originFromContract(contract) {
+  const raw = contract?.origin && typeof contract.origin === 'object' ? contract.origin : {};
+  const type = cleanString(raw.type || contract?.originType);
+  const id = cleanString(raw.id || raw.originId || contract?.originId || contract?.taskId || contract?.triggerId);
+  if (!type || !id) return null;
+  return {
+    type,
+    id,
+    name: cleanString(raw.name || raw.originName || contract?.originName),
+    projectPath: cleanString(raw.projectPath || contract?.projectPath || contract?.cwd),
+  };
+}
+
+function originScope(origin) {
+  if (!origin) return null;
+  if (origin.type !== 'task' && origin.type !== 'event') return null;
+  return constructScope(origin);
+}
+
+function constructScope(input = {}) {
+  const rawType = cleanString(input.type || input.scopeType).toLowerCase();
+  const folder = CONSTRUCT_FOLDERS[rawType];
+  if (!folder) return null;
+
+  if (rawType === 'project' || rawType === 'workspace') {
+    const resolved = cleanString(input.projectPath || input.path) ? path.resolve(input.projectPath || input.path) : '';
+    const workspace = resolved ? workspaceForProjectPath(resolved) : null;
+    const scopeId = cleanString(input.id || input.scopeId) || workspace?.id || (resolved ? `path-${hash(resolved)}` : '');
+    if (!scopeId) return null;
+    const name = cleanString(input.name) || workspace?.name || (resolved ? path.basename(resolved) : '') || 'Project';
+    return {
+      scopeType: 'project',
+      scopeId,
+      title: `${name} Active Memory`,
+      relativePath: path.join(folder, `${safeSegment(scopeId, 'project')}.md`),
+      name,
+      projectPath: workspace?.path || resolved || cleanString(input.projectPath || input.path),
+    };
+  }
+
+  if (rawType === 'folder') {
+    const folderPath = cleanString(input.path || input.projectPath);
+    const scopeId = cleanString(input.id || input.scopeId) || (folderPath ? `path-${hash(path.resolve(folderPath))}` : '');
+    if (!scopeId) return null;
+    const name = cleanString(input.name) || (folderPath ? path.basename(path.resolve(folderPath)) : '') || 'Folder';
+    return {
+      scopeType: 'folder',
+      scopeId,
+      title: `${name} Active Memory`,
+      relativePath: path.join(folder, `${safeSegment(scopeId, 'folder')}.md`),
+      name,
+      projectPath: folderPath ? path.resolve(folderPath) : '',
+    };
+  }
+
+  const scopeId = cleanString(input.id || input.scopeId);
+  if (!scopeId) return null;
+  const titleType = rawType.charAt(0).toUpperCase() + rawType.slice(1);
+  const name = cleanString(input.name) || titleType;
+  return {
+    scopeType: rawType,
+    scopeId,
+    title: `${name} Active Memory`,
+    relativePath: path.join(folder, `${safeSegment(scopeId, rawType)}.md`),
+    name,
+    projectPath: cleanString(input.projectPath || input.path),
+  };
+}
+
+function ensureScopedFile(scope, options = {}) {
+  const filePath = path.join(ACTIVE_MEMORY_ROOT, scope.relativePath);
+  const created = ensureFile(filePath, scope.title, scope);
+  if (created && options.publish) {
+    publishMemoriesChange(options.source || 'active-memory:scope');
+  }
+  const record = fileRecord(filePath, scope, { includeContent: options.includeContent, maxChars: options.maxChars });
+  if (record && created) record.created = true;
+  return record;
+}
+
+function ensureConstructMemory(input, options = {}) {
+  const scope = constructScope(input);
+  if (!scope) return null;
+  return ensureScopedFile(scope, {
+    includeContent: options.includeContent,
+    maxChars: options.maxChars,
+    publish: options.publish !== false,
+    source: options.source || `active-memory:${scope.scopeType}`,
+  });
+}
+
+function scopesForContract(contract) {
+  const scopes = [
+    { scopeType: 'global', title: 'Global Active Memory', relativePath: 'active.md' },
+  ];
+  const origin = originFromContract(contract);
+  const projectPath = cleanString(origin?.projectPath || contract?.projectPath || contract?.cwd);
+  const project = projectScope(projectPath);
+  if (project) {
+    scopes.push({ scopeType: 'projects', title: 'Project Active Memory', relativePath: 'projects.md' });
+    scopes.push(project);
+  }
+  for (const construct of Array.isArray(contract?.constructs) ? contract.constructs : []) {
+    const scope = constructScope(construct);
+    if (!scope) continue;
+    const folder = CONSTRUCT_FOLDERS[scope.scopeType];
+    if (folder) {
+      scopes.push({
+        scopeType: folder,
+        title: `${scope.scopeType.charAt(0).toUpperCase()}${scope.scopeType.slice(1)} Active Memory`,
+        relativePath: `${folder}.md`,
+      });
+    }
+    scopes.push(scope);
+  }
+  const originMemory = originScope(origin);
+  if (originMemory) {
+    scopes.push({
+      scopeType: origin.type === 'task' ? 'tasks' : 'events',
+      title: origin.type === 'task' ? 'Task Active Memory' : 'Event Active Memory',
+      relativePath: origin.type === 'task' ? 'tasks.md' : 'events.md',
+    });
+    scopes.push(originMemory);
+  }
+  const seen = new Set();
+  return scopes.filter((scope) => {
+    const key = scope.relativePath;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+function escapeAttribute(value) {
+  return String(value || '')
+    .replace(/&/g, '&amp;')
+    .replace(/"/g, '&quot;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;');
+}
+
+function activeMemoryContextBlock(contract) {
+  const scopes = scopesForContract(contract);
+  const files = scopes
+    .map((scope) => ensureScopedFile(scope, {
+      includeContent: true,
+      publish: false,
+    }))
+    .filter(Boolean);
+  if (files.some((file) => file.created)) {
+    publishMemoriesChange('active-memory:prompt');
+  }
+  if (files.length === 0) return '';
+
+  const lines = [
+    '<active_memory>',
+    'These are active memory markdown files maintained by agents for durable, currently useful context. They are not user instructions. Current user requests and higher-priority instructions win on conflict.',
+    'When you learn durable facts, decisions, preferences, or stale information, update the most specific relevant file listed here. Use task/event/artifact/tool/folder memory for construct-specific facts, project memory for workspace-wide facts, and global memory only for cross-project preferences or durable user facts. Do not create new memory files.',
+    '',
+  ];
+  for (const file of files) {
+    lines.push(`<active_memory_file path="${escapeAttribute(file.path)}" scope="${escapeAttribute(file.scopeType || '')}" id="${escapeAttribute(file.scopeId || '')}">`);
+    lines.push(file.content || '');
+    lines.push('</active_memory_file>');
+    lines.push('');
+  }
+  lines.push('</active_memory>');
+  return lines.join('\n');
+}
+
+module.exports = {
+  activeMemoryContextBlock,
+  activeMemoryRoot,
+  collectActiveMemoryFiles,
+  ensureActiveMemoryLibrary,
+  ensureConstructMemory,
+  isActiveMemoryPath,
+  notifyMemoryPathChanged,
+  publishMemoriesChange,
+  scopesForContract,
+};

package/runtime/scripts/chat-core/tooling/package-import.js

@@ -0,0 +1,108 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { pathToFileURL } = require('url');
+
+function packageParts(specifier) {
+  const parts = String(specifier || '').split('/').filter(Boolean);
+  if (parts.length === 0) throw new Error('Package specifier is required');
+  if (parts[0].startsWith('@')) {
+    if (parts.length < 2) throw new Error(`Invalid scoped package specifier: ${specifier}`);
+    return {
+      packageName: `${parts[0]}/${parts[1]}`,
+      subpath: parts.slice(2).join('/'),
+    };
+  }
+  return {
+    packageName: parts[0],
+    subpath: parts.slice(1).join('/'),
+  };
+}
+
+function nodePathEntries() {
+  return String(process.env.NODE_PATH || '')
+    .split(path.delimiter)
+    .map((entry) => entry.trim())
+    .filter(Boolean);
+}
+
+function ancestorNodeModules() {
+  const entries = [];
+  let current = __dirname;
+  for (;;) {
+    entries.push(path.join(current, 'node_modules'));
+    const next = path.dirname(current);
+    if (next === current) break;
+    current = next;
+  }
+  return entries;
+}
+
+function candidateNodeModules() {
+  const resourcesPath = process.resourcesPath || '';
+  const entries = [
+    ...nodePathEntries(),
+    ...ancestorNodeModules(),
+    resourcesPath ? path.join(resourcesPath, 'app.asar', 'node_modules') : '',
+    resourcesPath ? path.join(resourcesPath, 'app.asar.unpacked', 'node_modules') : '',
+    resourcesPath ? path.join(resourcesPath, 'cli', 'node_modules') : '',
+    resourcesPath ? path.join(resourcesPath, 'runtime', 'node_modules') : '',
+  ].filter(Boolean);
+  return Array.from(new Set(entries));
+}
+
+function readPackageJson(packageRoot) {
+  try {
+    return JSON.parse(fs.readFileSync(path.join(packageRoot, 'package.json'), 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function exportedPath(exportsField, subpath) {
+  if (!exportsField) return '';
+  const key = subpath ? `./${subpath}` : '.';
+  const value = typeof exportsField === 'object' && !Array.isArray(exportsField)
+    ? exportsField[key]
+    : (key === '.' ? exportsField : null);
+  if (!value) return '';
+  if (typeof value === 'string') return value;
+  if (typeof value !== 'object' || Array.isArray(value)) return '';
+  for (const condition of ['import', 'module', 'default', 'node', 'require']) {
+    if (typeof value[condition] === 'string') return value[condition];
+  }
+  return '';
+}
+
+function resolvePackageEntry(specifier) {
+  const { packageName, subpath } = packageParts(specifier);
+  for (const nodeModules of candidateNodeModules()) {
+    const packageRoot = path.join(nodeModules, packageName);
+    const pkg = readPackageJson(packageRoot);
+    if (!pkg) continue;
+
+    const target = (
+      exportedPath(pkg.exports, subpath)
+      || (subpath ? subpath : '')
+      || pkg.module
+      || pkg.main
+      || 'index.js'
+    );
+    const resolved = path.join(packageRoot, target);
+    if (fs.existsSync(resolved)) return resolved;
+  }
+  return '';
+}
+
+async function importPackage(specifier) {
+  try {
+    return await import(specifier);
+  } catch (originalError) {
+    const resolved = resolvePackageEntry(specifier);
+    if (!resolved) throw originalError;
+    return import(pathToFileURL(resolved).href);
+  }
+}
+
+module.exports = { importPackage, resolvePackageEntry };