salmon-loop 0.2.3

package/dist/core/session/token-tracker.js

@@ -0,0 +1,82 @@
+import path from 'path';
+import { FileAdapter } from '../adapters/fs/index.js';
+import { logIgnoredError } from '../observability/ignored-error.js';
+/**
+ * Token usage tracker for chat sessions.
+ * Extracts and accumulates token statistics from LLM execution results.
+ */
+export class TokenTracker {
+    static fileAdapter = new FileAdapter();
+    /**
+     * Extract token usage from LoopResult
+     * Strategies (in order of priority):
+     * 1. Parse from result metadata (if available)
+     * 2. Estimate based on content length (fallback)
+     */
+    static async extractFromResult(result) {
+        if (result.usage)
+            return result.usage;
+        if (!result.auditPath)
+            return null;
+        try {
+            const auditRaw = await this.fileAdapter.readFile(result.auditPath, 'utf8');
+            const audit = JSON.parse(auditRaw);
+            const eventsRef = audit?.context?.eventsRef;
+            if (!eventsRef || typeof eventsRef.path !== 'string')
+                return null;
+            const eventsPath = path.isAbsolute(eventsRef.path)
+                ? eventsRef.path
+                : path.join(path.dirname(result.auditPath), eventsRef.path);
+            const eventsRaw = await this.fileAdapter.readFile(eventsPath, 'utf8');
+            const events = eventsRaw
+                .split('\n')
+                .filter((line) => line.trim().length > 0)
+                .map((line) => JSON.parse(line));
+            let inputTokens = 0;
+            let outputTokens = 0;
+            for (const event of events) {
+                if (!event || typeof event !== 'object')
+                    continue;
+                if (event.action !== 'llm.usage')
+                    continue;
+                const details = event.details;
+                if (!details || typeof details !== 'object')
+                    continue;
+                const promptTokens = details.promptTokens;
+                const completionTokens = details.completionTokens;
+                if (typeof promptTokens === 'number' && Number.isFinite(promptTokens)) {
+                    inputTokens += promptTokens;
+                }
+                if (typeof completionTokens === 'number' && Number.isFinite(completionTokens)) {
+                    outputTokens += completionTokens;
+                }
+            }
+            if (inputTokens === 0 && outputTokens === 0)
+                return null;
+            return {
+                inputTokens,
+                outputTokens,
+                totalTokens: inputTokens + outputTokens,
+            };
+        }
+        catch (error) {
+            logIgnoredError(`[TokenTracker] Failed to extract usage from ${result.auditPath}`, error);
+            return null;
+        }
+    }
+    /**
+     * Accumulate tokens into session metadata
+     */
+    static accumulate(session, usage) {
+        session.meta.totalTokens.input += usage.inputTokens;
+        session.meta.totalTokens.output += usage.outputTokens;
+    }
+    /**
+     * Estimate token count based on text length
+     * Rough approximation: 1 token ≈ 4 characters (for English text)
+     */
+    static estimateTokens(text) {
+        return Math.ceil(text.length / 4);
+    }
+}
+//# sourceMappingURL=token-tracker.js.map

package/dist/core/session/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/core/skills/bridge.js

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+import { MicroTaskRunner } from './runtime/MicroTaskRunner.js';
+/**
+ * Bridges a Skill into a ToolSpec compatible with the standard tool registry.
+ */
+export function skillToToolSpec(skill) {
+    return {
+        name: skill.id,
+        source: 'plugin',
+        intent: 'AGENT',
+        description: skill.metadata.description,
+        riskLevel: 'medium',
+        sideEffects: ['process', 'fs_read'],
+        concurrency: 'serial_only',
+        allowedPhases: ['PLAN', 'APPLY'],
+        inputSchema: z.object({
+            args: z.string().optional().describe('Arguments to pass to the skill'),
+        }),
+        outputSchema: z.object({
+            prompt: z.string(),
+            status: z.string(),
+        }),
+        executor: async (input, ctx) => {
+            const runner = new MicroTaskRunner(skill);
+            const result = await runner.execute({ args: input.args || '' }, ctx);
+            return {
+                prompt: result.injectedPrompt,
+                status: result.status,
+            };
+        },
+    };
+}
+//# sourceMappingURL=bridge.js.map

package/dist/core/skills/index.js

@@ -0,0 +1,8 @@
+export * from './types.js';
+export * from './loader.js';
+export * from './parser.js';
+export * from './strategy.js';
+export * from './bridge.js';
+export { MicroTaskRunner } from './runtime/MicroTaskRunner.js';
+export * from './runtime/SkillRunner.js';
+//# sourceMappingURL=index.js.map

package/dist/core/skills/loader.js

@@ -0,0 +1,80 @@
+import os from 'node:os';
+import path from 'node:path';
+import { syncFs as fs } from '../adapters/fs/node-fs.js';
+import { getLogger } from '../observability/logger.js';
+import { SkillParser } from './parser.js';
+export class SkillLoader {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async initialize() {
+        const inventory = [];
+        const seen = new Map();
+        for (const target of this.buildSearchPaths()) {
+            if (!fs.existsSync(target.path))
+                continue;
+            const entries = fs.readdirSync(target.path, { withFileTypes: true });
+            for (const entry of entries) {
+                let skillFile = null;
+                if (entry.isDirectory()) {
+                    skillFile = path.join(target.path, entry.name, 'SKILL.md');
+                }
+                else if (entry.name.endsWith('.md')) {
+                    skillFile = path.join(target.path, entry.name);
+                }
+                if (!skillFile || !fs.existsSync(skillFile))
+                    continue;
+                try {
+                    const content = fs.readFileSync(skillFile, 'utf-8');
+                    const skill = SkillParser.parse(content, skillFile);
+                    if (seen.has(skill.id)) {
+                        getLogger().warn(`Duplicate skill ${skill.id} found in ${skillFile}; already loaded from ${seen.get(skill.id)}`);
+                        continue;
+                    }
+                    seen.set(skill.id, `${target.label}:${skillFile}`);
+                    inventory.push(skill);
+                }
+                catch (err) {
+                    getLogger().error(`Failed to load skill at ${skillFile}: ${err instanceof Error ? err.message : String(err)}`);
+                }
+            }
+        }
+        return inventory;
+    }
+    buildSearchPaths() {
+        const paths = [];
+        const extra = this.options.extraPaths ?? [];
+        for (const extraPath of extra) {
+            paths.push({ path: extraPath, label: `config:${extraPath}` });
+        }
+        paths.push({
+            path: path.join(this.options.repoRoot, '.salmonloop', 'skills'),
+            label: 'repo:.salmonloop/skills',
+        });
+        paths.push({
+            path: path.join(os.homedir(), '.salmonloop', 'skills'),
+            label: 'user:~/.salmonloop/skills',
+        });
+        if (this.options.useDefaults ?? true) {
+            paths.push({
+                path: path.join(os.homedir(), '.claude', 'skills'),
+                label: 'compat:~/.claude/skills',
+            });
+            paths.push({
+                path: path.join(this.options.repoRoot, '.claude', 'skills'),
+                label: 'compat:.claude/skills',
+            });
+        }
+        const deduped = [];
+        const seen = new Set();
+        for (const entry of paths) {
+            if (seen.has(entry.path))
+                continue;
+            seen.add(entry.path);
+            deduped.push(entry);
+        }
+        return deduped;
+    }
+}
+//# sourceMappingURL=loader.js.map

package/dist/core/skills/parser.js

@@ -0,0 +1,66 @@
+import { getLogger } from '../observability/logger.js';
+export class SkillParser {
+    static parse(content, filePath) {
+        // COMPLIANCE: Lightweight parsing instead of heavy gray-matter
+        const yamlRegex = /^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/;
+        const match = content.match(yamlRegex);
+        if (!match) {
+            getLogger().error(`Failed to parse skill at ${filePath}: Missing frontmatter`);
+            return {
+                id: filePath,
+                path: filePath,
+                metadata: {},
+                rawContent: content,
+                instructions: content.trim(),
+            };
+        }
+        const yamlRaw = match[1];
+        const instructions = match[2];
+        const data = {};
+        // Simple key-value parser for basic frontmatter
+        yamlRaw.split('\n').forEach((line) => {
+            const [key, ...value] = line.split(':');
+            if (key && value) {
+                data[key.trim()] = value.join(':').trim();
+            }
+        });
+        return {
+            id: data.name || filePath,
+            path: filePath,
+            metadata: data,
+            rawContent: content,
+            instructions: instructions.trim(),
+        };
+    }
+    static substituteVariables(template, args) {
+        let result = template;
+        // Sort keys by length descending to prevent shorter keys from replacing parts of longer keys
+        const sortedKeys = Object.keys(args).sort((a, b) => b.length - a.length);
+        // Track original content to prevent infinite recursion if a value contains its own key
+        // We use a single pass approach by replacing markers
+        const markers = new Map();
+        let processedTemplate = template;
+        for (let i = 0; i < sortedKeys.length; i++) {
+            const key = sortedKeys[i];
+            const value = args[key];
+            const escapedKey = key.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            const marker = `__SKILL_VAR_${i}__`;
+            const regex = new RegExp(`\\$${escapedKey}\\b|\\$\\{${escapedKey}\\}`, 'g');
+            processedTemplate = processedTemplate.replace(regex, marker);
+            markers.set(marker, value);
+        }
+        // Second pass: Replace markers with actual values to ensure no recursion
+        result = processedTemplate;
+        for (const [marker, value] of markers.entries()) {
+            result = result.replace(new RegExp(marker, 'g'), () => value);
+        }
+        return result;
+    }
+    static extractCommands(instructions) {
+        // Matches !sh command or !command
+        const commandRegex = /^!(?:sh\s+)?(.*)$/gm;
+        const matches = instructions.matchAll(commandRegex);
+        return Array.from(matches, (m) => m[1].trim()).filter((cmd) => cmd.length > 0);
+    }
+}
+//# sourceMappingURL=parser.js.map

package/dist/core/skills/runtime/MicroTaskRunner.js

@@ -0,0 +1,102 @@
+import { execa } from 'execa';
+import { text } from '../../../locales/index.js';
+import { DecisionEngine, PlanBuilder } from '../../grizzco/dsl/DecisionEngine.js';
+import { getPlatformShellInvocation } from '../../utils/platform-shell.js';
+import { SkillParser } from '../parser.js';
+import { SkillStrategyDSL } from '../strategy.js';
+/**
+ * MicroTaskRunner manages the execution loop of a single skill.
+ * COMPLIANCE: DSL-Spec-V3
+ * - Computation Layer: Handles variable substitution, command extraction, and prompt assembly.
+ * - Action Layer: Executes Shell commands and final Tool injection.
+ */
+export class MicroTaskRunner {
+    skill;
+    constructor(skill) {
+        this.skill = skill;
+    }
+    async execute(inputs, ctx) {
+        const skill = this.skill;
+        // 1. Computation (C): Pre-calculate all dynamic dependency keys
+        const rawCommands = SkillParser.extractCommands(skill.instructions || '');
+        const requiredShKeys = rawCommands.map((cmd) => `sh:${SkillParser.substituteVariables(cmd, inputs)}`);
+        const data = {
+            skill,
+            inputs,
+            required_sh_keys: requiredShKeys,
+            shell_outputs: {},
+        };
+        // 2. Decision Loop (D): Drive the DSL Engine until a PLAN is reached (Ping-Pong Protocol)
+        const MAX_RETRIES = 10;
+        let retries = 0;
+        while (true) {
+            if (retries++ > MAX_RETRIES) {
+                throw new Error(text.skills.maxRetriesExceeded(skill.id));
+            }
+            // Computation Phase (C): Pre-assemble the prompt for the DSL
+            const promptLines = (skill.instructions || '')
+                .split('\n')
+                .filter((line) => !line.trim().startsWith('!'));
+            data.prompt = SkillParser.substituteVariables(promptLines.join('\n').trim(), inputs);
+            const dslCtx = {
+                ...ctx,
+                data,
+                skillId: skill.id,
+                path: skill.path,
+            };
+            const engine = new DecisionEngine(dslCtx, new PlanBuilder());
+            const result = SkillStrategyDSL(engine).build();
+            if (result.type === 'NEED_DATA') {
+                // COMPLIANCE: DSL-Spec-V3 Ping-Pong
+                await this.handleMissingData(result.keys ?? [result.key], data, ctx);
+                continue;
+            }
+            const plan = result.plan;
+            const injectAction = plan.actions.find((a) => a.type === 'INJECT_PROMPT');
+            return {
+                traceId: `skill-${skill.id}-${Date.now()}`,
+                skillId: skill.id,
+                inputs,
+                dynamicCommands: Object.entries(data.shell_outputs).map(([cmd, output]) => ({
+                    cmd,
+                    output: output,
+                })),
+                injectedPrompt: injectAction?.params?.prompt || '',
+                status: plan.shouldAbort ? 'FAILURE' : 'SUCCESS',
+            };
+        }
+    }
+    async handleMissingData(keys, data, ctx) {
+        for (const key of keys) {
+            if (key.startsWith('sh:')) {
+                const command = key.slice(3);
+                const output = await this.executeCommand(command, ctx);
+                data.shell_outputs[command] = output;
+                data[key] = output; // Satisfy DecisionEngine dependency
+            }
+        }
+    }
+    /**
+     * Action (A): Physical Shell execution
+     */
+    async executeCommand(command, ctx) {
+        if (ctx.dryRun)
+            return `[DRY_RUN] Executing: ${command}`;
+        try {
+            const shell = getPlatformShellInvocation(command);
+            const { stdout } = await execa(shell.file, shell.args, {
+                cwd: ctx.repoRoot,
+                env: {
+                    ...process.env,
+                    SALMONLOOP_REPO_ROOT: ctx.repoRoot,
+                    SALMONLOOP_ATTEMPT_ID: String(ctx.attemptId),
+                },
+            });
+            return stdout.trim();
+        }
+        catch (error) {
+            return `Error: ${error instanceof Error ? error.message : String(error)}`;
+        }
+    }
+}
+//# sourceMappingURL=MicroTaskRunner.js.map

package/dist/core/skills/runtime/SkillRunner.js

@@ -0,0 +1,108 @@
+import * as crypto from 'crypto';
+import { MicroTaskRunner } from '../../grizzco/dsl/MicroTaskRunner.js';
+import { Phase } from '../../types/index.js';
+import { SkillParser } from '../parser.js';
+import { SkillStrategyDSL } from '../strategy.js';
+function buildStableId(parts) {
+    return crypto.createHash('sha256').update(parts.join('\n')).digest('hex').slice(0, 16);
+}
+function formatShellTranscript(shellOutputs) {
+    const entries = Object.entries(shellOutputs);
+    if (entries.length === 0)
+        return '';
+    const lines = [];
+    lines.push('');
+    lines.push('## Skill Shell Outputs');
+    for (const [cmd, out] of entries) {
+        lines.push('');
+        lines.push(`$ ${cmd}`);
+        lines.push(out ? out : '(no output)');
+    }
+    return lines.join('\n');
+}
+/**
+ * Execute a skill using the Grizzco MicroTaskRunner (DSL-Spec-V3 Ping-Pong).
+ *
+ * - Computation layer: parses instructions, extracts shell dependencies, assembles prompt.
+ * - Decision layer: SkillStrategyDSL declares required keys and emits INJECT_PROMPT.
+ * - Action layer: resolves sh:* keys through ToolRouter (governed + auditable).
+ */
+export async function executeSkill(options) {
+    const { skill, argsText, toolRouter, toolCtx, signal } = options;
+    const inputs = { args: argsText ?? '' };
+    const rawCommands = SkillParser.extractCommands(skill.instructions || '');
+    const requiredShKeys = rawCommands.map((cmd) => `sh:${SkillParser.substituteVariables(cmd, inputs)}`);
+    const data = {
+        skill,
+        inputs,
+        required_sh_keys: requiredShKeys,
+        shell_outputs: {},
+    };
+    const ctx = {
+        data,
+        skillId: skill.id,
+        path: skill.path,
+    };
+    const runner = new MicroTaskRunner({
+        debugLabel: `SkillRunner:${skill.id}`,
+        maxRounds: 10,
+        strategy: (engine) => {
+            // Computation phase: assemble a prompt without any "!..." lines.
+            const promptLines = (skill.instructions || '')
+                .split('\n')
+                .filter((line) => !line.trim().startsWith('!'));
+            const basePrompt = SkillParser.substituteVariables(promptLines.join('\n').trim(), inputs);
+            const transcript = formatShellTranscript(data.shell_outputs);
+            data.prompt = `${basePrompt}${transcript}`.trim();
+            SkillStrategyDSL(engine);
+            return engine;
+        },
+        resolveData: async (_ctx, key) => {
+            if (!key.startsWith('sh:')) {
+                return undefined;
+            }
+            const command = key.slice(3);
+            const callId = `slash-sh-${buildStableId([skill.id, command])}`;
+            const envelope = {
+                id: callId,
+                phase: Phase.SLASH,
+                toolName: 'shell.exec',
+                args: { command },
+                ctx: {
+                    ...toolCtx,
+                    // Ensure ToolPolicy sees worktree isolation for process execution.
+                    worktreeRoot: toolCtx.worktreeRoot ?? toolCtx.repoRoot,
+                },
+            };
+            let result = await toolRouter.call(envelope);
+            if (result.status === 'denied' && result.error?.code === 'AUTH_REQUIRED') {
+                await toolRouter.waitForAuthorization(callId, signal);
+                result = await toolRouter.call(envelope);
+            }
+            if (result.status !== 'ok') {
+                const msg = result.error?.message || 'shell.exec failed';
+                throw new Error(msg);
+            }
+            const output = result.output;
+            const combined = [output.stdout, output.stderr].filter(Boolean).join('\n').trim();
+            data.shell_outputs[command] = combined;
+            data[key] = combined;
+            return combined;
+        },
+    });
+    const decided = await runner.decide(ctx);
+    const plan = decided.plan;
+    const inject = plan.actions.find((a) => a.type === 'INJECT_PROMPT');
+    return {
+        traceId: `skill-${skill.id}-${Date.now()}`,
+        skillId: skill.id,
+        inputs,
+        dynamicCommands: Object.entries(data.shell_outputs).map(([cmd, output]) => ({
+            cmd,
+            output: String(output),
+        })),
+        injectedPrompt: String(inject?.params?.prompt ?? ''),
+        status: plan.shouldAbort ? 'FAILURE' : 'SUCCESS',
+    };
+}
+//# sourceMappingURL=SkillRunner.js.map

package/dist/core/skills/strategy.js

@@ -0,0 +1,29 @@
+/**
+ * SkillStrategyDSL implements the skill decision logic using the project's standard DecisionEngine.
+ * COMPLIANCE: DSL-Spec-V3 (Bifrost Architecture)
+ * 1. Purity: The DSL ONLY evaluates rules and declares dependencies.
+ * 2. No Logic: Computation (string manipulation, parsing) is forbidden here.
+ */
+export const SkillStrategyDSL = (engine) => {
+    return (engine
+        .phase('Context Discovery')
+        .require((c) => !!c.data.skill, 'No skill context provided')
+        .require((c) => !!c.data.skill.instructions, 'Skill has no instructions')
+        .phase('Dynamic Data Dependencies')
+        .apply((e) => {
+        // Declarative dependencies: The list of sh: keys is pre-computed by the Computation layer.
+        const keys = e.ctx.data.required_sh_keys || [];
+        for (const key of keys) {
+            e.requireData(key);
+        }
+        return e;
+    })
+        .phase('Prompt Assembly')
+        // The DSL only decides WHICH worker to use.
+        .when((c) => !!c.data.prompt, (p) => {
+        const prompt = engine.ctx.data.prompt;
+        p.setWorker('skill-prompt-assembler');
+        p.addAction('INJECT_PROMPT', { prompt });
+    }));
+};
+//# sourceMappingURL=strategy.js.map

package/dist/core/skills/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/core/slash/index.js

@@ -0,0 +1,6 @@
+export * from './types.js';
+export * from './parser.js';
+export * from './registry.js';
+export * from './strategy.js';
+export * from './router.js';
+//# sourceMappingURL=index.js.map

package/dist/core/slash/parser.js

@@ -0,0 +1,33 @@
+function parseSuggestionContext(input) {
+    const trimmed = input.trimStart();
+    const parts = trimmed.split(/\s+/);
+    const argIndex = parts.length - 1;
+    const currentPrefix = parts[argIndex] || '';
+    const isSpaceTrailing = input.endsWith(' ');
+    return { argIndex, currentPrefix, isSpaceTrailing };
+}
+export function parseSlashInput(input) {
+    const raw = input ?? '';
+    const trimmed = raw.trim();
+    const suggestion = parseSuggestionContext(raw);
+    if (!trimmed)
+        return { kind: 'text', raw, trimmed, suggestion };
+    const trimmedStart = raw.trimStart();
+    if (!trimmedStart.startsWith('/')) {
+        return { kind: 'text', raw, trimmed, suggestion };
+    }
+    const first = trimmedStart.split(/\s+/)[0] ?? '';
+    const normalized = first.toLowerCase();
+    const argsText = trimmedStart.slice(first.length).trimStart();
+    const tokens = argsText.length > 0 ? argsText.split(/\s+/) : [];
+    return {
+        kind: 'slash',
+        raw,
+        trimmed,
+        commandName: normalized,
+        argsText,
+        tokens,
+        suggestion,
+    };
+}
+//# sourceMappingURL=parser.js.map

package/dist/core/slash/registry.js

@@ -0,0 +1,78 @@
+function normalizeToken(value) {
+    return value.trim().toLowerCase();
+}
+function normalizeCommandName(name) {
+    const trimmed = name.trim();
+    if (!trimmed.startsWith('/'))
+        return `/${trimmed}`.toLowerCase();
+    return trimmed.toLowerCase();
+}
+export function createSlashRegistry(options) {
+    const conflictPolicy = options.conflictPolicy ?? 'keep_first';
+    if (conflictPolicy !== 'keep_first') {
+        throw new Error(`Unsupported conflictPolicy: ${conflictPolicy}`);
+    }
+    const diagnostics = { conflicts: [] };
+    const ordered = [...options.commands].sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+    const byName = new Map();
+    const byToken = new Map();
+    const tryRegisterToken = (token, spec, reason) => {
+        const normalized = normalizeToken(token);
+        const existing = byToken.get(normalized);
+        if (existing) {
+            diagnostics.conflicts.push({
+                existing: existing.name,
+                incoming: spec.name,
+                reason,
+                token: normalized,
+            });
+            return false;
+        }
+        byToken.set(normalized, spec);
+        return true;
+    };
+    for (const command of ordered) {
+        const normalizedName = normalizeCommandName(command.name);
+        const spec = { ...command, name: normalizedName };
+        // If the primary name conflicts, drop the command.
+        if (!tryRegisterToken(spec.name, spec, 'name')) {
+            continue;
+        }
+        // Only register aliases if the primary name succeeded.
+        for (const alias of spec.aliases ?? []) {
+            const normalizedAlias = normalizeCommandName(alias);
+            if (!tryRegisterToken(normalizedAlias, spec, 'alias')) {
+                // Alias conflict does not drop the command; it only drops that alias.
+                continue;
+            }
+        }
+        byName.set(spec.name, spec);
+    }
+    const listAll = () => Array.from(byName.values()).sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+    const suggest = (prefix) => {
+        const normalizedPrefix = normalizeCommandName(prefix || '/');
+        const commands = listAll().filter((c) => !c.hidden);
+        const matches = commands.filter((c) => {
+            const tokens = [c.name, ...(c.aliases?.map(normalizeCommandName) ?? [])];
+            return tokens.some((t) => t.startsWith(normalizedPrefix));
+        });
+        const maxNameLength = matches.reduce((max, cmd) => Math.max(max, cmd.name.length), 0);
+        return matches.map((cmd) => ({
+            name: cmd.name.padEnd(maxNameLength + 2),
+            description: cmd.description,
+            hidden: cmd.hidden,
+            order: cmd.order,
+        }));
+    };
+    return {
+        find: (commandOrAlias) => {
+            const normalized = normalizeCommandName(commandOrAlias);
+            return byToken.get(normalized);
+        },
+        list: () => listAll(),
+        suggest,
+        diagnostics: () => diagnostics,
+    };
+}
+export { normalizeCommandName };
+//# sourceMappingURL=registry.js.map